Really connect to the same server in FTP network transaction.

net/socket/ssl_client_socket_mac.cc

 // Copyright (c) 2008-2009 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/ssl_client_socket_mac.h"
 
 #include <CoreServices/CoreServices.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/types.h>
 
 #include "base/scoped_cftyperef.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
+#include "net/base/address_list.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_info.h"
 
 // Welcome to Mac SSL. We've been waiting for you.
 //
 // The Mac SSL implementation is, like the Windows and NSS implementations, a
@@ skipping 550 matching lines @@
   // Unlike IsConnected, this method doesn't return a false positive.
   //
   // Strictly speaking, we should check if we have received the close_notify
   // alert message from the server, and return false in that case.  Although
   // the close_notify alert message means EOF in the SSL layer, it is just
   // bytes to the transport layer below, so transport_->IsConnectedAndIdle()
   // returns the desired false when we receive close_notify.
   return completed_handshake_ && transport_->IsConnectedAndIdle();
 }
 
-int SSLClientSocketMac::GetPeerName(struct sockaddr* name, socklen_t* namelen) {
-  return transport_->GetPeerName(name, namelen);
+int SSLClientSocketMac::GetPeerAddress(AddressList* address) const {
+  return transport_->GetPeerAddress(address);
 }
 
 int SSLClientSocketMac::Read(IOBuffer* buf, int buf_len,
                              CompletionCallback* callback) {
   DCHECK(completed_handshake_);
   DCHECK(!user_read_callback_);
   DCHECK(!user_read_buf_);
 
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
@@ skipping 144 matching lines @@
                                        kSSLSessionOptionBreakOnCertRequested,
                                        true);
     if (status)
       return NetErrorFromOSStatus(status);
 
     // Concatenate the hostname and peer address to use as the peer ID. To
     // resume a session, we must connect to the same server on the same port
     // using the same hostname (i.e., localhost and 127.0.0.1 are considered
     // different peers, which puts us through certificate validation again
     // and catches hostname/certificate name mismatches.
-    struct sockaddr_storage addr;
-    socklen_t addr_length = sizeof(struct sockaddr_storage);
-    memset(&addr, 0, sizeof(addr));
-    if (!transport_->GetPeerName(reinterpret_cast<struct sockaddr*>(&addr),
-                                 &addr_length)) {
-      // Assemble the socket hostname and address into a single buffer.
-      std::vector<char> peer_id(hostname_.begin(), hostname_.end());
-      peer_id.insert(peer_id.end(), reinterpret_cast<char*>(&addr),
-                     reinterpret_cast<char*>(&addr) + addr_length);
+    AddressList address;
+    int rv = transport_->GetPeerAddress(&address);
+    if (rv != OK)
+      return rv;
+    const struct addrinfo* ai = address.head();
+    std::string peer_id(hostname_);
+    peer_id += std::string(reinterpret_cast<char*>(ai->ai_addr),
+                           ai->ai_addrlen);
 
-      // SSLSetPeerID() treats peer_id as a binary blob, and makes its
-      // own copy.
-      status = SSLSetPeerID(ssl_context_, &peer_id[0], peer_id.size());
-      if (status)
-        return NetErrorFromOSStatus(status);
-    }
+    // SSLSetPeerID() treats peer_id as a binary blob, and makes its
+    // own copy.
+    status = SSLSetPeerID(ssl_context_, peer_id.data(), peer_id.length());
+    if (status)
+      return NetErrorFromOSStatus(status);
   } else {
     // If I can't break on cert-requested, then set the cert up-front:
     status = SetClientCert();
     if (status)
       return NetErrorFromOSStatus(status);
   }
 
   return OK;
 }
 
@@ skipping 390 matching lines @@
   if (rv < 0 && rv != ERR_IO_PENDING) {
     us->write_io_buf_ = NULL;
     return OSStatusFromNetError(rv);
   }
 
   // always lie to our caller
   return noErr;
 }
 
 }  // namespace net