Handle unresolved remote hostname for TCP sockets.

content/renderer/p2p/ipc_socket_factory.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 "content/renderer/p2p/ipc_socket_factory.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/compiler_specific.h"
@@ skipping 75 matching lines @@
                      const talk_base::SocketAddress& addr,
                      const talk_base::PacketOptions& options) OVERRIDE;
   virtual int Close() OVERRIDE;
   virtual State GetState() const OVERRIDE;
   virtual int GetOption(talk_base::Socket::Option option, int* value) OVERRIDE;
   virtual int SetOption(talk_base::Socket::Option option, int value) OVERRIDE;
   virtual int GetError() const OVERRIDE;
   virtual void SetError(int error) OVERRIDE;
 
   // P2PSocketClientDelegate implementation.
-  virtual void OnOpen(const net::IPEndPoint& address) OVERRIDE;
+  virtual void OnOpen(const net::IPEndPoint& address,
+                      const net::IPEndPoint& remote_address) OVERRIDE;
   virtual void OnIncomingTcpConnection(
       const net::IPEndPoint& address,
       P2PSocketClient* client) OVERRIDE;
   virtual void OnSendComplete() OVERRIDE;
   virtual void OnError() OVERRIDE;
   virtual void OnDataReceived(const net::IPEndPoint& address,
                               const std::vector<char>& data,
                               const base::TimeTicks& timestamp) OVERRIDE;
 
  private:
@@ skipping 119 matching lines @@
   local_address_ = local_address;
   remote_address_ = remote_address;
   state_ = IS_OPENING;
 
   net::IPEndPoint local_endpoint;
   if (!jingle_glue::SocketAddressToIPEndPoint(
           local_address, &local_endpoint)) {
     return false;
   }
 
+  if (remote_address.IsNil()) {
+    return false;
+  }
+
   net::IPEndPoint remote_endpoint;
-  if (!remote_address.IsNil() &&
-      !jingle_glue::SocketAddressToIPEndPoint(
-          remote_address, &remote_endpoint)) {
+  if (!jingle_glue::SocketAddressToIPEndPoint(
+      remote_address, &remote_endpoint) && !IsTcpClientSocket(type_)) {
+    // Non TCP sockets must have a resolved remote address.
     return false;
   }
 
   // We need to send both resolved and unresolved address in Init. Unresolved
   // address will be used in case of TLS for certificate hostname matching.
   // Certificate will be tied to domain name not to IP address.
   P2PHostAndIPEndPoint remote_info(remote_address.hostname(), remote_endpoint);
 
   client->Init(type, local_endpoint, remote_info, this);
 
@@ skipping 169 matching lines @@
 int IpcPacketSocket::GetError() const {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   return error_;
 }
 
 void IpcPacketSocket::SetError(int error) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   error_ = error;
 }
 
-void IpcPacketSocket::OnOpen(const net::IPEndPoint& address) {
+void IpcPacketSocket::OnOpen(const net::IPEndPoint& address,
+                             const net::IPEndPoint& remote_address) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   if (!jingle_glue::IPEndPointToSocketAddress(address, &local_address_)) {
     // Always expect correct IPv4 address to be allocated.
     NOTREACHED();
     OnError();
     return;
   }
 
   state_ = IS_OPEN;
   TraceSendThrottlingState();
 
   // Set all pending options if any.
   for (int i = 0; i < P2P_SOCKET_OPT_MAX; ++i) {
     if (options_[i] != kDefaultNonSetOptionValue)
       DoSetOption(static_cast<P2PSocketOption> (i), options_[i]);
   }
 
   SignalAddressReady(this, local_address_);
-  if (IsTcpClientSocket(type_))
+  if (IsTcpClientSocket(type_)) {
     SignalConnect(this);
+    // If remote address is unresolved, set resolved remote IP address received
+    // in the callback. This address will be used while sending the packets
+    // over the network.
+    if (remote_address_.IsUnresolvedIP()) {
+      talk_base::SocketAddress jingle_socket_address;
+      if (!jingle_glue::IPEndPointToSocketAddress(
+            remote_address, &jingle_socket_address)) {
+        NOTREACHED();
+      }
+      // Set only the IP address.
+      remote_address_.SetResolvedIP(jingle_socket_address.ipaddr());
+    }
+  }
 }
 
 void IpcPacketSocket::OnIncomingTcpConnection(
     const net::IPEndPoint& address,
     P2PSocketClient* client) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   scoped_ptr<IpcPacketSocket> socket(new IpcPacketSocket());
 
   talk_base::SocketAddress remote_address;
@@ skipping 186 matching lines @@
 }
 
 talk_base::AsyncResolverInterface*
 IpcPacketSocketFactory::CreateAsyncResolver() {
   scoped_ptr<AsyncAddressResolverImpl> resolver(
     new AsyncAddressResolverImpl(socket_dispatcher_));
   return resolver.release();
 }
 
 }  // namespace content