1/* 2 * libjingle 3 * Copyright 2009 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28#include "talk/p2p/base/basicpacketsocketfactory.h" 29#include "talk/p2p/base/constants.h" 30#include "talk/p2p/base/p2ptransportchannel.h" 31#include "talk/p2p/base/portallocatorsessionproxy.h" 32#include "talk/p2p/base/testrelayserver.h" 33#include "talk/p2p/base/teststunserver.h" 34#include "talk/p2p/base/testturnserver.h" 35#include "talk/p2p/client/basicportallocator.h" 36#include "talk/p2p/client/httpportallocator.h" 37#include "webrtc/base/fakenetwork.h" 38#include "webrtc/base/firewallsocketserver.h" 39#include "webrtc/base/gunit.h" 40#include "webrtc/base/helpers.h" 41#include "webrtc/base/logging.h" 42#include "webrtc/base/natserver.h" 43#include "webrtc/base/natsocketfactory.h" 44#include "webrtc/base/network.h" 45#include "webrtc/base/physicalsocketserver.h" 46#include "webrtc/base/socketaddress.h" 47#include "webrtc/base/ssladapter.h" 48#include "webrtc/base/thread.h" 49#include "webrtc/base/virtualsocketserver.h" 50 51using cricket::ServerAddresses; 52using rtc::SocketAddress; 53using rtc::Thread; 54 55static const SocketAddress kClientAddr("11.11.11.11", 0); 56static const SocketAddress kPrivateAddr("192.168.1.11", 0); 57static const SocketAddress kClientIPv6Addr( 58 "2401:fa00:4:1000:be30:5bff:fee5:c3", 0); 59static const SocketAddress kClientAddr2("22.22.22.22", 0); 60static const SocketAddress kNatAddr("77.77.77.77", rtc::NAT_SERVER_PORT); 61static const SocketAddress kRemoteClientAddr("22.22.22.22", 0); 62static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT); 63static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000); 64static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001); 65static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002); 66static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003); 67static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004); 68static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005); 69static const SocketAddress kTurnUdpIntAddr("99.99.99.4", 3478); 70static const SocketAddress kTurnTcpIntAddr("99.99.99.5", 3478); 71static const SocketAddress kTurnUdpExtAddr("99.99.99.6", 0); 72 73// Minimum and maximum port for port range tests. 74static const int kMinPort = 10000; 75static const int kMaxPort = 10099; 76 77// Based on ICE_UFRAG_LENGTH 78static const char kIceUfrag0[] = "TESTICEUFRAG0000"; 79// Based on ICE_PWD_LENGTH 80static const char kIcePwd0[] = "TESTICEPWD00000000000000"; 81 82static const char kContentName[] = "test content"; 83 84static const int kDefaultAllocationTimeout = 1000; 85static const char kTurnUsername[] = "test"; 86static const char kTurnPassword[] = "test"; 87 88namespace cricket { 89 90// Helper for dumping candidates 91std::ostream& operator<<(std::ostream& os, const cricket::Candidate& c) { 92 os << c.ToString(); 93 return os; 94} 95 96} // namespace cricket 97 98class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> { 99 public: 100 static void SetUpTestCase() { 101 rtc::InitializeSSL(); 102 } 103 104 static void TearDownTestCase() { 105 rtc::CleanupSSL(); 106 } 107 108 PortAllocatorTest() 109 : pss_(new rtc::PhysicalSocketServer), 110 vss_(new rtc::VirtualSocketServer(pss_.get())), 111 fss_(new rtc::FirewallSocketServer(vss_.get())), 112 ss_scope_(fss_.get()), 113 nat_factory_(vss_.get(), kNatAddr), 114 nat_socket_factory_(&nat_factory_), 115 stun_server_(Thread::Current(), kStunAddr), 116 relay_server_(Thread::Current(), kRelayUdpIntAddr, kRelayUdpExtAddr, 117 kRelayTcpIntAddr, kRelayTcpExtAddr, 118 kRelaySslTcpIntAddr, kRelaySslTcpExtAddr), 119 turn_server_(Thread::Current(), kTurnUdpIntAddr, kTurnUdpExtAddr), 120 candidate_allocation_done_(false) { 121 cricket::ServerAddresses stun_servers; 122 stun_servers.insert(kStunAddr); 123 allocator_.reset(new cricket::BasicPortAllocator( 124 &network_manager_, 125 stun_servers, 126 kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr)); 127 allocator_->set_step_delay(cricket::kMinimumStepDelay); 128 } 129 130 void AddInterface(const SocketAddress& addr) { 131 network_manager_.AddInterface(addr); 132 } 133 bool SetPortRange(int min_port, int max_port) { 134 return allocator_->SetPortRange(min_port, max_port); 135 } 136 void ResetWithNatServer(const rtc::SocketAddress& stun_server) { 137 nat_server_.reset(new rtc::NATServer( 138 rtc::NAT_OPEN_CONE, vss_.get(), kNatAddr, vss_.get(), kNatAddr)); 139 140 ServerAddresses stun_servers; 141 stun_servers.insert(stun_server); 142 allocator_.reset(new cricket::BasicPortAllocator( 143 &network_manager_, &nat_socket_factory_, stun_servers)); 144 allocator().set_step_delay(cricket::kMinimumStepDelay); 145 } 146 147 void AddTurnServers(const rtc::SocketAddress& udp_turn, 148 const rtc::SocketAddress& tcp_turn) { 149 cricket::RelayServerConfig relay_server(cricket::RELAY_TURN); 150 cricket::RelayCredentials credentials(kTurnUsername, kTurnPassword); 151 relay_server.credentials = credentials; 152 153 if (!udp_turn.IsNil()) { 154 relay_server.ports.push_back(cricket::ProtocolAddress( 155 kTurnUdpIntAddr, cricket::PROTO_UDP, false)); 156 } 157 if (!tcp_turn.IsNil()) { 158 relay_server.ports.push_back(cricket::ProtocolAddress( 159 kTurnTcpIntAddr, cricket::PROTO_TCP, false)); 160 } 161 allocator_->AddRelay(relay_server); 162 } 163 164 bool CreateSession(int component) { 165 session_.reset(CreateSession("session", component)); 166 if (!session_) 167 return false; 168 return true; 169 } 170 171 bool CreateSession(int component, const std::string& content_name) { 172 session_.reset(CreateSession("session", content_name, component)); 173 if (!session_) 174 return false; 175 return true; 176 } 177 178 cricket::PortAllocatorSession* CreateSession( 179 const std::string& sid, int component) { 180 return CreateSession(sid, kContentName, component); 181 } 182 183 cricket::PortAllocatorSession* CreateSession( 184 const std::string& sid, const std::string& content_name, int component) { 185 return CreateSession(sid, content_name, component, kIceUfrag0, kIcePwd0); 186 } 187 188 cricket::PortAllocatorSession* CreateSession( 189 const std::string& sid, const std::string& content_name, int component, 190 const std::string& ice_ufrag, const std::string& ice_pwd) { 191 cricket::PortAllocatorSession* session = 192 allocator_->CreateSession( 193 sid, content_name, component, ice_ufrag, ice_pwd); 194 session->SignalPortReady.connect(this, 195 &PortAllocatorTest::OnPortReady); 196 session->SignalCandidatesReady.connect(this, 197 &PortAllocatorTest::OnCandidatesReady); 198 session->SignalCandidatesAllocationDone.connect(this, 199 &PortAllocatorTest::OnCandidatesAllocationDone); 200 return session; 201 } 202 203 static bool CheckCandidate(const cricket::Candidate& c, 204 int component, const std::string& type, 205 const std::string& proto, 206 const SocketAddress& addr) { 207 return (c.component() == component && c.type() == type && 208 c.protocol() == proto && c.address().ipaddr() == addr.ipaddr() && 209 ((addr.port() == 0 && (c.address().port() != 0)) || 210 (c.address().port() == addr.port()))); 211 } 212 static bool CheckPort(const rtc::SocketAddress& addr, 213 int min_port, int max_port) { 214 return (addr.port() >= min_port && addr.port() <= max_port); 215 } 216 217 void OnCandidatesAllocationDone(cricket::PortAllocatorSession* session) { 218 // We should only get this callback once, except in the mux test where 219 // we have multiple port allocation sessions. 220 if (session == session_.get()) { 221 ASSERT_FALSE(candidate_allocation_done_); 222 candidate_allocation_done_ = true; 223 } 224 } 225 226 // Check if all ports allocated have send-buffer size |expected|. If 227 // |expected| == -1, check if GetOptions returns SOCKET_ERROR. 228 void CheckSendBufferSizesOfAllPorts(int expected) { 229 std::vector<cricket::PortInterface*>::iterator it; 230 for (it = ports_.begin(); it < ports_.end(); ++it) { 231 int send_buffer_size; 232 if (expected == -1) { 233 EXPECT_EQ(SOCKET_ERROR, 234 (*it)->GetOption(rtc::Socket::OPT_SNDBUF, 235 &send_buffer_size)); 236 } else { 237 EXPECT_EQ(0, (*it)->GetOption(rtc::Socket::OPT_SNDBUF, 238 &send_buffer_size)); 239 ASSERT_EQ(expected, send_buffer_size); 240 } 241 } 242 } 243 244 protected: 245 cricket::BasicPortAllocator& allocator() { 246 return *allocator_; 247 } 248 249 void OnPortReady(cricket::PortAllocatorSession* ses, 250 cricket::PortInterface* port) { 251 LOG(LS_INFO) << "OnPortReady: " << port->ToString(); 252 ports_.push_back(port); 253 } 254 void OnCandidatesReady(cricket::PortAllocatorSession* ses, 255 const std::vector<cricket::Candidate>& candidates) { 256 for (size_t i = 0; i < candidates.size(); ++i) { 257 LOG(LS_INFO) << "OnCandidatesReady: " << candidates[i].ToString(); 258 candidates_.push_back(candidates[i]); 259 } 260 } 261 262 bool HasRelayAddress(const cricket::ProtocolAddress& proto_addr) { 263 for (size_t i = 0; i < allocator_->relays().size(); ++i) { 264 cricket::RelayServerConfig server_config = allocator_->relays()[i]; 265 cricket::PortList::const_iterator relay_port; 266 for (relay_port = server_config.ports.begin(); 267 relay_port != server_config.ports.end(); ++relay_port) { 268 if (proto_addr.address == relay_port->address && 269 proto_addr.proto == relay_port->proto) 270 return true; 271 } 272 } 273 return false; 274 } 275 276 rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_; 277 rtc::scoped_ptr<rtc::VirtualSocketServer> vss_; 278 rtc::scoped_ptr<rtc::FirewallSocketServer> fss_; 279 rtc::SocketServerScope ss_scope_; 280 rtc::scoped_ptr<rtc::NATServer> nat_server_; 281 rtc::NATSocketFactory nat_factory_; 282 rtc::BasicPacketSocketFactory nat_socket_factory_; 283 cricket::TestStunServer stun_server_; 284 cricket::TestRelayServer relay_server_; 285 cricket::TestTurnServer turn_server_; 286 rtc::FakeNetworkManager network_manager_; 287 rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_; 288 rtc::scoped_ptr<cricket::PortAllocatorSession> session_; 289 std::vector<cricket::PortInterface*> ports_; 290 std::vector<cricket::Candidate> candidates_; 291 bool candidate_allocation_done_; 292}; 293 294// Tests that we can init the port allocator and create a session. 295TEST_F(PortAllocatorTest, TestBasic) { 296 EXPECT_EQ(&network_manager_, allocator().network_manager()); 297 EXPECT_EQ(kStunAddr, *allocator().stun_servers().begin()); 298 ASSERT_EQ(1u, allocator().relays().size()); 299 EXPECT_EQ(cricket::RELAY_GTURN, allocator().relays()[0].type); 300 // Empty relay credentials are used for GTURN. 301 EXPECT_TRUE(allocator().relays()[0].credentials.username.empty()); 302 EXPECT_TRUE(allocator().relays()[0].credentials.password.empty()); 303 EXPECT_TRUE(HasRelayAddress(cricket::ProtocolAddress( 304 kRelayUdpIntAddr, cricket::PROTO_UDP))); 305 EXPECT_TRUE(HasRelayAddress(cricket::ProtocolAddress( 306 kRelayTcpIntAddr, cricket::PROTO_TCP))); 307 EXPECT_TRUE(HasRelayAddress(cricket::ProtocolAddress( 308 kRelaySslTcpIntAddr, cricket::PROTO_SSLTCP))); 309 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 310} 311 312// Tests that we allocator session not trying to allocate ports for every 250ms. 313TEST_F(PortAllocatorTest, TestNoNetworkInterface) { 314 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 315 session_->StartGettingPorts(); 316 // Waiting for one second to make sure BasicPortAllocatorSession has not 317 // called OnAllocate multiple times. In old behavior it's called every 250ms. 318 // When there are no network interfaces, each execution of OnAllocate will 319 // result in SignalCandidatesAllocationDone signal. 320 rtc::Thread::Current()->ProcessMessages(1000); 321 EXPECT_TRUE(candidate_allocation_done_); 322 EXPECT_EQ(0U, candidates_.size()); 323} 324 325// Tests that we can get all the desired addresses successfully. 326TEST_F(PortAllocatorTest, TestGetAllPortsWithMinimumStepDelay) { 327 AddInterface(kClientAddr); 328 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 329 session_->StartGettingPorts(); 330 ASSERT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout); 331 EXPECT_EQ(4U, ports_.size()); 332 EXPECT_PRED5(CheckCandidate, candidates_[0], 333 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 334 EXPECT_PRED5(CheckCandidate, candidates_[1], 335 cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp", kClientAddr); 336 EXPECT_PRED5(CheckCandidate, candidates_[2], 337 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpIntAddr); 338 EXPECT_PRED5(CheckCandidate, candidates_[3], 339 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpExtAddr); 340 EXPECT_PRED5(CheckCandidate, candidates_[4], 341 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "tcp", kRelayTcpIntAddr); 342 EXPECT_PRED5(CheckCandidate, candidates_[5], 343 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "tcp", kClientAddr); 344 EXPECT_PRED5(CheckCandidate, candidates_[6], 345 cricket::ICE_CANDIDATE_COMPONENT_RTP, 346 "relay", "ssltcp", kRelaySslTcpIntAddr); 347 EXPECT_TRUE(candidate_allocation_done_); 348} 349 350// Verify candidates with default step delay of 1sec. 351TEST_F(PortAllocatorTest, TestGetAllPortsWithOneSecondStepDelay) { 352 AddInterface(kClientAddr); 353 allocator_->set_step_delay(cricket::kDefaultStepDelay); 354 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 355 session_->StartGettingPorts(); 356 ASSERT_EQ_WAIT(2U, candidates_.size(), 1000); 357 EXPECT_EQ(2U, ports_.size()); 358 ASSERT_EQ_WAIT(4U, candidates_.size(), 2000); 359 EXPECT_EQ(3U, ports_.size()); 360 EXPECT_PRED5(CheckCandidate, candidates_[2], 361 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpIntAddr); 362 EXPECT_PRED5(CheckCandidate, candidates_[3], 363 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpExtAddr); 364 ASSERT_EQ_WAIT(6U, candidates_.size(), 1500); 365 EXPECT_PRED5(CheckCandidate, candidates_[4], 366 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "tcp", kRelayTcpIntAddr); 367 EXPECT_PRED5(CheckCandidate, candidates_[5], 368 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "tcp", kClientAddr); 369 EXPECT_EQ(4U, ports_.size()); 370 ASSERT_EQ_WAIT(7U, candidates_.size(), 2000); 371 EXPECT_PRED5(CheckCandidate, candidates_[6], 372 cricket::ICE_CANDIDATE_COMPONENT_RTP, 373 "relay", "ssltcp", kRelaySslTcpIntAddr); 374 EXPECT_EQ(4U, ports_.size()); 375 EXPECT_TRUE(candidate_allocation_done_); 376 // If we Stop gathering now, we shouldn't get a second "done" callback. 377 session_->StopGettingPorts(); 378} 379 380TEST_F(PortAllocatorTest, TestSetupVideoRtpPortsWithNormalSendBuffers) { 381 AddInterface(kClientAddr); 382 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP, 383 cricket::CN_VIDEO)); 384 session_->StartGettingPorts(); 385 ASSERT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout); 386 EXPECT_TRUE(candidate_allocation_done_); 387 // If we Stop gathering now, we shouldn't get a second "done" callback. 388 session_->StopGettingPorts(); 389 390 // All ports should have unset send-buffer sizes. 391 CheckSendBufferSizesOfAllPorts(-1); 392} 393 394// Tests that we can get callback after StopGetAllPorts. 395TEST_F(PortAllocatorTest, TestStopGetAllPorts) { 396 AddInterface(kClientAddr); 397 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 398 session_->StartGettingPorts(); 399 ASSERT_EQ_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout); 400 EXPECT_EQ(2U, ports_.size()); 401 session_->StopGettingPorts(); 402 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 403} 404 405// Test that we restrict client ports appropriately when a port range is set. 406// We check the candidates for udp/stun/tcp ports, and the from address 407// for relay ports. 408TEST_F(PortAllocatorTest, TestGetAllPortsPortRange) { 409 AddInterface(kClientAddr); 410 // Check that an invalid port range fails. 411 EXPECT_FALSE(SetPortRange(kMaxPort, kMinPort)); 412 // Check that a null port range succeeds. 413 EXPECT_TRUE(SetPortRange(0, 0)); 414 // Check that a valid port range succeeds. 415 EXPECT_TRUE(SetPortRange(kMinPort, kMaxPort)); 416 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 417 session_->StartGettingPorts(); 418 ASSERT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout); 419 EXPECT_EQ(4U, ports_.size()); 420 // Check the port number for the UDP port object. 421 EXPECT_PRED3(CheckPort, candidates_[0].address(), kMinPort, kMaxPort); 422 // Check the port number for the STUN port object. 423 EXPECT_PRED3(CheckPort, candidates_[1].address(), kMinPort, kMaxPort); 424 // Check the port number used to connect to the relay server. 425 EXPECT_PRED3(CheckPort, relay_server_.GetConnection(0).source(), 426 kMinPort, kMaxPort); 427 // Check the port number for the TCP port object. 428 EXPECT_PRED3(CheckPort, candidates_[5].address(), kMinPort, kMaxPort); 429 EXPECT_TRUE(candidate_allocation_done_); 430} 431 432// Test that we don't crash or malfunction if we have no network adapters. 433TEST_F(PortAllocatorTest, TestGetAllPortsNoAdapters) { 434 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 435 session_->StartGettingPorts(); 436 rtc::Thread::Current()->ProcessMessages(100); 437 // Without network adapter, we should not get any candidate. 438 EXPECT_EQ(0U, candidates_.size()); 439 EXPECT_TRUE(candidate_allocation_done_); 440} 441 442// Test that we can get OnCandidatesAllocationDone callback when all the ports 443// are disabled. 444TEST_F(PortAllocatorTest, TestDisableAllPorts) { 445 AddInterface(kClientAddr); 446 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 447 session_->set_flags(cricket::PORTALLOCATOR_DISABLE_UDP | 448 cricket::PORTALLOCATOR_DISABLE_STUN | 449 cricket::PORTALLOCATOR_DISABLE_RELAY | 450 cricket::PORTALLOCATOR_DISABLE_TCP); 451 session_->StartGettingPorts(); 452 rtc::Thread::Current()->ProcessMessages(100); 453 EXPECT_EQ(0U, candidates_.size()); 454 EXPECT_TRUE(candidate_allocation_done_); 455} 456 457// Test that we don't crash or malfunction if we can't create UDP sockets. 458TEST_F(PortAllocatorTest, TestGetAllPortsNoUdpSockets) { 459 AddInterface(kClientAddr); 460 fss_->set_udp_sockets_enabled(false); 461 EXPECT_TRUE(CreateSession(1)); 462 session_->StartGettingPorts(); 463 ASSERT_EQ_WAIT(5U, candidates_.size(), kDefaultAllocationTimeout); 464 EXPECT_EQ(2U, ports_.size()); 465 EXPECT_PRED5(CheckCandidate, candidates_[0], 466 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpIntAddr); 467 EXPECT_PRED5(CheckCandidate, candidates_[1], 468 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpExtAddr); 469 EXPECT_PRED5(CheckCandidate, candidates_[2], 470 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "tcp", kRelayTcpIntAddr); 471 EXPECT_PRED5(CheckCandidate, candidates_[3], 472 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "tcp", kClientAddr); 473 EXPECT_PRED5(CheckCandidate, candidates_[4], 474 cricket::ICE_CANDIDATE_COMPONENT_RTP, 475 "relay", "ssltcp", kRelaySslTcpIntAddr); 476 EXPECT_TRUE(candidate_allocation_done_); 477} 478 479// Test that we don't crash or malfunction if we can't create UDP sockets or 480// listen on TCP sockets. We still give out a local TCP address, since 481// apparently this is needed for the remote side to accept our connection. 482TEST_F(PortAllocatorTest, TestGetAllPortsNoUdpSocketsNoTcpListen) { 483 AddInterface(kClientAddr); 484 fss_->set_udp_sockets_enabled(false); 485 fss_->set_tcp_listen_enabled(false); 486 EXPECT_TRUE(CreateSession(1)); 487 session_->StartGettingPorts(); 488 ASSERT_EQ_WAIT(5U, candidates_.size(), kDefaultAllocationTimeout); 489 EXPECT_EQ(2U, ports_.size()); 490 EXPECT_PRED5(CheckCandidate, candidates_[0], 491 1, "relay", "udp", kRelayUdpIntAddr); 492 EXPECT_PRED5(CheckCandidate, candidates_[1], 493 1, "relay", "udp", kRelayUdpExtAddr); 494 EXPECT_PRED5(CheckCandidate, candidates_[2], 495 1, "relay", "tcp", kRelayTcpIntAddr); 496 EXPECT_PRED5(CheckCandidate, candidates_[3], 497 1, "local", "tcp", kClientAddr); 498 EXPECT_PRED5(CheckCandidate, candidates_[4], 499 1, "relay", "ssltcp", kRelaySslTcpIntAddr); 500 EXPECT_TRUE(candidate_allocation_done_); 501} 502 503// Test that we don't crash or malfunction if we can't create any sockets. 504// TODO: Find a way to exit early here. 505TEST_F(PortAllocatorTest, TestGetAllPortsNoSockets) { 506 AddInterface(kClientAddr); 507 fss_->set_tcp_sockets_enabled(false); 508 fss_->set_udp_sockets_enabled(false); 509 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 510 session_->StartGettingPorts(); 511 WAIT(candidates_.size() > 0, 2000); 512 // TODO - Check candidate_allocation_done signal. 513 // In case of Relay, ports creation will succeed but sockets will fail. 514 // There is no error reporting from RelayEntry to handle this failure. 515} 516 517// Testing STUN timeout. 518TEST_F(PortAllocatorTest, TestGetAllPortsNoUdpAllowed) { 519 fss_->AddRule(false, rtc::FP_UDP, rtc::FD_ANY, kClientAddr); 520 AddInterface(kClientAddr); 521 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 522 session_->StartGettingPorts(); 523 EXPECT_EQ_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout); 524 EXPECT_EQ(2U, ports_.size()); 525 EXPECT_PRED5(CheckCandidate, candidates_[0], 526 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 527 EXPECT_PRED5(CheckCandidate, candidates_[1], 528 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "tcp", kClientAddr); 529 // RelayPort connection timeout is 3sec. TCP connection with RelayServer 530 // will be tried after 3 seconds. 531 EXPECT_EQ_WAIT(6U, candidates_.size(), 4000); 532 EXPECT_EQ(3U, ports_.size()); 533 EXPECT_PRED5(CheckCandidate, candidates_[2], 534 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpIntAddr); 535 EXPECT_PRED5(CheckCandidate, candidates_[3], 536 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "tcp", kRelayTcpIntAddr); 537 EXPECT_PRED5(CheckCandidate, candidates_[4], 538 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "ssltcp", 539 kRelaySslTcpIntAddr); 540 EXPECT_PRED5(CheckCandidate, candidates_[5], 541 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", kRelayUdpExtAddr); 542 // Stun Timeout is 9sec. 543 EXPECT_TRUE_WAIT(candidate_allocation_done_, 9000); 544} 545 546TEST_F(PortAllocatorTest, TestCandidatePriorityOfMultipleInterfaces) { 547 AddInterface(kClientAddr); 548 AddInterface(kClientAddr2); 549 // Allocating only host UDP ports. This is done purely for testing 550 // convenience. 551 allocator().set_flags(cricket::PORTALLOCATOR_DISABLE_TCP | 552 cricket::PORTALLOCATOR_DISABLE_STUN | 553 cricket::PORTALLOCATOR_DISABLE_RELAY); 554 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 555 session_->StartGettingPorts(); 556 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 557 ASSERT_EQ(2U, candidates_.size()); 558 EXPECT_EQ(2U, ports_.size()); 559 // Candidates priorities should be different. 560 EXPECT_NE(candidates_[0].priority(), candidates_[1].priority()); 561} 562 563// Test to verify ICE restart process. 564TEST_F(PortAllocatorTest, TestGetAllPortsRestarts) { 565 AddInterface(kClientAddr); 566 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 567 session_->StartGettingPorts(); 568 EXPECT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout); 569 EXPECT_EQ(4U, ports_.size()); 570 EXPECT_TRUE(candidate_allocation_done_); 571 // TODO - Extend this to verify ICE restart. 572} 573 574// Test ICE candidate filter mechanism with options Relay/Host/Reflexive. 575TEST_F(PortAllocatorTest, TestCandidateFilterWithRelayOnly) { 576 AddInterface(kClientAddr); 577 allocator().set_candidate_filter(cricket::CF_RELAY); 578 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 579 session_->StartGettingPorts(); 580 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 581 // Using GTURN, we will have 4 candidates. 582 EXPECT_EQ(4U, candidates_.size()); 583 EXPECT_EQ(1U, ports_.size()); // Only Relay port will be in ready state. 584 for (size_t i = 0; i < candidates_.size(); ++i) { 585 EXPECT_EQ(std::string(cricket::RELAY_PORT_TYPE), candidates_[i].type()); 586 } 587} 588 589TEST_F(PortAllocatorTest, TestCandidateFilterWithHostOnly) { 590 AddInterface(kClientAddr); 591 allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 592 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET); 593 allocator().set_candidate_filter(cricket::CF_HOST); 594 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 595 session_->StartGettingPorts(); 596 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 597 EXPECT_EQ(2U, candidates_.size()); // Host UDP/TCP candidates only. 598 EXPECT_EQ(2U, ports_.size()); // UDP/TCP ports only. 599 for (size_t i = 0; i < candidates_.size(); ++i) { 600 EXPECT_EQ(std::string(cricket::LOCAL_PORT_TYPE), candidates_[i].type()); 601 } 602} 603 604// Host is behind the NAT. 605TEST_F(PortAllocatorTest, TestCandidateFilterWithReflexiveOnly) { 606 AddInterface(kPrivateAddr); 607 ResetWithNatServer(kStunAddr); 608 609 allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 610 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET); 611 allocator().set_candidate_filter(cricket::CF_REFLEXIVE); 612 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 613 session_->StartGettingPorts(); 614 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 615 // Host is behind NAT, no private address will be exposed. Hence only UDP 616 // port with STUN candidate will be sent outside. 617 EXPECT_EQ(1U, candidates_.size()); // Only STUN candidate. 618 EXPECT_EQ(1U, ports_.size()); // Only UDP port will be in ready state. 619 for (size_t i = 0; i < candidates_.size(); ++i) { 620 EXPECT_EQ(std::string(cricket::STUN_PORT_TYPE), candidates_[i].type()); 621 } 622} 623 624// Host is not behind the NAT. 625TEST_F(PortAllocatorTest, TestCandidateFilterWithReflexiveOnlyAndNoNAT) { 626 AddInterface(kClientAddr); 627 allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 628 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET); 629 allocator().set_candidate_filter(cricket::CF_REFLEXIVE); 630 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 631 session_->StartGettingPorts(); 632 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 633 // Host has a public address, both UDP and TCP candidates will be exposed. 634 EXPECT_EQ(2U, candidates_.size()); // Local UDP + TCP candidate. 635 EXPECT_EQ(2U, ports_.size()); // UDP and TCP ports will be in ready state. 636 for (size_t i = 0; i < candidates_.size(); ++i) { 637 EXPECT_EQ(std::string(cricket::LOCAL_PORT_TYPE), candidates_[i].type()); 638 } 639} 640 641TEST_F(PortAllocatorTest, TestBasicMuxFeatures) { 642 AddInterface(kClientAddr); 643 allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_BUNDLE); 644 // Session ID - session1. 645 rtc::scoped_ptr<cricket::PortAllocatorSession> session1( 646 CreateSession("session1", cricket::ICE_CANDIDATE_COMPONENT_RTP)); 647 rtc::scoped_ptr<cricket::PortAllocatorSession> session2( 648 CreateSession("session1", cricket::ICE_CANDIDATE_COMPONENT_RTCP)); 649 session1->StartGettingPorts(); 650 session2->StartGettingPorts(); 651 // Each session should receive two proxy ports of local and stun. 652 ASSERT_EQ_WAIT(14U, candidates_.size(), kDefaultAllocationTimeout); 653 EXPECT_EQ(8U, ports_.size()); 654 655 rtc::scoped_ptr<cricket::PortAllocatorSession> session3( 656 CreateSession("session1", cricket::ICE_CANDIDATE_COMPONENT_RTP)); 657 session3->StartGettingPorts(); 658 // Already allocated candidates and ports will be sent to the newly 659 // allocated proxy session. 660 ASSERT_EQ_WAIT(21U, candidates_.size(), kDefaultAllocationTimeout); 661 EXPECT_EQ(12U, ports_.size()); 662} 663 664// This test verifies by changing ice_ufrag and/or ice_pwd 665// will result in different set of candidates when BUNDLE is enabled. 666// If BUNDLE is disabled, CreateSession will always allocate new 667// set of candidates. 668TEST_F(PortAllocatorTest, TestBundleIceRestart) { 669 AddInterface(kClientAddr); 670 allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_BUNDLE); 671 // Session ID - session1. 672 rtc::scoped_ptr<cricket::PortAllocatorSession> session1( 673 CreateSession("session1", kContentName, 674 cricket::ICE_CANDIDATE_COMPONENT_RTP, 675 kIceUfrag0, kIcePwd0)); 676 session1->StartGettingPorts(); 677 ASSERT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout); 678 EXPECT_EQ(4U, ports_.size()); 679 680 // Allocate a different session with sid |session1| and different ice_ufrag. 681 rtc::scoped_ptr<cricket::PortAllocatorSession> session2( 682 CreateSession("session1", kContentName, 683 cricket::ICE_CANDIDATE_COMPONENT_RTP, 684 "TestIceUfrag", kIcePwd0)); 685 session2->StartGettingPorts(); 686 ASSERT_EQ_WAIT(14U, candidates_.size(), kDefaultAllocationTimeout); 687 EXPECT_EQ(8U, ports_.size()); 688 // Verifying the candidate address different from previously allocated 689 // address. 690 // Skipping verification of component id and candidate type. 691 EXPECT_NE(candidates_[0].address(), candidates_[7].address()); 692 EXPECT_NE(candidates_[1].address(), candidates_[8].address()); 693 694 // Allocating a different session with sid |session1| and 695 // different ice_pwd. 696 rtc::scoped_ptr<cricket::PortAllocatorSession> session3( 697 CreateSession("session1", kContentName, 698 cricket::ICE_CANDIDATE_COMPONENT_RTP, 699 kIceUfrag0, "TestIcePwd")); 700 session3->StartGettingPorts(); 701 ASSERT_EQ_WAIT(21U, candidates_.size(), kDefaultAllocationTimeout); 702 EXPECT_EQ(12U, ports_.size()); 703 // Verifying the candidate address different from previously 704 // allocated address. 705 EXPECT_NE(candidates_[7].address(), candidates_[14].address()); 706 EXPECT_NE(candidates_[8].address(), candidates_[15].address()); 707 708 // Allocating a session with by changing both ice_ufrag and ice_pwd. 709 rtc::scoped_ptr<cricket::PortAllocatorSession> session4( 710 CreateSession("session1", kContentName, 711 cricket::ICE_CANDIDATE_COMPONENT_RTP, 712 "TestIceUfrag", "TestIcePwd")); 713 session4->StartGettingPorts(); 714 ASSERT_EQ_WAIT(28U, candidates_.size(), kDefaultAllocationTimeout); 715 EXPECT_EQ(16U, ports_.size()); 716 // Verifying the candidate address different from previously 717 // allocated address. 718 EXPECT_NE(candidates_[14].address(), candidates_[21].address()); 719 EXPECT_NE(candidates_[15].address(), candidates_[22].address()); 720} 721 722// Test that when the PORTALLOCATOR_ENABLE_SHARED_UFRAG is enabled we got same 723// ufrag and pwd for the collected candidates. 724TEST_F(PortAllocatorTest, TestEnableSharedUfrag) { 725 allocator().set_flags(allocator().flags() | 726 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG); 727 AddInterface(kClientAddr); 728 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 729 session_->StartGettingPorts(); 730 ASSERT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout); 731 EXPECT_PRED5(CheckCandidate, candidates_[0], 732 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 733 EXPECT_PRED5(CheckCandidate, candidates_[1], 734 cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp", kClientAddr); 735 EXPECT_PRED5(CheckCandidate, candidates_[5], 736 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "tcp", kClientAddr); 737 EXPECT_EQ(4U, ports_.size()); 738 EXPECT_EQ(kIceUfrag0, candidates_[0].username()); 739 EXPECT_EQ(kIceUfrag0, candidates_[1].username()); 740 EXPECT_EQ(kIceUfrag0, candidates_[2].username()); 741 EXPECT_EQ(kIcePwd0, candidates_[0].password()); 742 EXPECT_EQ(kIcePwd0, candidates_[1].password()); 743 EXPECT_TRUE(candidate_allocation_done_); 744} 745 746// Test that when the PORTALLOCATOR_ENABLE_SHARED_UFRAG isn't enabled we got 747// different ufrag and pwd for the collected candidates. 748TEST_F(PortAllocatorTest, TestDisableSharedUfrag) { 749 allocator().set_flags(allocator().flags() & 750 ~cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG); 751 AddInterface(kClientAddr); 752 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 753 session_->StartGettingPorts(); 754 ASSERT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout); 755 EXPECT_PRED5(CheckCandidate, candidates_[0], 756 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 757 EXPECT_PRED5(CheckCandidate, candidates_[1], 758 cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp", kClientAddr); 759 EXPECT_EQ(4U, ports_.size()); 760 // Port should generate random ufrag and pwd. 761 EXPECT_NE(kIceUfrag0, candidates_[0].username()); 762 EXPECT_NE(kIceUfrag0, candidates_[1].username()); 763 EXPECT_NE(candidates_[0].username(), candidates_[1].username()); 764 EXPECT_NE(kIcePwd0, candidates_[0].password()); 765 EXPECT_NE(kIcePwd0, candidates_[1].password()); 766 EXPECT_NE(candidates_[0].password(), candidates_[1].password()); 767 EXPECT_TRUE(candidate_allocation_done_); 768} 769 770// Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port 771// is allocated for udp and stun. Also verify there is only one candidate 772// (local) if stun candidate is same as local candidate, which will be the case 773// in a public network like the below test. 774TEST_F(PortAllocatorTest, TestSharedSocketWithoutNat) { 775 AddInterface(kClientAddr); 776 allocator_->set_flags(allocator().flags() | 777 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 778 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET); 779 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 780 session_->StartGettingPorts(); 781 ASSERT_EQ_WAIT(6U, candidates_.size(), kDefaultAllocationTimeout); 782 EXPECT_EQ(3U, ports_.size()); 783 EXPECT_PRED5(CheckCandidate, candidates_[0], 784 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 785 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 786} 787 788// Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port 789// is allocated for udp and stun. In this test we should expect both stun and 790// local candidates as client behind a nat. 791TEST_F(PortAllocatorTest, TestSharedSocketWithNat) { 792 AddInterface(kClientAddr); 793 ResetWithNatServer(kStunAddr); 794 795 allocator_->set_flags(allocator().flags() | 796 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 797 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET); 798 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 799 session_->StartGettingPorts(); 800 ASSERT_EQ_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout); 801 ASSERT_EQ(2U, ports_.size()); 802 EXPECT_PRED5(CheckCandidate, candidates_[0], 803 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 804 EXPECT_PRED5(CheckCandidate, candidates_[1], 805 cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp", 806 rtc::SocketAddress(kNatAddr.ipaddr(), 0)); 807 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 808 EXPECT_EQ(3U, candidates_.size()); 809} 810 811// Test TURN port in shared socket mode with UDP and TCP TURN server adderesses. 812TEST_F(PortAllocatorTest, TestSharedSocketWithoutNatUsingTurn) { 813 turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP); 814 AddInterface(kClientAddr); 815 allocator_.reset(new cricket::BasicPortAllocator(&network_manager_)); 816 817 AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr); 818 819 allocator_->set_step_delay(cricket::kMinimumStepDelay); 820 allocator_->set_flags(allocator().flags() | 821 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 822 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET | 823 cricket::PORTALLOCATOR_DISABLE_TCP); 824 825 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 826 session_->StartGettingPorts(); 827 828 ASSERT_EQ_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout); 829 ASSERT_EQ(3U, ports_.size()); 830 EXPECT_PRED5(CheckCandidate, candidates_[0], 831 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 832 EXPECT_PRED5(CheckCandidate, candidates_[1], 833 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", 834 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); 835 EXPECT_PRED5(CheckCandidate, candidates_[2], 836 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", 837 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); 838 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 839 EXPECT_EQ(3U, candidates_.size()); 840} 841 842// Testing DNS resolve for the TURN server, this will test AllocationSequence 843// handling the unresolved address signal from TurnPort. 844TEST_F(PortAllocatorTest, TestSharedSocketWithServerAddressResolve) { 845 turn_server_.AddInternalSocket(rtc::SocketAddress("127.0.0.1", 3478), 846 cricket::PROTO_UDP); 847 AddInterface(kClientAddr); 848 allocator_.reset(new cricket::BasicPortAllocator(&network_manager_)); 849 cricket::RelayServerConfig relay_server(cricket::RELAY_TURN); 850 cricket::RelayCredentials credentials(kTurnUsername, kTurnPassword); 851 relay_server.credentials = credentials; 852 relay_server.ports.push_back(cricket::ProtocolAddress( 853 rtc::SocketAddress("localhost", 3478), 854 cricket::PROTO_UDP, false)); 855 allocator_->AddRelay(relay_server); 856 857 allocator_->set_step_delay(cricket::kMinimumStepDelay); 858 allocator_->set_flags(allocator().flags() | 859 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 860 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET | 861 cricket::PORTALLOCATOR_DISABLE_TCP); 862 863 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 864 session_->StartGettingPorts(); 865 866 EXPECT_EQ_WAIT(2U, ports_.size(), kDefaultAllocationTimeout); 867} 868 869// Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port 870// is allocated for udp/stun/turn. In this test we should expect all local, 871// stun and turn candidates. 872TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurn) { 873 AddInterface(kClientAddr); 874 ResetWithNatServer(kStunAddr); 875 876 AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress()); 877 878 allocator_->set_flags(allocator().flags() | 879 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 880 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET | 881 cricket::PORTALLOCATOR_DISABLE_TCP); 882 883 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 884 session_->StartGettingPorts(); 885 886 ASSERT_EQ_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout); 887 ASSERT_EQ(2U, ports_.size()); 888 EXPECT_PRED5(CheckCandidate, candidates_[0], 889 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 890 EXPECT_PRED5(CheckCandidate, candidates_[1], 891 cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp", 892 rtc::SocketAddress(kNatAddr.ipaddr(), 0)); 893 EXPECT_PRED5(CheckCandidate, candidates_[2], 894 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", 895 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); 896 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 897 EXPECT_EQ(3U, candidates_.size()); 898 // Local port will be created first and then TURN port. 899 EXPECT_EQ(2U, ports_[0]->Candidates().size()); 900 EXPECT_EQ(1U, ports_[1]->Candidates().size()); 901} 902 903// Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled and the TURN 904// server is also used as the STUN server, we should get 'local', 'stun', and 905// 'relay' candidates. 906TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurnAsStun) { 907 AddInterface(kClientAddr); 908 ResetWithNatServer(kTurnUdpIntAddr); 909 AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress()); 910 911 // Must set the step delay to 0 to make sure the relay allocation phase is 912 // started before the STUN candidates are obtained, so that the STUN binding 913 // response is processed when both StunPort and TurnPort exist to reproduce 914 // webrtc issue 3537. 915 allocator_->set_step_delay(0); 916 allocator_->set_flags(allocator().flags() | 917 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 918 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET | 919 cricket::PORTALLOCATOR_DISABLE_TCP); 920 921 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 922 session_->StartGettingPorts(); 923 924 ASSERT_EQ_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout); 925 EXPECT_PRED5(CheckCandidate, candidates_[0], 926 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 927 EXPECT_PRED5(CheckCandidate, candidates_[1], 928 cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp", 929 rtc::SocketAddress(kNatAddr.ipaddr(), 0)); 930 EXPECT_PRED5(CheckCandidate, candidates_[2], 931 cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp", 932 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); 933 EXPECT_EQ(candidates_[2].related_address(), candidates_[1].address()); 934 935 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 936 EXPECT_EQ(3U, candidates_.size()); 937 // Local port will be created first and then TURN port. 938 EXPECT_EQ(2U, ports_[0]->Candidates().size()); 939 EXPECT_EQ(1U, ports_[1]->Candidates().size()); 940} 941 942// This test verifies when PORTALLOCATOR_ENABLE_SHARED_SOCKET flag is enabled 943// and fail to generate STUN candidate, local UDP candidate is generated 944// properly. 945TEST_F(PortAllocatorTest, TestSharedSocketNoUdpAllowed) { 946 allocator().set_flags(allocator().flags() | 947 cricket::PORTALLOCATOR_DISABLE_RELAY | 948 cricket::PORTALLOCATOR_DISABLE_TCP | 949 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 950 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET); 951 fss_->AddRule(false, rtc::FP_UDP, rtc::FD_ANY, kClientAddr); 952 AddInterface(kClientAddr); 953 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 954 session_->StartGettingPorts(); 955 ASSERT_EQ_WAIT(1U, ports_.size(), kDefaultAllocationTimeout); 956 EXPECT_EQ(1U, candidates_.size()); 957 EXPECT_PRED5(CheckCandidate, candidates_[0], 958 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr); 959 // STUN timeout is 9sec. We need to wait to get candidate done signal. 960 EXPECT_TRUE_WAIT(candidate_allocation_done_, 10000); 961 EXPECT_EQ(1U, candidates_.size()); 962} 963 964// This test verifies allocator can use IPv6 addresses along with IPv4. 965TEST_F(PortAllocatorTest, TestEnableIPv6Addresses) { 966 allocator().set_flags(allocator().flags() | 967 cricket::PORTALLOCATOR_DISABLE_RELAY | 968 cricket::PORTALLOCATOR_ENABLE_IPV6 | 969 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | 970 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET); 971 AddInterface(kClientIPv6Addr); 972 AddInterface(kClientAddr); 973 allocator_->set_step_delay(cricket::kMinimumStepDelay); 974 EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP)); 975 session_->StartGettingPorts(); 976 ASSERT_EQ_WAIT(4U, ports_.size(), kDefaultAllocationTimeout); 977 EXPECT_EQ(4U, candidates_.size()); 978 EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); 979 EXPECT_PRED5(CheckCandidate, candidates_[0], 980 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", 981 kClientIPv6Addr); 982 EXPECT_PRED5(CheckCandidate, candidates_[1], 983 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", 984 kClientAddr); 985 EXPECT_PRED5(CheckCandidate, candidates_[2], 986 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "tcp", 987 kClientIPv6Addr); 988 EXPECT_PRED5(CheckCandidate, candidates_[3], 989 cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "tcp", 990 kClientAddr); 991 EXPECT_EQ(4U, candidates_.size()); 992} 993 994// Test that the httpportallocator correctly maintains its lists of stun and 995// relay servers, by never allowing an empty list. 996TEST(HttpPortAllocatorTest, TestHttpPortAllocatorHostLists) { 997 rtc::FakeNetworkManager network_manager; 998 cricket::HttpPortAllocator alloc(&network_manager, "unit test agent"); 999 EXPECT_EQ(1U, alloc.relay_hosts().size()); 1000 EXPECT_EQ(1U, alloc.stun_hosts().size()); 1001 1002 std::vector<std::string> relay_servers; 1003 std::vector<rtc::SocketAddress> stun_servers; 1004 1005 alloc.SetRelayHosts(relay_servers); 1006 alloc.SetStunHosts(stun_servers); 1007 EXPECT_EQ(1U, alloc.relay_hosts().size()); 1008 EXPECT_EQ(1U, alloc.stun_hosts().size()); 1009 1010 relay_servers.push_back("1.unittest.corp.google.com"); 1011 relay_servers.push_back("2.unittest.corp.google.com"); 1012 stun_servers.push_back( 1013 rtc::SocketAddress("1.unittest.corp.google.com", 0)); 1014 stun_servers.push_back( 1015 rtc::SocketAddress("2.unittest.corp.google.com", 0)); 1016 1017 alloc.SetRelayHosts(relay_servers); 1018 alloc.SetStunHosts(stun_servers); 1019 EXPECT_EQ(2U, alloc.relay_hosts().size()); 1020 EXPECT_EQ(2U, alloc.stun_hosts().size()); 1021} 1022 1023// Test that the HttpPortAllocator uses correct URL to create sessions. 1024TEST(HttpPortAllocatorTest, TestSessionRequestUrl) { 1025 rtc::FakeNetworkManager network_manager; 1026 cricket::HttpPortAllocator alloc(&network_manager, "unit test agent"); 1027 1028 // Disable PORTALLOCATOR_ENABLE_SHARED_UFRAG. 1029 alloc.set_flags(alloc.flags() & ~cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG); 1030 rtc::scoped_ptr<cricket::HttpPortAllocatorSessionBase> session( 1031 static_cast<cricket::HttpPortAllocatorSession*>( 1032 alloc.CreateSessionInternal( 1033 "test content", 0, kIceUfrag0, kIcePwd0))); 1034 std::string url = session->GetSessionRequestUrl(); 1035 LOG(LS_INFO) << "url: " << url; 1036 EXPECT_EQ(std::string(cricket::HttpPortAllocator::kCreateSessionURL), url); 1037 1038 // Enable PORTALLOCATOR_ENABLE_SHARED_UFRAG. 1039 alloc.set_flags(alloc.flags() | cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG); 1040 session.reset(static_cast<cricket::HttpPortAllocatorSession*>( 1041 alloc.CreateSessionInternal("test content", 0, kIceUfrag0, kIcePwd0))); 1042 url = session->GetSessionRequestUrl(); 1043 LOG(LS_INFO) << "url: " << url; 1044 std::vector<std::string> parts; 1045 rtc::split(url, '?', &parts); 1046 ASSERT_EQ(2U, parts.size()); 1047 1048 std::vector<std::string> args_parts; 1049 rtc::split(parts[1], '&', &args_parts); 1050 1051 std::map<std::string, std::string> args; 1052 for (std::vector<std::string>::iterator it = args_parts.begin(); 1053 it != args_parts.end(); ++it) { 1054 std::vector<std::string> parts; 1055 rtc::split(*it, '=', &parts); 1056 ASSERT_EQ(2U, parts.size()); 1057 args[rtc::s_url_decode(parts[0])] = rtc::s_url_decode(parts[1]); 1058 } 1059 1060 EXPECT_EQ(kIceUfrag0, args["username"]); 1061 EXPECT_EQ(kIcePwd0, args["password"]); 1062} 1063