Make Port (and subclasses) fully "Network"-based, instead of IP-based.

webrtc/p2p/base/turnport.cc

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/p2p/base/turnport.h"
 
+#include <algorithm>
 #include <functional>
 
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/rtc_base/asyncpacketsocket.h"
 #include "webrtc/rtc_base/byteorder.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/nethelpers.h"
 #include "webrtc/rtc_base/ptr_util.h"
@@ skipping 164 matching lines @@
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
                    int server_priority,
                    const std::string& origin)
     : Port(thread,
            RELAY_PORT_TYPE,
            factory,
            network,
-           socket->GetLocalAddress().ipaddr(),
            username,
            password),
       server_address_(server_address),
       credentials_(credentials),
       socket_(socket),
       resolver_(NULL),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
       state_(STATE_CONNECTING),
       server_priority_(server_priority),
       allocate_mismatch_retries_(0) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
   request_manager_.set_origin(origin);
 }
 
 TurnPort::TurnPort(rtc::Thread* thread,
                    rtc::PacketSocketFactory* factory,
                    rtc::Network* network,
-                   const rtc::IPAddress& ip,
                    uint16_t min_port,
                    uint16_t max_port,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
                    int server_priority,
                    const std::string& origin)
     : Port(thread,
            RELAY_PORT_TYPE,
            factory,
            network,
-           ip,
            min_port,
            max_port,
            username,
            password),
       server_address_(server_address),
       credentials_(credentials),
       socket_(NULL),
       resolver_(NULL),
       error_(0),
       request_manager_(thread),
@@ skipping 45 matching lines @@
     server_address_.address.SetPort(TURN_DEFAULT_PORT);
   }
 
   if (server_address_.address.IsUnresolvedIP()) {
     ResolveTurnAddress(server_address_.address);
   } else {
     // If protocol family of server address doesn't match with local, return.
     if (!IsCompatibleAddress(server_address_.address)) {
       LOG(LS_ERROR) << "IP address family does not match: "
                     << "server: " << server_address_.address.family()
-                    << " local: " << ip().family();
+                    << " local: " << Network()->GetBestIP().family();
       OnAllocateError();
       return;
     }
 
     // Insert the current address to prevent redirection pingpong.
     attempted_server_addresses_.insert(server_address_.address);
 
     LOG_J(LS_INFO, this) << "Trying to connect to TURN server via "
                          << ProtoToString(server_address_.proto) << " @ "
                          << server_address_.address.ToSensitiveString();
     if (!CreateTurnClientSocket()) {
       LOG(LS_ERROR) << "Failed to create TURN client socket";
       OnAllocateError();
       return;
     }
     if (server_address_.proto == PROTO_UDP) {
       // If its UDP, send AllocateRequest now.
       // For TCP and TLS AllcateRequest will be sent by OnSocketConnect.
       SendRequest(new TurnAllocateRequest(this), 0);
     }
   }
 }
 
 bool TurnPort::CreateTurnClientSocket() {
   RTC_DCHECK(!socket_ || SharedSocket());
 
   if (server_address_.proto == PROTO_UDP && !SharedSocket()) {
     socket_ = socket_factory()->CreateUdpSocket(
-        rtc::SocketAddress(ip(), 0), min_port(), max_port());
+        rtc::SocketAddress(Network()->GetBestIP(), 0), min_port(), max_port());
   } else if (server_address_.proto == PROTO_TCP ||
              server_address_.proto == PROTO_TLS) {
     RTC_DCHECK(!SharedSocket());
     int opts = rtc::PacketSocketFactory::OPT_STUN;
 
     // Apply server address TLS and insecure bits to options.
     if (server_address_.proto == PROTO_TLS) {
       if (tls_cert_policy_ ==
           TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK) {
         opts |= rtc::PacketSocketFactory::OPT_TLS_INSECURE;
       } else {
         opts |= rtc::PacketSocketFactory::OPT_TLS;
       }
     }
 
     socket_ = socket_factory()->CreateClientTcpSocket(
-        rtc::SocketAddress(ip(), 0), server_address_.address,
+        rtc::SocketAddress(Network()->GetBestIP(), 0), server_address_.address,
         proxy(), user_agent(), opts);
   }
 
   if (!socket_) {
     error_ = SOCKET_ERROR;
     return false;
   }
 
   // Apply options if any.
   for (SocketOptionsMap::iterator iter = socket_options_.begin();
@@ skipping 21 matching lines @@
   }
   return true;
 }
 
 void TurnPort::OnSocketConnect(rtc::AsyncPacketSocket* socket) {
   // This slot should only be invoked if we're using a connection-oriented
   // protocol.
   RTC_DCHECK(server_address_.proto == PROTO_TCP ||
              server_address_.proto == PROTO_TLS);
 
-  // Do not use this port if the socket bound to a different address than
-  // the one we asked for. This is seen in Chrome, where TCP sockets cannot be
-  // given a binding address, and the platform is expected to pick the
-  // correct local address.
-
+  // Do not use this port if the socket bound to an address not associated with
+  // the desired network interface. This is seen in Chrome, where TCP sockets
+  // cannot be given a binding address, and the platform is expected to pick
+  // the correct local address.
+  //
   // However, there are two situations in which we allow the bound address to
-  // differ from the requested address: 1. The bound address is the loopback
-  // address.  This happens when a proxy forces TCP to bind to only the
-  // localhost address (see issue 3927). 2. The bound address is the "any
-  // address".  This happens when multiple_routes is disabled (see issue 4780).
-  if (socket->GetLocalAddress().ipaddr() != ip()) {
+  // not be one of the addresses of the requested interface:
+  // 1. The bound address is the loopback address. This happens when a proxy
+  // forces TCP to bind to only the localhost address (see issue 3927).
+  // 2. The bound address is the "any address". This happens when
+  // multiple_routes is disabled (see issue 4780).
+  //
+  // Note that, aside from minor differences in log statements, this logic is
+  // identical to that in TcpPort.
+  const rtc::SocketAddress& socket_address = socket->GetLocalAddress();
+  const std::vector<rtc::InterfaceAddress>& desired_addresses =
+      Network()->GetIPs();
+  if (std::find(desired_addresses.begin(), desired_addresses.end(),
+                socket_address.ipaddr()) == desired_addresses.end()) {
     if (socket->GetLocalAddress().IsLoopbackIP()) {
-      LOG(LS_WARNING) << "Socket is bound to a different address:"
-                      << socket->GetLocalAddress().ipaddr().ToString()
-                      << ", rather then the local port:" << ip().ToString()
+      LOG(LS_WARNING) << "Socket is bound to the address:"
+                      << socket_address.ipaddr().ToString()
+                      << ", rather then an address associated with network:"
+                      << Network()->ToString()
                       << ". Still allowing it since it's localhost.";
-    } else if (IPIsAny(ip())) {
-      LOG(LS_WARNING) << "Socket is bound to a different address:"
-                      << socket->GetLocalAddress().ipaddr().ToString()
-                      << ", rather then the local port:" << ip().ToString()
-                      << ". Still allowing it since it's any address"
+    } else if (IPIsAny(Network()->GetBestIP())) {
+      LOG(LS_WARNING) << "Socket is bound to the address:"
+                      << socket_address.ipaddr().ToString()
+                      << ", rather then an address associated with network:"
+                      << Network()->ToString()
+                      << ". Still allowing it since it's the 'any' address"
                       << ", possibly caused by multiple_routes being disabled.";
     } else {
-      LOG(LS_WARNING) << "Socket is bound to a different address:"
-                      << socket->GetLocalAddress().ipaddr().ToString()
-                      << ", rather then the local port:" << ip().ToString()
-                      << ". Discarding TURN port.";
+      LOG(LS_WARNING) << "Socket is bound to the address:"
+                      << socket_address.ipaddr().ToString()
+                      << ", rather then an address associated with network:"
+                      << Network()->ToString() << ". Discarding TURN port.";
       OnAllocateError();
       return;
     }
   }
 
   state_ = STATE_CONNECTED;  // It is ready to send stun requests.
   if (server_address_.address.IsUnresolvedIP()) {
     server_address_.address = socket_->GetRemoteAddress();
   }
 
@@ skipping 273 matching lines @@
     if (!CreateTurnClientSocket()) {
       OnAllocateError();
     }
     return;
   }
 
   // Copy the original server address in |resolved_address|. For TLS based
   // sockets we need hostname along with resolved address.
   rtc::SocketAddress resolved_address = server_address_.address;
   if (resolver_->GetError() != 0 ||
-      !resolver_->GetResolvedAddress(ip().family(), &resolved_address)) {
+      !resolver_->GetResolvedAddress(Network()->GetBestIP().family(),
+                                     &resolved_address)) {
     LOG_J(LS_WARNING, this) << "TURN host lookup received error "
                             << resolver_->GetError();
     error_ = resolver_->GetError();
     OnAllocateError();
     return;
   }
   // Signal needs both resolved and unresolved address. After signal is sent
   // we can copy resolved address back into |server_address_|.
   SignalResolvedServerAddress(this, server_address_.address,
                               resolved_address);
@@ skipping 867 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->FailAndPruneConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->FailAndPruneConnection(ext_addr_);
 }
 }  // namespace cricket