Reimplements net::AddressList without struct addrinfo.

net/socket/socks_client_socket.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/socks_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/sys_byteorder.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/socket/client_socket_handle.h"
 
 namespace net {
 
 // Every SOCKS server requests a user-id from the client. It is optional
 // and we send an empty string.
 static const char kEmptyUserId[] = "";
 
 // For SOCKS4, the client sends 8 bytes  plus the size of the user-id.
 static const unsigned int kWriteHeaderSize = 8;
@@ skipping 275 matching lines @@
   return OK;
 }
 
 // Builds the buffer that is to be sent to the server.
 const std::string SOCKSClientSocket::BuildHandshakeWriteBuffer() const {
   SOCKS4ServerRequest request;
   request.version = kSOCKSVersion4;
   request.command = kSOCKSStreamRequest;
   request.nw_port = base::HostToNet16(host_request_info_.port());
 
-  const struct addrinfo* ai = addresses_.head();
-  DCHECK(ai);
+  DCHECK(!addresses_.empty());
+  const IPEndPoint& ipe = addresses_.front();
 
   // We disabled IPv6 results when resolving the hostname, so none of the
   // results in the list will be IPv6.
   // TODO(eroman): we only ever use the first address in the list. It would be
   //               more robust to try all the IP addresses we have before
   //               failing the connect attempt.
-  CHECK_EQ(AF_INET, ai->ai_addr->sa_family);
-  struct sockaddr_in* ipv4_host =
-      reinterpret_cast<struct sockaddr_in*>(ai->ai_addr);
-  memcpy(&request.ip, &ipv4_host->sin_addr, sizeof(ipv4_host->sin_addr));
+  CHECK_EQ(AF_INET, ipe.GetFamily());
+  memcpy(&request.ip, &ipe.address()[0], ipe.address().size());

[eroman, 2012/05/04 01:08:41]

I'm not sure how I feel about this... The assumption is IPAddressNumber stores
things in network order.

I would rather explicitly convert this to sockaddr, and then memcpy using that
as the source.

[szym, 2012/05/04 02:38:29]

Currently, IPAddressNumber stores data in same order as sockaddr. Do you suggest
we should treat IPAddressNumber as opaque and always convert to sockaddr and
using platform APIs for answering questions like "is this 127.0.0.1"?

I think we'd be better off specifying that order in IPAddressNumber is same as
in sockaddr (i.e., network order). IPEndPoint::{To,From}SockAddr already assume
that. I'm not even sure how the order could be different.

[eroman, 2012/05/04 04:20:22]

My paranoia stems from doing a memcpy() from a source of unknown size.
I guess I would be placated if you could add something like this:

CHECK_LE(ip.address().size(), sizeof(request.ip));

the "CHECK_EQ(AF_INET, ipe.GetFamily())" above should presumably cover this as
well, but I think a more direct test is worthwhile.

 
-  DVLOG(1) << "Resolved Host is : " << NetAddressToString(ai);
+  DVLOG(1) << "Resolved Host is : " << ipe.ToStringWithoutPort();
 
   std::string handshake_data(reinterpret_cast<char*>(&request),
                              sizeof(request));
   handshake_data.append(kEmptyUserId, arraysize(kEmptyUserId));
 
   return handshake_data;
 }
 
 // Writes the SOCKS handshake data to the underlying socket connection.
 int SOCKSClientSocket::DoHandshakeWrite() {
@@ skipping 101 matching lines @@
 
 int SOCKSClientSocket::GetPeerAddress(AddressList* address) const {
   return transport_->socket()->GetPeerAddress(address);
 }
 
 int SOCKSClientSocket::GetLocalAddress(IPEndPoint* address) const {
   return transport_->socket()->GetLocalAddress(address);
 }
 
 }  // namespace net