If network enumeration fails, try binding to the "ANY" address.

webrtc/p2p/client/basicportallocator_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 19 matching lines @@
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 using rtc::IPAddress;
 using rtc::SocketAddress;
 using rtc::Thread;
 
+static const SocketAddress kAnyAddr("0.0.0.0", 0);
 static const SocketAddress kClientAddr("11.11.11.11", 0);
 static const SocketAddress kClientAddr2("22.22.22.22", 0);
 static const SocketAddress kLoopbackAddr("127.0.0.1", 0);
 static const SocketAddress kPrivateAddr("192.168.1.11", 0);
 static const SocketAddress kPrivateAddr2("192.168.1.12", 0);
 static const SocketAddress kClientIPv6Addr("2401:fa00:4:1000:be30:5bff:fee5:c3",
                                            0);
 static const SocketAddress kClientIPv6Addr2(
     "2401:fa00:4:2000:be30:5bff:fee5:c3",
     0);
@@ skipping 57 matching lines @@
 }
 
 class BasicPortAllocatorTest : public testing::Test,
                                public sigslot::has_slots<> {
  public:
   BasicPortAllocatorTest()
       : pss_(new rtc::PhysicalSocketServer),
         vss_(new rtc::VirtualSocketServer(pss_.get())),
         fss_(new rtc::FirewallSocketServer(vss_.get())),
         ss_scope_(fss_.get()),
+        // Note that the NAT is not used by default. ResetWithStunServerAndNat
+        // must be called.
         nat_factory_(vss_.get(), kNatUdpAddr, kNatTcpAddr),
         nat_socket_factory_(new rtc::BasicPacketSocketFactory(&nat_factory_)),
         stun_server_(TestStunServer::Create(Thread::Current(), kStunAddr)),
         relay_server_(Thread::Current(),
                       kRelayUdpIntAddr,
                       kRelayUdpExtAddr,
                       kRelayTcpIntAddr,
                       kRelayTcpExtAddr,
                       kRelaySslTcpIntAddr,
                       kRelaySslTcpExtAddr),
         turn_server_(Thread::Current(), kTurnUdpIntAddr, kTurnUdpExtAddr),
         candidate_allocation_done_(false) {
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
     // Passing the addresses of GTURN servers will enable GTURN in
     // Basicportallocator.
+    // TODO(deadbeef): Stop using GTURN by default in this test... Either the
+    // configuration should be blank by default (preferred), or it should use
+    // TURN instead.
     allocator_.reset(new BasicPortAllocator(&network_manager_, stun_servers,
                                             kRelayUdpIntAddr, kRelayTcpIntAddr,
                                             kRelaySslTcpIntAddr));
     allocator_->set_step_delay(kMinimumStepDelay);
   }
 
   void AddInterface(const SocketAddress& addr) {
     network_manager_.AddInterface(addr);
   }
   void AddInterface(const SocketAddress& addr, const std::string& if_name) {
@@ skipping 125 matching lines @@
                         ProtocolType protocol,
                         const SocketAddress& client_addr) {
     return std::count_if(
         ports.begin(), ports.end(),
         [type, protocol, client_addr](PortInterface* port) {
           return port->Type() == type && port->GetProtocol() == protocol &&
                  port->Network()->GetBestIP() == client_addr.ipaddr();
         });
   }
 
+  static int CountCandidates(const std::vector<Candidate>& candidates,
+                             const std::string& type,
+                             const std::string& proto,
+                             const SocketAddress& addr) {
+    return std::count_if(candidates.begin(), candidates.end(),
+                         [type, proto, addr](const Candidate& c) {
+                           return c.type() == type && c.protocol() == proto &&
+                                  AddressMatch(c.address(), addr);
+                         });
+  }
+
   // Find a candidate and return it.
   static bool FindCandidate(const std::vector<Candidate>& candidates,
                             const std::string& type,
                             const std::string& proto,
                             const SocketAddress& addr,
                             Candidate* found) {
     auto it = std::find_if(candidates.begin(), candidates.end(),
                            [type, proto, addr](const Candidate& c) {
                              return c.type() == type && c.protocol() == proto &&
                                     AddressMatch(c.address(), addr);
@@ skipping 463 matching lines @@
   // Wi-Fi interface.
   candidates_.clear();
   candidate_allocation_done_ = false;
   AddInterface(addr_wifi, "test_wlan0", rtc::ADAPTER_TYPE_WIFI);
   session_->StartGettingPorts();
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_EQ(1U, candidates_.size());
   EXPECT_TRUE(addr_wifi.EqualIPs(candidates_[0].address()));
 }
 
-// Tests that we allocator session not trying to allocate ports for every 250ms.
-TEST_F(BasicPortAllocatorTest, TestNoNetworkInterface) {
-  EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
-  session_->StartGettingPorts();
-  // Waiting for one second to make sure BasicPortAllocatorSession has not
-  // called OnAllocate multiple times. In old behavior it's called every 250ms.
-  // When there are no network interfaces, each execution of OnAllocate will
-  // result in SignalCandidatesAllocationDone signal.
-  rtc::Thread::Current()->ProcessMessages(1000);
-  EXPECT_TRUE(candidate_allocation_done_);
-  EXPECT_EQ(0U, candidates_.size());
-}
-
 // Test that we could use loopback interface as host candidate.
 TEST_F(BasicPortAllocatorTest, TestLoopbackNetworkInterface) {
   AddInterface(kLoopbackAddr, "test_loopback", rtc::ADAPTER_TYPE_LOOPBACK);
   allocator_->SetNetworkIgnoreMask(0);
   EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
   session_->set_flags(PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY |
                       PORTALLOCATOR_DISABLE_TCP);
   session_->StartGettingPorts();
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_EQ(1U, candidates_.size());
@@ skipping 145 matching lines @@
       ++num_nonrelay_candidates;
     }
   }
   EXPECT_EQ(3, num_nonrelay_candidates);
   // Check the port number used to connect to the relay server.
   EXPECT_PRED3(CheckPort, relay_server_.GetConnection(0).source(), kMinPort,
                kMaxPort);
   EXPECT_TRUE(candidate_allocation_done_);
 }
 
-// Test that we don't crash or malfunction if we have no network adapters.
+// Test that if we have no network adapters, we bind to the ANY address and
+// still get non-host candidates.
 TEST_F(BasicPortAllocatorTest, TestGetAllPortsNoAdapters) {
+  // Default config uses GTURN and no NAT, so replace that with the
+  // desired setup (NAT, STUN server, TURN server, UDP/TCP).
+  ResetWithStunServerAndNat(kStunAddr);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
+  AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
+  AddTurnServers(kTurnUdpIntIPv6Addr, kTurnTcpIntIPv6Addr);
+  // Disable IPv6, because our test infrastructure doesn't support having IPv4
+  // behind a NAT but IPv6 not, or having an IPv6 NAT.
+  // TODO(deadbeef): Fix this.
+  network_manager_.set_ipv6_enabled(false);
   EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
-  rtc::Thread::Current()->ProcessMessages(100);
-  // Without network adapter, we should not get any candidate.
-  EXPECT_EQ(0U, candidates_.size());
-  EXPECT_TRUE(candidate_allocation_done_);
+  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+  EXPECT_EQ(4U, ports_.size());
+  EXPECT_EQ(1, CountPorts(ports_, "stun", PROTO_UDP, kAnyAddr));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kAnyAddr));
+  // Two TURN ports, using UDP/TCP for the first hop to the TURN server.
+  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kAnyAddr));
+  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_TCP, kAnyAddr));
+  // The "any" address port should be in the signaled ready ports, but the host
+  // candidate for it is useless and shouldn't be signaled. So we only have
+  // STUN/TURN candidates.
+  EXPECT_EQ(3U, candidates_.size());
+  EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp",
+               rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0));
+  // Again, two TURN candidates, using UDP/TCP for the first hop to the TURN
+  // server.
+  EXPECT_EQ(2,
+            CountCandidates(candidates_, "relay", "udp",
+                            rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
 }
 
 // Test that when enumeration is disabled, we should not have any ports when
 // candidate_filter() is set to CF_RELAY and no relay is specified.
 TEST_F(BasicPortAllocatorTest,
        TestDisableAdapterEnumerationWithoutNatRelayTransportOnly) {
   ResetWithStunServerNoNat(kStunAddr);
   allocator().set_candidate_filter(CF_RELAY);
   // Expect to see no ports and no candidates.
   CheckDisableAdapterEnumeration(0U, rtc::IPAddress(), rtc::IPAddress(),
@@ skipping 839 matching lines @@
   for (const Candidate& candidate : candidates) {
     // Expect only relay candidates now that the filter is applied.
     EXPECT_EQ(std::string(RELAY_PORT_TYPE), candidate.type());
     // Expect that the raddr is emptied due to the CF_RELAY filter.
     EXPECT_EQ(candidate.related_address(),
               rtc::EmptySocketAddressWithFamily(candidate.address().family()));
   }
 }
 
 }  // namespace cricket