Bug 4865: Enable connectivity when the remote peer is on public internet.

webrtc/p2p/client/portallocator_unittest.cc

 /*
  *  Copyright 2009 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.
  */
 
@@ skipping 101 matching lines @@
   }
   void AddInterfaceAsDefaultRoute(const SocketAddress& addr) {
     AddInterface(addr);
     // When a binding comes from the any address, the |addr| will be used as the
     // srflx address.
     vss_->SetDefaultRoute(addr.ipaddr());
   }
   bool SetPortRange(int min_port, int max_port) {
     return allocator_->SetPortRange(min_port, max_port);
   }
-  // No STUN/TURN configuration.
-  void ResetWithNoServers() {
+  // Endpoint is on the public network. No STUN or TURN.
+  void ResetWithNoServersOrNat() {
     allocator_.reset(new cricket::BasicPortAllocator(&network_manager_));
     allocator_->set_step_delay(cricket::kMinimumStepDelay);
   }
-  void ResetWithNatServer(const rtc::SocketAddress& stun_server) {
-    nat_server_.reset(new rtc::NATServer(
-        rtc::NAT_OPEN_CONE, vss_.get(), kNatUdpAddr, kNatTcpAddr, vss_.get(),
-        rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
-
-    ServerAddresses stun_servers;
-    if (!stun_server.IsNil()) {
-      stun_servers.insert(stun_server);
-    }
-    allocator_.reset(new cricket::BasicPortAllocator(
-        &network_manager_, nat_socket_factory_.get(), stun_servers));
-    allocator().set_step_delay(cricket::kMinimumStepDelay);
+  // Endpoint is behind a NAT, with STUN specified.
+  void ResetWithStunServerAndNat(const rtc::SocketAddress& stun_server) {
+    ResetWithStunServer(stun_server, true);
   }
-
-  void ResetWithStunServer(const rtc::SocketAddress& stun_server) {
-    nat_socket_factory_.reset(new rtc::BasicPacketSocketFactory());
-
-    ServerAddresses stun_servers;
-    if (!stun_server.IsNil()) {
-      stun_servers.insert(stun_server);
-    }
-    allocator_.reset(new cricket::BasicPortAllocator(
-        &network_manager_, nat_socket_factory_.get(), stun_servers));
-    allocator().set_step_delay(cricket::kMinimumStepDelay);
+  // Endpoint is on the public network, with STUN specified.
+  void ResetWithStunServerNoNat(const rtc::SocketAddress& stun_server) {
+    ResetWithStunServer(stun_server, false);
   }
-
-  // Create a BasicPortAllocator without GTURN and add the TURN servers.
-  void ResetWithTurnServers(const rtc::SocketAddress& udp_turn,
-                            const rtc::SocketAddress& tcp_turn) {
-    allocator_.reset(new cricket::BasicPortAllocator(&network_manager_));
-    allocator().set_step_delay(cricket::kMinimumStepDelay);
+  // Endpoint is on the public network, with TURN specified.
+  void ResetWithTurnServersNoNat(const rtc::SocketAddress& udp_turn,
+                                 const rtc::SocketAddress& tcp_turn) {
+    ResetWithNoServersOrNat();
     AddTurnServers(udp_turn, tcp_turn);
   }
 
   void AddTurnServers(const rtc::SocketAddress& udp_turn,
                       const rtc::SocketAddress& tcp_turn) {
     cricket::RelayServerConfig relay_server(cricket::RELAY_TURN);
     cricket::RelayCredentials credentials(kTurnUsername, kTurnPassword);
     relay_server.credentials = credentials;
 
     if (!udp_turn.IsNil()) {
@@ skipping 99 matching lines @@
       const rtc::IPAddress& relay_candidate_tcp_transport_addr) {
     EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
     session_->set_flags(cricket::PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
     allocator().set_allow_tcp_listen(false);
     session_->StartGettingPorts();
     EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
 
     uint32 total_candidates = 0;
-    if (!IPIsUnspec(stun_candidate_addr)) {
+    if (!stun_candidate_addr.IsNil()) {
       ++total_candidates;
       EXPECT_PRED5(CheckCandidate, candidates_[0],
                    cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp",
                    rtc::SocketAddress(stun_candidate_addr, 0));
       EXPECT_EQ(
           rtc::EmptySocketAddressWithFamily(candidates_[0].address().family()),
           candidates_[0].related_address());
     }
-    if (!IPIsUnspec(relay_candidate_udp_transport_addr)) {
+    if (!relay_candidate_udp_transport_addr.IsNil()) {
       ++total_candidates;
       EXPECT_PRED5(CheckCandidate, candidates_[1],
                    cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp",
                    rtc::SocketAddress(relay_candidate_udp_transport_addr, 0));
       EXPECT_EQ(stun_candidate_addr, candidates_[1].related_address().ipaddr());
     }
-    if (!IPIsUnspec(relay_candidate_tcp_transport_addr)) {
+    if (!relay_candidate_tcp_transport_addr.IsNil()) {
       ++total_candidates;
       EXPECT_PRED5(CheckCandidate, candidates_[2],
                    cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp",
                    rtc::SocketAddress(relay_candidate_tcp_transport_addr, 0));
       EXPECT_EQ(stun_candidate_addr, candidates_[2].related_address().ipaddr());
     }
 
     EXPECT_EQ(total_candidates, candidates_.size());
     EXPECT_EQ(total_ports, ports_.size());
   }
@@ skipping 23 matching lines @@
       for (relay_port = server_config.ports.begin();
           relay_port != server_config.ports.end(); ++relay_port) {
         if (proto_addr.address == relay_port->address &&
             proto_addr.proto == relay_port->proto)
           return true;
       }
     }
     return false;
   }
 
+  void ResetWithStunServer(const rtc::SocketAddress& stun_server,
+                           bool with_nat) {
+    if (with_nat) {
+      nat_server_.reset(new rtc::NATServer(
+          rtc::NAT_OPEN_CONE, vss_.get(), kNatUdpAddr, kNatTcpAddr, vss_.get(),
+          rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
+    } else {
+      nat_socket_factory_.reset(new rtc::BasicPacketSocketFactory());
+    }
+
+    ServerAddresses stun_servers;
+    if (!stun_server.IsNil()) {
+      stun_servers.insert(stun_server);
+    }
+    allocator_.reset(new cricket::BasicPortAllocator(
+        &network_manager_, nat_socket_factory_.get(), stun_servers));
+    allocator().set_step_delay(cricket::kMinimumStepDelay);
+  }
+
   rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
   rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
   rtc::scoped_ptr<rtc::FirewallSocketServer> fss_;
   rtc::SocketServerScope ss_scope_;
   rtc::scoped_ptr<rtc::NATServer> nat_server_;
   rtc::NATSocketFactory nat_factory_;
   rtc::scoped_ptr<rtc::BasicPacketSocketFactory> nat_socket_factory_;
   rtc::scoped_ptr<cricket::TestStunServer> stun_server_;
   cricket::TestRelayServer relay_server_;
   cricket::TestTurnServer turn_server_;
@@ skipping 151 matching lines @@
   // Without network adapter, we should not get any candidate.
   EXPECT_EQ(0U, candidates_.size());
   EXPECT_TRUE(candidate_allocation_done_);
 }
 
 // Test that we should only get STUN and TURN candidates when adapter
 // enumeration is disabled.
 TEST_F(PortAllocatorTest, TestDisableAdapterEnumerationBehindNat) {
   AddInterface(kClientAddr);
   // GTURN is not configured here.
-  ResetWithNatServer(kStunAddr);
+  ResetWithStunServerAndNat(kStunAddr);
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
   // Expect to see 3 ports: STUN, TURN/UDP and TCP ports, and both STUN and
   // TURN/UDP candidates.
   CheckDisableAdapterEnumeration(3U, kNatUdpAddr.ipaddr(),
                                  kTurnUdpExtAddr.ipaddr(), rtc::IPAddress());
 }
 
 // Test that even with multiple interfaces, the result should still be one STUN
 // and one TURN candidate since we bind to any address (i.e. all 0s).
 TEST_F(PortAllocatorTest,
        TestDisableAdapterEnumerationBehindNatMultipleInterfaces) {
   AddInterface(kPrivateAddr);
   AddInterface(kPrivateAddr2);
-  ResetWithNatServer(kStunAddr);
+  ResetWithStunServerAndNat(kStunAddr);
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
   // Expect to see 3 ports: STUN, TURN/UDP and TCP ports, and both STUN and
   // TURN/UDP candidates.
   CheckDisableAdapterEnumeration(3U, kNatUdpAddr.ipaddr(),
                                  kTurnUdpExtAddr.ipaddr(), rtc::IPAddress());
 }
 
 // Test that we should get STUN, TURN/UDP and TURN/TCP candidates when a
 // TURN/TCP server is specified.
 TEST_F(PortAllocatorTest, TestDisableAdapterEnumerationBehindNatWithTcp) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
   AddInterface(kClientAddr);
   // GTURN is not configured here.
-  ResetWithNatServer(kStunAddr);
+  ResetWithStunServerAndNat(kStunAddr);
   AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
   // Expect to see 4 ports - STUN, TURN/UDP, TURN/TCP and TCP port. STUN,
   // TURN/UDP, and TURN/TCP candidates.
   CheckDisableAdapterEnumeration(4U, kNatUdpAddr.ipaddr(),
                                  kTurnUdpExtAddr.ipaddr(),
                                  kTurnUdpExtAddr.ipaddr());
 }
 
 // Test that we should only get STUN and TURN candidates when adapter
 // enumeration is disabled. Since the endpoint is not behind NAT, the srflx
 // address should be the public client interface.
 TEST_F(PortAllocatorTest, TestDisableAdapterEnumerationWithoutNat) {
   AddInterfaceAsDefaultRoute(kClientAddr);
-  ResetWithStunServer(kStunAddr);
+  ResetWithStunServerNoNat(kStunAddr);
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
   // Expect to see 3 ports: STUN, TURN/UDP and TCP ports, but only both STUN and
   // TURN candidates. The STUN candidate should have kClientAddr as srflx
   // address, and TURN candidate with kClientAddr as the related address.
   CheckDisableAdapterEnumeration(3U, kClientAddr.ipaddr(),
                                  kTurnUdpExtAddr.ipaddr(), rtc::IPAddress());
 }
 
 // Test that when adapter enumeration is disabled, for endpoints without
 // STUN/TURN specified, no candidate is generated.
 TEST_F(PortAllocatorTest, TestDisableAdapterEnumerationWithoutNatOrServers) {
   AddInterfaceAsDefaultRoute(kClientAddr);
-  ResetWithNoServers();
+  ResetWithNoServersOrNat();
   // Expect to see 2 ports: STUN and TCP ports, but no candidate.
   CheckDisableAdapterEnumeration(2U, rtc::IPAddress(), rtc::IPAddress(),
                                  rtc::IPAddress());
 }
 
 // Disable for asan, see
 // https://code.google.com/p/webrtc/issues/detail?id=4743 for details.
 #if !defined(ADDRESS_SANITIZER)
 
 // Test that we can get OnCandidatesAllocationDone callback when all the ports
@@ skipping 131 matching lines @@
 }
 
 // Test ICE candidate filter mechanism with options Relay/Host/Reflexive.
 // This test also verifies that when the allocator is only allowed to use
 // relay (i.e. IceTransportsType is relay), the raddr is an empty
 // address with the correct family. This is to prevent any local
 // reflective address leakage in the sdp line.
 TEST_F(PortAllocatorTest, TestCandidateFilterWithRelayOnly) {
   AddInterface(kClientAddr);
   // GTURN is not configured here.
-  ResetWithTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+  ResetWithTurnServersNoNat(kTurnUdpIntAddr, rtc::SocketAddress());
   allocator().set_candidate_filter(cricket::CF_RELAY);
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_PRED5(CheckCandidate,
                candidates_[0],
                cricket::ICE_CANDIDATE_COMPONENT_RTP,
                "relay",
                "udp",
                rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
@@ skipping 19 matching lines @@
   EXPECT_EQ(2U, candidates_.size()); // Host UDP/TCP candidates only.
   EXPECT_EQ(2U, ports_.size()); // UDP/TCP ports only.
   for (size_t i = 0; i < candidates_.size(); ++i) {
     EXPECT_EQ(std::string(cricket::LOCAL_PORT_TYPE), candidates_[i].type());
   }
 }
 
 // Host is behind the NAT.
 TEST_F(PortAllocatorTest, TestCandidateFilterWithReflexiveOnly) {
   AddInterface(kPrivateAddr);
-  ResetWithNatServer(kStunAddr);
+  ResetWithStunServerAndNat(kStunAddr);
 
   allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
   allocator().set_candidate_filter(cricket::CF_REFLEXIVE);
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   // Host is behind NAT, no private address will be exposed. Hence only UDP
   // port with STUN candidate will be sent outside.
   EXPECT_EQ(1U, candidates_.size()); // Only STUN candidate.
@@ skipping 87 matching lines @@
   EXPECT_PRED5(CheckCandidate, candidates_[0],
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr);
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
 }
 
 // Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port
 // is allocated for udp and stun. In this test we should expect both stun and
 // local candidates as client behind a nat.
 TEST_F(PortAllocatorTest, TestSharedSocketWithNat) {
   AddInterface(kClientAddr);
-  ResetWithNatServer(kStunAddr);
+  ResetWithStunServerAndNat(kStunAddr);
 
   allocator_->set_flags(allocator().flags() |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
   ASSERT_EQ_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout);
   ASSERT_EQ(2U, ports_.size());
   EXPECT_PRED5(CheckCandidate, candidates_[0],
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr);
@@ skipping 60 matching lines @@
   session_->StartGettingPorts();
 
   EXPECT_EQ_WAIT(2U, ports_.size(), kDefaultAllocationTimeout);
 }
 
 // Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port
 // is allocated for udp/stun/turn. In this test we should expect all local,
 // stun and turn candidates.
 TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurn) {
   AddInterface(kClientAddr);
-  ResetWithNatServer(kStunAddr);
+  ResetWithStunServerAndNat(kStunAddr);
 
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
 
   allocator_->set_flags(allocator().flags() |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
                         cricket::PORTALLOCATOR_DISABLE_TCP);
 
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
@@ skipping 14 matching lines @@
   EXPECT_EQ(2U, ports_[0]->Candidates().size());
   EXPECT_EQ(1U, ports_[1]->Candidates().size());
 }
 
 // Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled and the TURN
 // server is also used as the STUN server, we should get 'local', 'stun', and
 // 'relay' candidates.
 TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurnAsStun) {
   AddInterface(kClientAddr);
   // Use an empty SocketAddress to add a NAT without STUN server.
-  ResetWithNatServer(SocketAddress());
+  ResetWithStunServerAndNat(SocketAddress());
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
 
   // Must set the step delay to 0 to make sure the relay allocation phase is
   // started before the STUN candidates are obtained, so that the STUN binding
   // response is processed when both StunPort and TurnPort exist to reproduce
   // webrtc issue 3537.
   allocator_->set_step_delay(0);
   allocator_->set_flags(allocator().flags() |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
@@ skipping 19 matching lines @@
   EXPECT_EQ(2U, ports_[0]->Candidates().size());
   EXPECT_EQ(1U, ports_[1]->Candidates().size());
 }
 
 // Test that when only a TCP TURN server is available, we do NOT use it as
 // a UDP STUN server, as this could leak our IP address. Thus we should only
 // expect two ports, a UDPPort and TurnPort.
 TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurnTcpOnly) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
   AddInterface(kClientAddr);
-  ResetWithNatServer(rtc::SocketAddress());
+  ResetWithStunServerAndNat(rtc::SocketAddress());
   AddTurnServers(rtc::SocketAddress(), kTurnTcpIntAddr);
 
   allocator_->set_flags(allocator().flags() |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
                         cricket::PORTALLOCATOR_DISABLE_TCP);
 
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
 
@@ skipping 12 matching lines @@
 }
 
 // Test that even when PORTALLOCATOR_ENABLE_SHARED_SOCKET is NOT enabled, the
 // TURN server is used as the STUN server and we get 'local', 'stun', and
 // 'relay' candidates.
 // TODO(deadbeef): Remove this test when support for non-shared socket mode
 // is removed.
 TEST_F(PortAllocatorTest, TestNonSharedSocketWithNatUsingTurnAsStun) {
   AddInterface(kClientAddr);
   // Use an empty SocketAddress to add a NAT without STUN server.
-  ResetWithNatServer(SocketAddress());
+  ResetWithStunServerAndNat(SocketAddress());
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
 
   allocator_->set_flags(allocator().flags() |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_DISABLE_TCP);
 
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
 
   ASSERT_EQ_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout);
@@ skipping 17 matching lines @@
   EXPECT_EQ(1U, ports_[1]->Candidates().size());
   EXPECT_EQ(1U, ports_[2]->Candidates().size());
 }
 
 // Test that even when both a STUN and TURN server are configured, the TURN
 // server is used as a STUN server and we get a 'stun' candidate.
 TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurnAndStun) {
   AddInterface(kClientAddr);
   // Configure with STUN server but destroy it, so we can ensure that it's
   // the TURN server actually being used as a STUN server.
-  ResetWithNatServer(kStunAddr);
+  ResetWithStunServerAndNat(kStunAddr);
   stun_server_.reset();
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
 
   allocator_->set_flags(allocator().flags() |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
                         cricket::PORTALLOCATOR_DISABLE_TCP);
 
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
@@ skipping 174 matching lines @@
   AllocationSequenceForTest alloc_sequence(
       static_cast<cricket::BasicPortAllocatorSession*>(session_.get()),
       &network1, &config, flag);
   // This simply tests it will not crash if udp_socket_ in the
   // AllocationSequence is null, which is chosen in the constructor.
   cricket::RelayServerConfig relay_server(cricket::RELAY_TURN);
   relay_server.ports.push_back(
       cricket::ProtocolAddress(kTurnUdpIntAddr, cricket::PROTO_UDP, false));
   alloc_sequence.CreateTurnPort(relay_server);
 }