Add config to prune TURN ports

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 21 matching lines @@
 #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 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 kClientAddr2("22.22.22.22", 0);
+static const SocketAddress kClientIPv6Addr2(
+    "2401:fa00:4:2000:be30:5bff:fee5:c3",
+    0);
 static const SocketAddress kNatUdpAddr("77.77.77.77", rtc::NAT_SERVER_UDP_PORT);
 static const SocketAddress kNatTcpAddr("77.77.77.77", rtc::NAT_SERVER_TCP_PORT);
 static const SocketAddress kRemoteClientAddr("22.22.22.22", 0);
 static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
 static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
 static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
 static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
 static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
 static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
 static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
 static const SocketAddress kTurnUdpIntAddr("99.99.99.4", 3478);
+static const SocketAddress kTurnUdpIntIPv6Addr(
+    "2402:fb00:4:1000:be30:5bff:fee5:c3",
+    3479);
 static const SocketAddress kTurnTcpIntAddr("99.99.99.5", 3478);
+static const SocketAddress kTurnTcpIntIPv6Addr(
+    "2402:fb00:4:2000:be30:5bff:fee5:c3",
+    3479);
 static const SocketAddress kTurnUdpExtAddr("99.99.99.6", 0);
 
 // Minimum and maximum port for port range tests.
 static const int kMinPort = 10000;
 static const int kMaxPort = 10099;
 
 // Based on ICE_UFRAG_LENGTH
 static const char kIceUfrag0[] = "UF00";
 // Based on ICE_PWD_LENGTH
 static const char kIcePwd0[] = "TESTICEPWD00000000000000";
@@ skipping 107 matching lines @@
     AddTurnServers(udp_turn, tcp_turn);
   }
 
   void AddTurnServers(const rtc::SocketAddress& udp_turn,
                       const rtc::SocketAddress& tcp_turn) {
     RelayServerConfig turn_server(RELAY_TURN);
     RelayCredentials credentials(kTurnUsername, kTurnPassword);
     turn_server.credentials = credentials;
 
     if (!udp_turn.IsNil()) {
-      turn_server.ports.push_back(
-          ProtocolAddress(kTurnUdpIntAddr, PROTO_UDP, false));
+      turn_server.ports.push_back(ProtocolAddress(udp_turn, PROTO_UDP, false));
     }
     if (!tcp_turn.IsNil()) {
-      turn_server.ports.push_back(
-          ProtocolAddress(kTurnTcpIntAddr, PROTO_TCP, false));
+      turn_server.ports.push_back(ProtocolAddress(tcp_turn, PROTO_TCP, false));
     }
     allocator_->AddTurnServer(turn_server);
   }
 
   bool CreateSession(int component) {
     session_ = CreateSession("session", component);
     if (!session_) {
       return false;
     }
     return true;
@@ skipping 22 matching lines @@
   std::unique_ptr<PortAllocatorSession> CreateSession(
       const std::string& sid,
       const std::string& content_name,
       int component,
       const std::string& ice_ufrag,
       const std::string& ice_pwd) {
     std::unique_ptr<PortAllocatorSession> session = allocator_->CreateSession(
         sid, content_name, component, ice_ufrag, ice_pwd);
     session->SignalPortReady.connect(this,
                                      &BasicPortAllocatorTest::OnPortReady);
+    session->SignalPortPruned.connect(this,
+                                      &BasicPortAllocatorTest::OnPortPruned);
     session->SignalCandidatesReady.connect(
         this, &BasicPortAllocatorTest::OnCandidatesReady);
     session->SignalCandidatesAllocationDone.connect(
         this, &BasicPortAllocatorTest::OnCandidatesAllocationDone);
     return session;
   }
 
   // Return true if the addresses are the same, or the port is 0 in |pattern|
   // (acting as a wildcard) and the IPs are the same.
   // Even with a wildcard port, the port of the address should be nonzero if
   // the IP is nonzero.
   static bool AddressMatch(const SocketAddress& address,
                            const SocketAddress& pattern) {
     return address.ipaddr() == pattern.ipaddr() &&
            ((pattern.port() == 0 &&
              (address.port() != 0 || IPIsAny(address.ipaddr()))) ||
             (pattern.port() != 0 && address.port() == pattern.port()));
   }
 
+  // Returns the number of ports that have matching type, protocol and
+  // address.
+  static int CountPorts(const std::vector<PortInterface*>& ports,
+                        const std::string& type,
+                        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();
+        });
+  }
+
   // 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 121 matching lines @@
   BasicPortAllocator& allocator() { return *allocator_; }
 
   void OnPortReady(PortAllocatorSession* ses, PortInterface* port) {
     LOG(LS_INFO) << "OnPortReady: " << port->ToString();
     ports_.push_back(port);
     // Make sure the new port is added to ReadyPorts.
     auto ready_ports = ses->ReadyPorts();
     EXPECT_NE(ready_ports.end(),
               std::find(ready_ports.begin(), ready_ports.end(), port));
   }
+  void OnPortPruned(PortAllocatorSession* ses, PortInterface* port) {
+    LOG(LS_INFO) << "OnPortPruned: " << port->ToString();
+    ports_.erase(std::remove(ports_.begin(), ports_.end(), port), ports_.end());
+    // Make sure the pruned port is not in ReadyPorts.
+    auto ready_ports = ses->ReadyPorts();
+    EXPECT_EQ(ready_ports.end(),
+              std::find(ready_ports.begin(), ready_ports.end(), port));
+  }
+
   void OnCandidatesReady(PortAllocatorSession* ses,
                          const std::vector<Candidate>& candidates) {
     for (const Candidate& candidate : candidates) {
       LOG(LS_INFO) << "OnCandidatesReady: " << candidate.ToString();
       // Sanity check that the ICE component is set.
       EXPECT_EQ(ICE_CANDIDATE_COMPONENT_RTP, candidate.component());
       candidates_.push_back(candidate);
     }
     // Make sure the new candidates are added to Candidates.
     auto ses_candidates = ses->ReadyCandidates();
@@ skipping 762 matching lines @@
   ASSERT_EQ(3U, ports_.size());
   EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
                rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
                rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_EQ(3U, candidates_.size());
 }
 
+// Test that if prune_turn_ports is set, TCP TurnPort will not
+// be used if UDP TurnPort is used.
+TEST_F(BasicPortAllocatorTest, TestUdpTurnPortPrunesTcpTurnPorts) {
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
+  AddInterface(kClientAddr);
+  allocator_.reset(new BasicPortAllocator(&network_manager_));
+  allocator_->SetConfiguration(allocator_->stun_servers(),
+                               allocator_->turn_servers(), 0, true);
+  AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
+  allocator_->set_step_delay(kMinimumStepDelay);
+  allocator_->set_flags(allocator().flags() |
+                        PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+                        PORTALLOCATOR_DISABLE_TCP);
+
+  EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
+  session_->StartGettingPorts();
+  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+  // Only 2 ports (one STUN and one TURN) are actually being used.
+  EXPECT_EQ(2U, session_->ReadyPorts().size());
+  // We have verified that each port, when it is added to |ports_|, it is found
+  // in |ready_ports|, and when it is pruned, it is not found in |ready_ports|,
+  // so we only need to verify the content in one of them.
+  EXPECT_EQ(2U, ports_.size());
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
+  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientAddr));
+  EXPECT_EQ(0, CountPorts(ports_, "relay", PROTO_TCP, kClientAddr));
+
+  // We don't remove candidates, so the size of |candidates_| will depend on
+  // when the TCP TURN port becomes ready. If it is ready after the UDP TURN
+  // port becomes ready, its candidates will be used there will be 3 candidates.
+  // Otherwise there will be only 2 candidates.
+  EXPECT_LE(2U, candidates_.size());
+  // There will only be 2 candidates in |ready_candidates| because it only
+  // includes the candidates in the ready ports.
+  const std::vector<Candidate>& ready_candidates = session_->ReadyCandidates();
+  EXPECT_EQ(2U, ready_candidates.size());
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
+               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+}
+
+// Tests that if prune_turn_ports is set, IPv4 TurnPort will not
+// be used if IPv6 TurnPort is used.
+TEST_F(BasicPortAllocatorTest, TestIPv6TurnPortPrunesIPv4TurnPorts) {
+  turn_server_.AddInternalSocket(kTurnUdpIntIPv6Addr, PROTO_UDP);
+  // Add two IP addresses on the same interface.
+  AddInterface(kClientAddr, "net1");
+  AddInterface(kClientIPv6Addr, "net1");
+  allocator_.reset(new BasicPortAllocator(&network_manager_));
+  allocator_->SetConfiguration(allocator_->stun_servers(),
+                               allocator_->turn_servers(), 0, true);
+  AddTurnServers(kTurnUdpIntIPv6Addr, rtc::SocketAddress());
+
+  allocator_->set_step_delay(kMinimumStepDelay);
+  allocator_->set_flags(allocator().flags() |
+                        PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+                        PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_DISABLE_TCP);
+
+  EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
+  session_->StartGettingPorts();
+  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+  // Three ports (one IPv4 STUN, one IPv6 STUN and one TURN) will be ready.
+  EXPECT_EQ(3U, session_->ReadyPorts().size());
+  EXPECT_EQ(3U, ports_.size());
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr));
+  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr));
+  EXPECT_EQ(0, CountPorts(ports_, "relay", PROTO_UDP, kClientAddr));
+
+  // We don't remove candidates, so there may be more than 3 elemenets in
+  // |candidates_|, although |ready_candidates| only includes the candidates
+  // in |ready_ports|.
+  EXPECT_LE(3U, candidates_.size());
+  const std::vector<Candidate>& ready_candidates = session_->ReadyCandidates();
+  EXPECT_EQ(3U, ready_candidates.size());
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
+               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+}
+
+// Test has an assert error on win_x64_dbg and win_dbg. See: webrtc:6068
+#if defined(WEBRTC_WIN)
+#define MAYBE_TestEachInterfaceHasItsOwnTurnPorts \
+  DISABLED_TestEachInterfaceHasItsOwnTurnPort
+#else
+#define MAYBE_TestEachInterfaceHasItsOwnTurnPorts \
+  TestEachInterfaceHasItsOwnTurnPorts
+#endif
+// Tests that if prune_turn_ports is set, each network interface
+// will has its own set of TurnPorts based on their priorities.
+TEST_F(BasicPortAllocatorTest, MAYBE_TestEachInterfaceHasItsOwnTurnPorts) {
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnUdpIntIPv6Addr, PROTO_UDP);
+  turn_server_.AddInternalSocket(kTurnTcpIntIPv6Addr, PROTO_TCP);
+  // Add two interfaces both having IPv4 and IPv6 addresses.
+  AddInterface(kClientAddr, "net1", rtc::ADAPTER_TYPE_WIFI);
+  AddInterface(kClientIPv6Addr, "net1", rtc::ADAPTER_TYPE_WIFI);
+  AddInterface(kClientAddr2, "net2", rtc::ADAPTER_TYPE_CELLULAR);
+  AddInterface(kClientIPv6Addr2, "net2", rtc::ADAPTER_TYPE_CELLULAR);
+  allocator_.reset(new BasicPortAllocator(&network_manager_));
+  allocator_->SetConfiguration(allocator_->stun_servers(),
+                               allocator_->turn_servers(), 0, true);
+  // Have both UDP/TCP and IPv4/IPv6 TURN ports.
+  AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
+  AddTurnServers(kTurnUdpIntIPv6Addr, kTurnTcpIntIPv6Addr);
+
+  allocator_->set_step_delay(kMinimumStepDelay);
+  allocator_->set_flags(allocator().flags() |
+                        PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+                        PORTALLOCATOR_ENABLE_IPV6);
+  EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
+  session_->StartGettingPorts();
+  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+  // 10 ports (4 STUN and 1 TURN ports on each interface) will be ready to use.
+  EXPECT_EQ(10U, session_->ReadyPorts().size());
+  EXPECT_EQ(10U, ports_.size());
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr2));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr2));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientAddr));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientAddr2));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientIPv6Addr));
+  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientIPv6Addr2));
+  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr));
+  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr2));
+
+  // We don't remove candidates, so there may be more than 10 candidates
+  // in |candidates_|.
+  EXPECT_LE(10U, candidates_.size());
+  const std::vector<Candidate>& ready_candidates = session_->ReadyCandidates();
+  EXPECT_EQ(10U, ready_candidates.size());
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr2);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientIPv6Addr);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp",
+               kClientIPv6Addr2);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr2);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientIPv6Addr);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp",
+               kClientIPv6Addr2);
+  EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
+               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+}
+
 // Testing DNS resolve for the TURN server, this will test AllocationSequence
 // handling the unresolved address signal from TurnPort.
 TEST_F(BasicPortAllocatorTest, TestSharedSocketWithServerAddressResolve) {
   turn_server_.AddInternalSocket(rtc::SocketAddress("127.0.0.1", 3478),
                                  PROTO_UDP);
   AddInterface(kClientAddr);
   allocator_.reset(new BasicPortAllocator(&network_manager_));
   RelayServerConfig turn_server(RELAY_TURN);
   RelayCredentials credentials(kTurnUsername, kTurnPassword);
   turn_server.credentials = credentials;
@@ skipping 275 matching lines @@
   ASSERT_EQ_WAIT(2U, candidates_.size(), 1000);
   EXPECT_EQ(2U, ports_.size());
 }
 
 // Test that the ports and candidates are updated with new ufrag/pwd/etc. when
 // a pooled session is taken out of the pool.
 TEST_F(BasicPortAllocatorTest, TestTransportInformationUpdated) {
   AddInterface(kClientAddr);
   int pool_size = 1;
   allocator_->SetConfiguration(allocator_->stun_servers(),
-                               allocator_->turn_servers(), pool_size);
+                               allocator_->turn_servers(), pool_size, false);
   const PortAllocatorSession* peeked_session = allocator_->GetPooledSession();
   ASSERT_NE(nullptr, peeked_session);
   EXPECT_EQ_WAIT(true, peeked_session->CandidatesAllocationDone(),
                  kDefaultAllocationTimeout);
   // Expect that when TakePooledSession is called,
   // UpdateTransportInformationInternal will be called and the
   // BasicPortAllocatorSession will update the ufrag/pwd of ports and
   // candidates.
   session_ =
       allocator_->TakePooledSession(kContentName, 1, kIceUfrag0, kIcePwd0);
@@ skipping 15 matching lines @@
     EXPECT_EQ(kIcePwd0, candidate.password());
   }
 }
 
 // Test that a new candidate filter takes effect even on already-gathered
 // candidates.
 TEST_F(BasicPortAllocatorTest, TestSetCandidateFilterAfterCandidatesGathered) {
   AddInterface(kClientAddr);
   int pool_size = 1;
   allocator_->SetConfiguration(allocator_->stun_servers(),
-                               allocator_->turn_servers(), pool_size);
+                               allocator_->turn_servers(), pool_size, false);
   const PortAllocatorSession* peeked_session = allocator_->GetPooledSession();
   ASSERT_NE(nullptr, peeked_session);
   EXPECT_EQ_WAIT(true, peeked_session->CandidatesAllocationDone(),
                  kDefaultAllocationTimeout);
   size_t initial_candidates_size = peeked_session->ReadyCandidates().size();
   size_t initial_ports_size = peeked_session->ReadyPorts().size();
   allocator_->set_candidate_filter(CF_RELAY);
   // Assume that when TakePooledSession is called, the candidate filter will be
   // applied to the pooled session. This is tested by PortAllocatorTest.
   session_ =
@@ skipping 11 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