1 /* 2 * libjingle 3 * Copyright 2004 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/base/crc32.h" 29 #include "talk/base/gunit.h" 30 #include "talk/base/helpers.h" 31 #include "talk/base/logging.h" 32 #include "talk/base/natserver.h" 33 #include "talk/base/natsocketfactory.h" 34 #include "talk/base/physicalsocketserver.h" 35 #include "talk/base/scoped_ptr.h" 36 #include "talk/base/socketaddress.h" 37 #include "talk/base/stringutils.h" 38 #include "talk/base/thread.h" 39 #include "talk/base/virtualsocketserver.h" 40 #include "talk/p2p/base/basicpacketsocketfactory.h" 41 #include "talk/p2p/base/portproxy.h" 42 #include "talk/p2p/base/relayport.h" 43 #include "talk/p2p/base/stunport.h" 44 #include "talk/p2p/base/tcpport.h" 45 #include "talk/p2p/base/testrelayserver.h" 46 #include "talk/p2p/base/teststunserver.h" 47 #include "talk/p2p/base/testturnserver.h" 48 #include "talk/p2p/base/transport.h" 49 #include "talk/p2p/base/turnport.h" 50 51 using talk_base::AsyncPacketSocket; 52 using talk_base::ByteBuffer; 53 using talk_base::NATType; 54 using talk_base::NAT_OPEN_CONE; 55 using talk_base::NAT_ADDR_RESTRICTED; 56 using talk_base::NAT_PORT_RESTRICTED; 57 using talk_base::NAT_SYMMETRIC; 58 using talk_base::PacketSocketFactory; 59 using talk_base::scoped_ptr; 60 using talk_base::Socket; 61 using talk_base::SocketAddress; 62 using namespace cricket; 63 64 static const int kTimeout = 1000; 65 static const SocketAddress kLocalAddr1("192.168.1.2", 0); 66 static const SocketAddress kLocalAddr2("192.168.1.3", 0); 67 static const SocketAddress kNatAddr1("77.77.77.77", talk_base::NAT_SERVER_PORT); 68 static const SocketAddress kNatAddr2("88.88.88.88", talk_base::NAT_SERVER_PORT); 69 static const SocketAddress kStunAddr("99.99.99.1", STUN_SERVER_PORT); 70 static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000); 71 static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001); 72 static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002); 73 static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003); 74 static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004); 75 static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005); 76 static const SocketAddress kTurnUdpIntAddr("99.99.99.4", STUN_SERVER_PORT); 77 static const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0); 78 static const RelayCredentials kRelayCredentials("test", "test"); 79 80 // TODO: Update these when RFC5245 is completely supported. 81 // Magic value of 30 is from RFC3484, for IPv4 addresses. 82 static const uint32 kDefaultPrflxPriority = ICE_TYPE_PREFERENCE_PRFLX << 24 | 83 30 << 8 | (256 - ICE_CANDIDATE_COMPONENT_DEFAULT); 84 static const int STUN_ERROR_BAD_REQUEST_AS_GICE = 85 STUN_ERROR_BAD_REQUEST / 256 * 100 + STUN_ERROR_BAD_REQUEST % 256; 86 static const int STUN_ERROR_UNAUTHORIZED_AS_GICE = 87 STUN_ERROR_UNAUTHORIZED / 256 * 100 + STUN_ERROR_UNAUTHORIZED % 256; 88 static const int STUN_ERROR_SERVER_ERROR_AS_GICE = 89 STUN_ERROR_SERVER_ERROR / 256 * 100 + STUN_ERROR_SERVER_ERROR % 256; 90 91 static const int kTiebreaker1 = 11111; 92 static const int kTiebreaker2 = 22222; 93 94 static Candidate GetCandidate(Port* port) { 95 assert(port->Candidates().size() == 1); 96 return port->Candidates()[0]; 97 } 98 99 static SocketAddress GetAddress(Port* port) { 100 return GetCandidate(port).address(); 101 } 102 103 static IceMessage* CopyStunMessage(const IceMessage* src) { 104 IceMessage* dst = new IceMessage(); 105 ByteBuffer buf; 106 src->Write(&buf); 107 dst->Read(&buf); 108 return dst; 109 } 110 111 static bool WriteStunMessage(const StunMessage* msg, ByteBuffer* buf) { 112 buf->Resize(0); // clear out any existing buffer contents 113 return msg->Write(buf); 114 } 115 116 // Stub port class for testing STUN generation and processing. 117 class TestPort : public Port { 118 public: 119 TestPort(talk_base::Thread* thread, const std::string& type, 120 talk_base::PacketSocketFactory* factory, talk_base::Network* network, 121 const talk_base::IPAddress& ip, int min_port, int max_port, 122 const std::string& username_fragment, const std::string& password) 123 : Port(thread, type, factory, network, ip, 124 min_port, max_port, username_fragment, password) { 125 } 126 ~TestPort() {} 127 128 // Expose GetStunMessage so that we can test it. 129 using cricket::Port::GetStunMessage; 130 131 // The last StunMessage that was sent on this Port. 132 // TODO: Make these const; requires changes to SendXXXXResponse. 133 ByteBuffer* last_stun_buf() { return last_stun_buf_.get(); } 134 IceMessage* last_stun_msg() { return last_stun_msg_.get(); } 135 int last_stun_error_code() { 136 int code = 0; 137 if (last_stun_msg_) { 138 const StunErrorCodeAttribute* error_attr = last_stun_msg_->GetErrorCode(); 139 if (error_attr) { 140 code = error_attr->code(); 141 } 142 } 143 return code; 144 } 145 146 virtual void PrepareAddress() { 147 talk_base::SocketAddress addr(ip(), min_port()); 148 AddAddress(addr, addr, "udp", Type(), ICE_TYPE_PREFERENCE_HOST, true); 149 } 150 151 // Exposed for testing candidate building. 152 void AddCandidateAddress(const talk_base::SocketAddress& addr) { 153 AddAddress(addr, addr, "udp", Type(), type_preference_, false); 154 } 155 void AddCandidateAddress(const talk_base::SocketAddress& addr, 156 const talk_base::SocketAddress& base_address, 157 const std::string& type, 158 int type_preference, 159 bool final) { 160 AddAddress(addr, base_address, "udp", type, 161 type_preference, final); 162 } 163 164 virtual Connection* CreateConnection(const Candidate& remote_candidate, 165 CandidateOrigin origin) { 166 Connection* conn = new ProxyConnection(this, 0, remote_candidate); 167 AddConnection(conn); 168 // Set use-candidate attribute flag as this will add USE-CANDIDATE attribute 169 // in STUN binding requests. 170 conn->set_use_candidate_attr(true); 171 return conn; 172 } 173 virtual int SendTo( 174 const void* data, size_t size, const talk_base::SocketAddress& addr, 175 bool payload) { 176 if (!payload) { 177 IceMessage* msg = new IceMessage; 178 ByteBuffer* buf = new ByteBuffer(static_cast<const char*>(data), size); 179 ByteBuffer::ReadPosition pos(buf->GetReadPosition()); 180 if (!msg->Read(buf)) { 181 delete msg; 182 delete buf; 183 return -1; 184 } 185 buf->SetReadPosition(pos); 186 last_stun_buf_.reset(buf); 187 last_stun_msg_.reset(msg); 188 } 189 return static_cast<int>(size); 190 } 191 virtual int SetOption(talk_base::Socket::Option opt, int value) { 192 return 0; 193 } 194 virtual int GetOption(talk_base::Socket::Option opt, int* value) { 195 return -1; 196 } 197 virtual int GetError() { 198 return 0; 199 } 200 void Reset() { 201 last_stun_buf_.reset(); 202 last_stun_msg_.reset(); 203 } 204 void set_type_preference(int type_preference) { 205 type_preference_ = type_preference; 206 } 207 208 private: 209 talk_base::scoped_ptr<ByteBuffer> last_stun_buf_; 210 talk_base::scoped_ptr<IceMessage> last_stun_msg_; 211 int type_preference_; 212 }; 213 214 class TestChannel : public sigslot::has_slots<> { 215 public: 216 TestChannel(Port* p1, Port* p2) 217 : ice_mode_(ICEMODE_FULL), src_(p1), dst_(p2), complete_count_(0), 218 conn_(NULL), remote_request_(NULL), nominated_(false) { 219 src_->SignalPortComplete.connect( 220 this, &TestChannel::OnPortComplete); 221 src_->SignalUnknownAddress.connect(this, &TestChannel::OnUnknownAddress); 222 } 223 224 int complete_count() { return complete_count_; } 225 Connection* conn() { return conn_; } 226 const SocketAddress& remote_address() { return remote_address_; } 227 const std::string remote_fragment() { return remote_frag_; } 228 229 void Start() { 230 src_->PrepareAddress(); 231 } 232 void CreateConnection() { 233 conn_ = src_->CreateConnection(GetCandidate(dst_), Port::ORIGIN_MESSAGE); 234 IceMode remote_ice_mode = 235 (ice_mode_ == ICEMODE_FULL) ? ICEMODE_LITE : ICEMODE_FULL; 236 conn_->set_remote_ice_mode(remote_ice_mode); 237 conn_->set_use_candidate_attr(remote_ice_mode == ICEMODE_FULL); 238 conn_->SignalStateChange.connect( 239 this, &TestChannel::OnConnectionStateChange); 240 } 241 void OnConnectionStateChange(Connection* conn) { 242 if (conn->write_state() == Connection::STATE_WRITABLE) { 243 conn->set_use_candidate_attr(true); 244 nominated_ = true; 245 } 246 } 247 void AcceptConnection() { 248 ASSERT_TRUE(remote_request_.get() != NULL); 249 Candidate c = GetCandidate(dst_); 250 c.set_address(remote_address_); 251 conn_ = src_->CreateConnection(c, Port::ORIGIN_MESSAGE); 252 src_->SendBindingResponse(remote_request_.get(), remote_address_); 253 remote_request_.reset(); 254 } 255 void Ping() { 256 Ping(0); 257 } 258 void Ping(uint32 now) { 259 conn_->Ping(now); 260 } 261 void Stop() { 262 conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed); 263 conn_->Destroy(); 264 } 265 266 void OnPortComplete(Port* port) { 267 complete_count_++; 268 } 269 void SetIceMode(IceMode ice_mode) { 270 ice_mode_ = ice_mode; 271 } 272 273 void OnUnknownAddress(PortInterface* port, const SocketAddress& addr, 274 ProtocolType proto, 275 IceMessage* msg, const std::string& rf, 276 bool /*port_muxed*/) { 277 ASSERT_EQ(src_.get(), port); 278 if (!remote_address_.IsNil()) { 279 ASSERT_EQ(remote_address_, addr); 280 } 281 // MI and PRIORITY attribute should be present in ping requests when port 282 // is in ICEPROTO_RFC5245 mode. 283 const cricket::StunUInt32Attribute* priority_attr = 284 msg->GetUInt32(STUN_ATTR_PRIORITY); 285 const cricket::StunByteStringAttribute* mi_attr = 286 msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY); 287 const cricket::StunUInt32Attribute* fingerprint_attr = 288 msg->GetUInt32(STUN_ATTR_FINGERPRINT); 289 if (src_->IceProtocol() == cricket::ICEPROTO_RFC5245) { 290 EXPECT_TRUE(priority_attr != NULL); 291 EXPECT_TRUE(mi_attr != NULL); 292 EXPECT_TRUE(fingerprint_attr != NULL); 293 } else { 294 EXPECT_TRUE(priority_attr == NULL); 295 EXPECT_TRUE(mi_attr == NULL); 296 EXPECT_TRUE(fingerprint_attr == NULL); 297 } 298 remote_address_ = addr; 299 remote_request_.reset(CopyStunMessage(msg)); 300 remote_frag_ = rf; 301 } 302 303 void OnDestroyed(Connection* conn) { 304 ASSERT_EQ(conn_, conn); 305 conn_ = NULL; 306 } 307 308 bool nominated() const { return nominated_; } 309 310 private: 311 IceMode ice_mode_; 312 talk_base::scoped_ptr<Port> src_; 313 Port* dst_; 314 315 int complete_count_; 316 Connection* conn_; 317 SocketAddress remote_address_; 318 talk_base::scoped_ptr<StunMessage> remote_request_; 319 std::string remote_frag_; 320 bool nominated_; 321 }; 322 323 class PortTest : public testing::Test, public sigslot::has_slots<> { 324 public: 325 PortTest() 326 : main_(talk_base::Thread::Current()), 327 pss_(new talk_base::PhysicalSocketServer), 328 ss_(new talk_base::VirtualSocketServer(pss_.get())), 329 ss_scope_(ss_.get()), 330 network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY), 32), 331 socket_factory_(talk_base::Thread::Current()), 332 nat_factory1_(ss_.get(), kNatAddr1), 333 nat_factory2_(ss_.get(), kNatAddr2), 334 nat_socket_factory1_(&nat_factory1_), 335 nat_socket_factory2_(&nat_factory2_), 336 stun_server_(main_, kStunAddr), 337 turn_server_(main_, kTurnUdpIntAddr, kTurnUdpExtAddr), 338 relay_server_(main_, kRelayUdpIntAddr, kRelayUdpExtAddr, 339 kRelayTcpIntAddr, kRelayTcpExtAddr, 340 kRelaySslTcpIntAddr, kRelaySslTcpExtAddr), 341 username_(talk_base::CreateRandomString(ICE_UFRAG_LENGTH)), 342 password_(talk_base::CreateRandomString(ICE_PWD_LENGTH)), 343 ice_protocol_(cricket::ICEPROTO_GOOGLE), 344 role_conflict_(false) { 345 network_.AddIP(talk_base::IPAddress(INADDR_ANY)); 346 } 347 348 protected: 349 static void SetUpTestCase() { 350 // Ensure the RNG is inited. 351 talk_base::InitRandom(NULL, 0); 352 } 353 354 void TestLocalToLocal() { 355 Port* port1 = CreateUdpPort(kLocalAddr1); 356 Port* port2 = CreateUdpPort(kLocalAddr2); 357 TestConnectivity("udp", port1, "udp", port2, true, true, true, true); 358 } 359 void TestLocalToStun(NATType ntype) { 360 Port* port1 = CreateUdpPort(kLocalAddr1); 361 nat_server2_.reset(CreateNatServer(kNatAddr2, ntype)); 362 Port* port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_); 363 TestConnectivity("udp", port1, StunName(ntype), port2, 364 ntype == NAT_OPEN_CONE, true, 365 ntype != NAT_SYMMETRIC, true); 366 } 367 void TestLocalToRelay(RelayType rtype, ProtocolType proto) { 368 Port* port1 = CreateUdpPort(kLocalAddr1); 369 Port* port2 = CreateRelayPort(kLocalAddr2, rtype, proto, PROTO_UDP); 370 TestConnectivity("udp", port1, RelayName(rtype, proto), port2, 371 rtype == RELAY_GTURN, true, true, true); 372 } 373 void TestStunToLocal(NATType ntype) { 374 nat_server1_.reset(CreateNatServer(kNatAddr1, ntype)); 375 Port* port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_); 376 Port* port2 = CreateUdpPort(kLocalAddr2); 377 TestConnectivity(StunName(ntype), port1, "udp", port2, 378 true, ntype != NAT_SYMMETRIC, true, true); 379 } 380 void TestStunToStun(NATType ntype1, NATType ntype2) { 381 nat_server1_.reset(CreateNatServer(kNatAddr1, ntype1)); 382 Port* port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_); 383 nat_server2_.reset(CreateNatServer(kNatAddr2, ntype2)); 384 Port* port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_); 385 TestConnectivity(StunName(ntype1), port1, StunName(ntype2), port2, 386 ntype2 == NAT_OPEN_CONE, 387 ntype1 != NAT_SYMMETRIC, ntype2 != NAT_SYMMETRIC, 388 ntype1 + ntype2 < (NAT_PORT_RESTRICTED + NAT_SYMMETRIC)); 389 } 390 void TestStunToRelay(NATType ntype, RelayType rtype, ProtocolType proto) { 391 nat_server1_.reset(CreateNatServer(kNatAddr1, ntype)); 392 Port* port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_); 393 Port* port2 = CreateRelayPort(kLocalAddr2, rtype, proto, PROTO_UDP); 394 TestConnectivity(StunName(ntype), port1, RelayName(rtype, proto), port2, 395 rtype == RELAY_GTURN, ntype != NAT_SYMMETRIC, true, true); 396 } 397 void TestTcpToTcp() { 398 Port* port1 = CreateTcpPort(kLocalAddr1); 399 Port* port2 = CreateTcpPort(kLocalAddr2); 400 TestConnectivity("tcp", port1, "tcp", port2, true, false, true, true); 401 } 402 void TestTcpToRelay(RelayType rtype, ProtocolType proto) { 403 Port* port1 = CreateTcpPort(kLocalAddr1); 404 Port* port2 = CreateRelayPort(kLocalAddr2, rtype, proto, PROTO_TCP); 405 TestConnectivity("tcp", port1, RelayName(rtype, proto), port2, 406 rtype == RELAY_GTURN, false, true, true); 407 } 408 void TestSslTcpToRelay(RelayType rtype, ProtocolType proto) { 409 Port* port1 = CreateTcpPort(kLocalAddr1); 410 Port* port2 = CreateRelayPort(kLocalAddr2, rtype, proto, PROTO_SSLTCP); 411 TestConnectivity("ssltcp", port1, RelayName(rtype, proto), port2, 412 rtype == RELAY_GTURN, false, true, true); 413 } 414 415 // helpers for above functions 416 UDPPort* CreateUdpPort(const SocketAddress& addr) { 417 return CreateUdpPort(addr, &socket_factory_); 418 } 419 UDPPort* CreateUdpPort(const SocketAddress& addr, 420 PacketSocketFactory* socket_factory) { 421 UDPPort* port = UDPPort::Create(main_, socket_factory, &network_, 422 addr.ipaddr(), 0, 0, username_, password_); 423 port->SetIceProtocolType(ice_protocol_); 424 return port; 425 } 426 TCPPort* CreateTcpPort(const SocketAddress& addr) { 427 TCPPort* port = CreateTcpPort(addr, &socket_factory_); 428 port->SetIceProtocolType(ice_protocol_); 429 return port; 430 } 431 TCPPort* CreateTcpPort(const SocketAddress& addr, 432 PacketSocketFactory* socket_factory) { 433 TCPPort* port = TCPPort::Create(main_, socket_factory, &network_, 434 addr.ipaddr(), 0, 0, username_, password_, 435 true); 436 port->SetIceProtocolType(ice_protocol_); 437 return port; 438 } 439 StunPort* CreateStunPort(const SocketAddress& addr, 440 talk_base::PacketSocketFactory* factory) { 441 StunPort* port = StunPort::Create(main_, factory, &network_, 442 addr.ipaddr(), 0, 0, 443 username_, password_, kStunAddr); 444 port->SetIceProtocolType(ice_protocol_); 445 return port; 446 } 447 Port* CreateRelayPort(const SocketAddress& addr, RelayType rtype, 448 ProtocolType int_proto, ProtocolType ext_proto) { 449 if (rtype == RELAY_TURN) { 450 return CreateTurnPort(addr, &socket_factory_, int_proto, ext_proto); 451 } else { 452 return CreateGturnPort(addr, int_proto, ext_proto); 453 } 454 } 455 TurnPort* CreateTurnPort(const SocketAddress& addr, 456 PacketSocketFactory* socket_factory, 457 ProtocolType int_proto, ProtocolType ext_proto) { 458 TurnPort* port = TurnPort::Create(main_, socket_factory, &network_, 459 addr.ipaddr(), 0, 0, 460 username_, password_, ProtocolAddress( 461 kTurnUdpIntAddr, PROTO_UDP), 462 kRelayCredentials); 463 port->SetIceProtocolType(ice_protocol_); 464 return port; 465 } 466 RelayPort* CreateGturnPort(const SocketAddress& addr, 467 ProtocolType int_proto, ProtocolType ext_proto) { 468 RelayPort* port = CreateGturnPort(addr); 469 SocketAddress addrs[] = 470 { kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr }; 471 port->AddServerAddress(ProtocolAddress(addrs[int_proto], int_proto)); 472 return port; 473 } 474 RelayPort* CreateGturnPort(const SocketAddress& addr) { 475 RelayPort* port = RelayPort::Create(main_, &socket_factory_, &network_, 476 addr.ipaddr(), 0, 0, 477 username_, password_); 478 // TODO: Add an external address for ext_proto, so that the 479 // other side can connect to this port using a non-UDP protocol. 480 port->SetIceProtocolType(ice_protocol_); 481 return port; 482 } 483 talk_base::NATServer* CreateNatServer(const SocketAddress& addr, 484 talk_base::NATType type) { 485 return new talk_base::NATServer(type, ss_.get(), addr, ss_.get(), addr); 486 } 487 static const char* StunName(NATType type) { 488 switch (type) { 489 case NAT_OPEN_CONE: return "stun(open cone)"; 490 case NAT_ADDR_RESTRICTED: return "stun(addr restricted)"; 491 case NAT_PORT_RESTRICTED: return "stun(port restricted)"; 492 case NAT_SYMMETRIC: return "stun(symmetric)"; 493 default: return "stun(?)"; 494 } 495 } 496 static const char* RelayName(RelayType type, ProtocolType proto) { 497 if (type == RELAY_TURN) { 498 switch (proto) { 499 case PROTO_UDP: return "turn(udp)"; 500 case PROTO_TCP: return "turn(tcp)"; 501 case PROTO_SSLTCP: return "turn(ssltcp)"; 502 default: return "turn(?)"; 503 } 504 } else { 505 switch (proto) { 506 case PROTO_UDP: return "gturn(udp)"; 507 case PROTO_TCP: return "gturn(tcp)"; 508 case PROTO_SSLTCP: return "gturn(ssltcp)"; 509 default: return "gturn(?)"; 510 } 511 } 512 } 513 514 void TestCrossFamilyPorts(int type); 515 516 // this does all the work 517 void TestConnectivity(const char* name1, Port* port1, 518 const char* name2, Port* port2, 519 bool accept, bool same_addr1, 520 bool same_addr2, bool possible); 521 522 void SetIceProtocolType(cricket::IceProtocolType protocol) { 523 ice_protocol_ = protocol; 524 } 525 526 IceMessage* CreateStunMessage(int type) { 527 IceMessage* msg = new IceMessage(); 528 msg->SetType(type); 529 msg->SetTransactionID("TESTTESTTEST"); 530 return msg; 531 } 532 IceMessage* CreateStunMessageWithUsername(int type, 533 const std::string& username) { 534 IceMessage* msg = CreateStunMessage(type); 535 msg->AddAttribute( 536 new StunByteStringAttribute(STUN_ATTR_USERNAME, username)); 537 return msg; 538 } 539 TestPort* CreateTestPort(const talk_base::SocketAddress& addr, 540 const std::string& username, 541 const std::string& password) { 542 TestPort* port = new TestPort(main_, "test", &socket_factory_, &network_, 543 addr.ipaddr(), 0, 0, username, password); 544 port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict); 545 return port; 546 } 547 TestPort* CreateTestPort(const talk_base::SocketAddress& addr, 548 const std::string& username, 549 const std::string& password, 550 cricket::IceProtocolType type, 551 cricket::IceRole role, 552 int tiebreaker) { 553 TestPort* port = CreateTestPort(addr, username, password); 554 port->SetIceProtocolType(type); 555 port->SetIceRole(role); 556 port->SetIceTiebreaker(tiebreaker); 557 return port; 558 } 559 560 void OnRoleConflict(PortInterface* port) { 561 role_conflict_ = true; 562 } 563 bool role_conflict() const { return role_conflict_; } 564 565 talk_base::BasicPacketSocketFactory* nat_socket_factory1() { 566 return &nat_socket_factory1_; 567 } 568 569 private: 570 talk_base::Thread* main_; 571 talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_; 572 talk_base::scoped_ptr<talk_base::VirtualSocketServer> ss_; 573 talk_base::SocketServerScope ss_scope_; 574 talk_base::Network network_; 575 talk_base::BasicPacketSocketFactory socket_factory_; 576 talk_base::scoped_ptr<talk_base::NATServer> nat_server1_; 577 talk_base::scoped_ptr<talk_base::NATServer> nat_server2_; 578 talk_base::NATSocketFactory nat_factory1_; 579 talk_base::NATSocketFactory nat_factory2_; 580 talk_base::BasicPacketSocketFactory nat_socket_factory1_; 581 talk_base::BasicPacketSocketFactory nat_socket_factory2_; 582 TestStunServer stun_server_; 583 TestTurnServer turn_server_; 584 TestRelayServer relay_server_; 585 std::string username_; 586 std::string password_; 587 cricket::IceProtocolType ice_protocol_; 588 bool role_conflict_; 589 }; 590 591 void PortTest::TestConnectivity(const char* name1, Port* port1, 592 const char* name2, Port* port2, 593 bool accept, bool same_addr1, 594 bool same_addr2, bool possible) { 595 LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": "; 596 port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT); 597 port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT); 598 599 // Set up channels. 600 TestChannel ch1(port1, port2); 601 TestChannel ch2(port2, port1); 602 EXPECT_EQ(0, ch1.complete_count()); 603 EXPECT_EQ(0, ch2.complete_count()); 604 605 // Acquire addresses. 606 ch1.Start(); 607 ch2.Start(); 608 ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout); 609 ASSERT_EQ_WAIT(1, ch2.complete_count(), kTimeout); 610 611 // Send a ping from src to dst. This may or may not make it. 612 ch1.CreateConnection(); 613 ASSERT_TRUE(ch1.conn() != NULL); 614 EXPECT_TRUE_WAIT(ch1.conn()->connected(), kTimeout); // for TCP connect 615 ch1.Ping(); 616 WAIT(!ch2.remote_address().IsNil(), kTimeout); 617 618 if (accept) { 619 // We are able to send a ping from src to dst. This is the case when 620 // sending to UDP ports and cone NATs. 621 EXPECT_TRUE(ch1.remote_address().IsNil()); 622 EXPECT_EQ(ch2.remote_fragment(), port1->username_fragment()); 623 624 // Ensure the ping came from the same address used for src. 625 // This is the case unless the source NAT was symmetric. 626 if (same_addr1) EXPECT_EQ(ch2.remote_address(), GetAddress(port1)); 627 EXPECT_TRUE(same_addr2); 628 629 // Send a ping from dst to src. 630 ch2.AcceptConnection(); 631 ASSERT_TRUE(ch2.conn() != NULL); 632 ch2.Ping(); 633 EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2.conn()->write_state(), 634 kTimeout); 635 } else { 636 // We can't send a ping from src to dst, so flip it around. This will happen 637 // when the destination NAT is addr/port restricted or symmetric. 638 EXPECT_TRUE(ch1.remote_address().IsNil()); 639 EXPECT_TRUE(ch2.remote_address().IsNil()); 640 641 // Send a ping from dst to src. Again, this may or may not make it. 642 ch2.CreateConnection(); 643 ASSERT_TRUE(ch2.conn() != NULL); 644 ch2.Ping(); 645 WAIT(ch2.conn()->write_state() == Connection::STATE_WRITABLE, kTimeout); 646 647 if (same_addr1 && same_addr2) { 648 // The new ping got back to the source. 649 EXPECT_EQ(Connection::STATE_READABLE, ch1.conn()->read_state()); 650 EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state()); 651 652 // First connection may not be writable if the first ping did not get 653 // through. So we will have to do another. 654 if (ch1.conn()->write_state() == Connection::STATE_WRITE_INIT) { 655 ch1.Ping(); 656 EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(), 657 kTimeout); 658 } 659 } else if (!same_addr1 && possible) { 660 // The new ping went to the candidate address, but that address was bad. 661 // This will happen when the source NAT is symmetric. 662 EXPECT_TRUE(ch1.remote_address().IsNil()); 663 EXPECT_TRUE(ch2.remote_address().IsNil()); 664 665 // However, since we have now sent a ping to the source IP, we should be 666 // able to get a ping from it. This gives us the real source address. 667 ch1.Ping(); 668 EXPECT_TRUE_WAIT(!ch2.remote_address().IsNil(), kTimeout); 669 EXPECT_EQ(Connection::STATE_READ_INIT, ch2.conn()->read_state()); 670 EXPECT_TRUE(ch1.remote_address().IsNil()); 671 672 // Pick up the actual address and establish the connection. 673 ch2.AcceptConnection(); 674 ASSERT_TRUE(ch2.conn() != NULL); 675 ch2.Ping(); 676 EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2.conn()->write_state(), 677 kTimeout); 678 } else if (!same_addr2 && possible) { 679 // The new ping came in, but from an unexpected address. This will happen 680 // when the destination NAT is symmetric. 681 EXPECT_FALSE(ch1.remote_address().IsNil()); 682 EXPECT_EQ(Connection::STATE_READ_INIT, ch1.conn()->read_state()); 683 684 // Update our address and complete the connection. 685 ch1.AcceptConnection(); 686 ch1.Ping(); 687 EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(), 688 kTimeout); 689 } else { // (!possible) 690 // There should be s no way for the pings to reach each other. Check it. 691 EXPECT_TRUE(ch1.remote_address().IsNil()); 692 EXPECT_TRUE(ch2.remote_address().IsNil()); 693 ch1.Ping(); 694 WAIT(!ch2.remote_address().IsNil(), kTimeout); 695 EXPECT_TRUE(ch1.remote_address().IsNil()); 696 EXPECT_TRUE(ch2.remote_address().IsNil()); 697 } 698 } 699 700 // Everything should be good, unless we know the situation is impossible. 701 ASSERT_TRUE(ch1.conn() != NULL); 702 ASSERT_TRUE(ch2.conn() != NULL); 703 if (possible) { 704 EXPECT_EQ(Connection::STATE_READABLE, ch1.conn()->read_state()); 705 EXPECT_EQ(Connection::STATE_WRITABLE, ch1.conn()->write_state()); 706 EXPECT_EQ(Connection::STATE_READABLE, ch2.conn()->read_state()); 707 EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state()); 708 } else { 709 EXPECT_NE(Connection::STATE_READABLE, ch1.conn()->read_state()); 710 EXPECT_NE(Connection::STATE_WRITABLE, ch1.conn()->write_state()); 711 EXPECT_NE(Connection::STATE_READABLE, ch2.conn()->read_state()); 712 EXPECT_NE(Connection::STATE_WRITABLE, ch2.conn()->write_state()); 713 } 714 715 // Tear down and ensure that goes smoothly. 716 ch1.Stop(); 717 ch2.Stop(); 718 EXPECT_TRUE_WAIT(ch1.conn() == NULL, kTimeout); 719 EXPECT_TRUE_WAIT(ch2.conn() == NULL, kTimeout); 720 } 721 722 class FakePacketSocketFactory : public talk_base::PacketSocketFactory { 723 public: 724 FakePacketSocketFactory() 725 : next_udp_socket_(NULL), 726 next_server_tcp_socket_(NULL), 727 next_client_tcp_socket_(NULL) { 728 } 729 virtual ~FakePacketSocketFactory() { } 730 731 virtual AsyncPacketSocket* CreateUdpSocket( 732 const SocketAddress& address, int min_port, int max_port) { 733 EXPECT_TRUE(next_udp_socket_ != NULL); 734 AsyncPacketSocket* result = next_udp_socket_; 735 next_udp_socket_ = NULL; 736 return result; 737 } 738 739 virtual AsyncPacketSocket* CreateServerTcpSocket( 740 const SocketAddress& local_address, int min_port, int max_port, 741 int opts) { 742 EXPECT_TRUE(next_server_tcp_socket_ != NULL); 743 AsyncPacketSocket* result = next_server_tcp_socket_; 744 next_server_tcp_socket_ = NULL; 745 return result; 746 } 747 748 // TODO: |proxy_info| and |user_agent| should be set 749 // per-factory and not when socket is created. 750 virtual AsyncPacketSocket* CreateClientTcpSocket( 751 const SocketAddress& local_address, const SocketAddress& remote_address, 752 const talk_base::ProxyInfo& proxy_info, 753 const std::string& user_agent, int opts) { 754 EXPECT_TRUE(next_client_tcp_socket_ != NULL); 755 AsyncPacketSocket* result = next_client_tcp_socket_; 756 next_client_tcp_socket_ = NULL; 757 return result; 758 } 759 760 void set_next_udp_socket(AsyncPacketSocket* next_udp_socket) { 761 next_udp_socket_ = next_udp_socket; 762 } 763 void set_next_server_tcp_socket(AsyncPacketSocket* next_server_tcp_socket) { 764 next_server_tcp_socket_ = next_server_tcp_socket; 765 } 766 void set_next_client_tcp_socket(AsyncPacketSocket* next_client_tcp_socket) { 767 next_client_tcp_socket_ = next_client_tcp_socket; 768 } 769 770 private: 771 AsyncPacketSocket* next_udp_socket_; 772 AsyncPacketSocket* next_server_tcp_socket_; 773 AsyncPacketSocket* next_client_tcp_socket_; 774 }; 775 776 class FakeAsyncPacketSocket : public AsyncPacketSocket { 777 public: 778 // Returns current local address. Address may be set to NULL if the 779 // socket is not bound yet (GetState() returns STATE_BINDING). 780 virtual SocketAddress GetLocalAddress() const { 781 return SocketAddress(); 782 } 783 784 // Returns remote address. Returns zeroes if this is not a client TCP socket. 785 virtual SocketAddress GetRemoteAddress() const { 786 return SocketAddress(); 787 } 788 789 // Send a packet. 790 virtual int Send(const void *pv, size_t cb) { 791 return static_cast<int>(cb); 792 } 793 virtual int SendTo(const void *pv, size_t cb, const SocketAddress& addr) { 794 return static_cast<int>(cb); 795 } 796 virtual int Close() { 797 return 0; 798 } 799 800 virtual State GetState() const { return state_; } 801 virtual int GetOption(Socket::Option opt, int* value) { return 0; } 802 virtual int SetOption(Socket::Option opt, int value) { return 0; } 803 virtual int GetError() const { return 0; } 804 virtual void SetError(int error) { } 805 806 void set_state(State state) { state_ = state; } 807 808 private: 809 State state_; 810 }; 811 812 // Local -> XXXX 813 TEST_F(PortTest, TestLocalToLocal) { 814 TestLocalToLocal(); 815 } 816 817 TEST_F(PortTest, TestLocalToConeNat) { 818 TestLocalToStun(NAT_OPEN_CONE); 819 } 820 821 TEST_F(PortTest, TestLocalToARNat) { 822 TestLocalToStun(NAT_ADDR_RESTRICTED); 823 } 824 825 TEST_F(PortTest, TestLocalToPRNat) { 826 TestLocalToStun(NAT_PORT_RESTRICTED); 827 } 828 829 TEST_F(PortTest, TestLocalToSymNat) { 830 TestLocalToStun(NAT_SYMMETRIC); 831 } 832 833 TEST_F(PortTest, TestLocalToTurn) { 834 TestLocalToRelay(RELAY_TURN, PROTO_UDP); 835 } 836 837 TEST_F(PortTest, TestLocalToGturn) { 838 TestLocalToRelay(RELAY_GTURN, PROTO_UDP); 839 } 840 841 TEST_F(PortTest, TestLocalToTcpGturn) { 842 TestLocalToRelay(RELAY_GTURN, PROTO_TCP); 843 } 844 845 TEST_F(PortTest, TestLocalToSslTcpGturn) { 846 TestLocalToRelay(RELAY_GTURN, PROTO_SSLTCP); 847 } 848 849 // Cone NAT -> XXXX 850 TEST_F(PortTest, TestConeNatToLocal) { 851 TestStunToLocal(NAT_OPEN_CONE); 852 } 853 854 TEST_F(PortTest, TestConeNatToConeNat) { 855 TestStunToStun(NAT_OPEN_CONE, NAT_OPEN_CONE); 856 } 857 858 TEST_F(PortTest, TestConeNatToARNat) { 859 TestStunToStun(NAT_OPEN_CONE, NAT_ADDR_RESTRICTED); 860 } 861 862 TEST_F(PortTest, TestConeNatToPRNat) { 863 TestStunToStun(NAT_OPEN_CONE, NAT_PORT_RESTRICTED); 864 } 865 866 TEST_F(PortTest, TestConeNatToSymNat) { 867 TestStunToStun(NAT_OPEN_CONE, NAT_SYMMETRIC); 868 } 869 870 TEST_F(PortTest, TestConeNatToTurn) { 871 TestStunToRelay(NAT_OPEN_CONE, RELAY_TURN, PROTO_UDP); 872 } 873 874 TEST_F(PortTest, TestConeNatToGturn) { 875 TestStunToRelay(NAT_OPEN_CONE, RELAY_GTURN, PROTO_UDP); 876 } 877 878 TEST_F(PortTest, TestConeNatToTcpGturn) { 879 TestStunToRelay(NAT_OPEN_CONE, RELAY_GTURN, PROTO_TCP); 880 } 881 882 // Address-restricted NAT -> XXXX 883 TEST_F(PortTest, TestARNatToLocal) { 884 TestStunToLocal(NAT_ADDR_RESTRICTED); 885 } 886 887 TEST_F(PortTest, TestARNatToConeNat) { 888 TestStunToStun(NAT_ADDR_RESTRICTED, NAT_OPEN_CONE); 889 } 890 891 TEST_F(PortTest, TestARNatToARNat) { 892 TestStunToStun(NAT_ADDR_RESTRICTED, NAT_ADDR_RESTRICTED); 893 } 894 895 TEST_F(PortTest, TestARNatToPRNat) { 896 TestStunToStun(NAT_ADDR_RESTRICTED, NAT_PORT_RESTRICTED); 897 } 898 899 TEST_F(PortTest, TestARNatToSymNat) { 900 TestStunToStun(NAT_ADDR_RESTRICTED, NAT_SYMMETRIC); 901 } 902 903 TEST_F(PortTest, TestARNatToTurn) { 904 TestStunToRelay(NAT_ADDR_RESTRICTED, RELAY_TURN, PROTO_UDP); 905 } 906 907 TEST_F(PortTest, TestARNatToGturn) { 908 TestStunToRelay(NAT_ADDR_RESTRICTED, RELAY_GTURN, PROTO_UDP); 909 } 910 911 TEST_F(PortTest, TestARNATNatToTcpGturn) { 912 TestStunToRelay(NAT_ADDR_RESTRICTED, RELAY_GTURN, PROTO_TCP); 913 } 914 915 // Port-restricted NAT -> XXXX 916 TEST_F(PortTest, TestPRNatToLocal) { 917 TestStunToLocal(NAT_PORT_RESTRICTED); 918 } 919 920 TEST_F(PortTest, TestPRNatToConeNat) { 921 TestStunToStun(NAT_PORT_RESTRICTED, NAT_OPEN_CONE); 922 } 923 924 TEST_F(PortTest, TestPRNatToARNat) { 925 TestStunToStun(NAT_PORT_RESTRICTED, NAT_ADDR_RESTRICTED); 926 } 927 928 TEST_F(PortTest, TestPRNatToPRNat) { 929 TestStunToStun(NAT_PORT_RESTRICTED, NAT_PORT_RESTRICTED); 930 } 931 932 TEST_F(PortTest, TestPRNatToSymNat) { 933 // Will "fail" 934 TestStunToStun(NAT_PORT_RESTRICTED, NAT_SYMMETRIC); 935 } 936 937 TEST_F(PortTest, TestPRNatToTurn) { 938 TestStunToRelay(NAT_PORT_RESTRICTED, RELAY_TURN, PROTO_UDP); 939 } 940 941 TEST_F(PortTest, TestPRNatToGturn) { 942 TestStunToRelay(NAT_PORT_RESTRICTED, RELAY_GTURN, PROTO_UDP); 943 } 944 945 TEST_F(PortTest, TestPRNatToTcpGturn) { 946 TestStunToRelay(NAT_PORT_RESTRICTED, RELAY_GTURN, PROTO_TCP); 947 } 948 949 // Symmetric NAT -> XXXX 950 TEST_F(PortTest, TestSymNatToLocal) { 951 TestStunToLocal(NAT_SYMMETRIC); 952 } 953 954 TEST_F(PortTest, TestSymNatToConeNat) { 955 TestStunToStun(NAT_SYMMETRIC, NAT_OPEN_CONE); 956 } 957 958 TEST_F(PortTest, TestSymNatToARNat) { 959 TestStunToStun(NAT_SYMMETRIC, NAT_ADDR_RESTRICTED); 960 } 961 962 TEST_F(PortTest, TestSymNatToPRNat) { 963 // Will "fail" 964 TestStunToStun(NAT_SYMMETRIC, NAT_PORT_RESTRICTED); 965 } 966 967 TEST_F(PortTest, TestSymNatToSymNat) { 968 // Will "fail" 969 TestStunToStun(NAT_SYMMETRIC, NAT_SYMMETRIC); 970 } 971 972 TEST_F(PortTest, TestSymNatToTurn) { 973 TestStunToRelay(NAT_SYMMETRIC, RELAY_TURN, PROTO_UDP); 974 } 975 976 TEST_F(PortTest, TestSymNatToGturn) { 977 TestStunToRelay(NAT_SYMMETRIC, RELAY_GTURN, PROTO_UDP); 978 } 979 980 TEST_F(PortTest, TestSymNatToTcpGturn) { 981 TestStunToRelay(NAT_SYMMETRIC, RELAY_GTURN, PROTO_TCP); 982 } 983 984 // Outbound TCP -> XXXX 985 TEST_F(PortTest, TestTcpToTcp) { 986 TestTcpToTcp(); 987 } 988 989 /* TODO: Enable these once testrelayserver can accept external TCP. 990 TEST_F(PortTest, TestTcpToTcpRelay) { 991 TestTcpToRelay(PROTO_TCP); 992 } 993 994 TEST_F(PortTest, TestTcpToSslTcpRelay) { 995 TestTcpToRelay(PROTO_SSLTCP); 996 } 997 */ 998 999 // Outbound SSLTCP -> XXXX 1000 /* TODO: Enable these once testrelayserver can accept external SSL. 1001 TEST_F(PortTest, TestSslTcpToTcpRelay) { 1002 TestSslTcpToRelay(PROTO_TCP); 1003 } 1004 1005 TEST_F(PortTest, TestSslTcpToSslTcpRelay) { 1006 TestSslTcpToRelay(PROTO_SSLTCP); 1007 } 1008 */ 1009 1010 // This test case verifies standard ICE features in STUN messages. Currently it 1011 // verifies Message Integrity attribute in STUN messages and username in STUN 1012 // binding request will have colon (":") between remote and local username. 1013 TEST_F(PortTest, TestLocalToLocalAsIce) { 1014 SetIceProtocolType(cricket::ICEPROTO_RFC5245); 1015 UDPPort* port1 = CreateUdpPort(kLocalAddr1); 1016 port1->SetIceRole(cricket::ICEROLE_CONTROLLING); 1017 port1->SetIceTiebreaker(kTiebreaker1); 1018 ASSERT_EQ(cricket::ICEPROTO_RFC5245, port1->IceProtocol()); 1019 UDPPort* port2 = CreateUdpPort(kLocalAddr2); 1020 port2->SetIceRole(cricket::ICEROLE_CONTROLLED); 1021 port2->SetIceTiebreaker(kTiebreaker2); 1022 ASSERT_EQ(cricket::ICEPROTO_RFC5245, port2->IceProtocol()); 1023 // Same parameters as TestLocalToLocal above. 1024 TestConnectivity("udp", port1, "udp", port2, true, true, true, true); 1025 } 1026 1027 // This test is trying to validate a successful and failure scenario in a 1028 // loopback test when protocol is RFC5245. For success IceTiebreaker, username 1029 // should remain equal to the request generated by the port and role of port 1030 // must be in controlling. 1031 TEST_F(PortTest, TestLoopbackCallAsIce) { 1032 talk_base::scoped_ptr<TestPort> lport( 1033 CreateTestPort(kLocalAddr1, "lfrag", "lpass")); 1034 lport->SetIceProtocolType(ICEPROTO_RFC5245); 1035 lport->SetIceRole(cricket::ICEROLE_CONTROLLING); 1036 lport->SetIceTiebreaker(kTiebreaker1); 1037 lport->PrepareAddress(); 1038 ASSERT_FALSE(lport->Candidates().empty()); 1039 Connection* conn = lport->CreateConnection(lport->Candidates()[0], 1040 Port::ORIGIN_MESSAGE); 1041 conn->Ping(0); 1042 1043 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1044 IceMessage* msg = lport->last_stun_msg(); 1045 EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); 1046 conn->OnReadPacket(lport->last_stun_buf()->Data(), 1047 lport->last_stun_buf()->Length()); 1048 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1049 msg = lport->last_stun_msg(); 1050 EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type()); 1051 1052 // If the tiebreaker value is different from port, we expect a error 1053 // response. 1054 lport->Reset(); 1055 lport->AddCandidateAddress(kLocalAddr2); 1056 // Creating a different connection as |conn| is in STATE_READABLE. 1057 Connection* conn1 = lport->CreateConnection(lport->Candidates()[1], 1058 Port::ORIGIN_MESSAGE); 1059 conn1->Ping(0); 1060 1061 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1062 msg = lport->last_stun_msg(); 1063 EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); 1064 talk_base::scoped_ptr<IceMessage> modified_req( 1065 CreateStunMessage(STUN_BINDING_REQUEST)); 1066 const StunByteStringAttribute* username_attr = msg->GetByteString( 1067 STUN_ATTR_USERNAME); 1068 modified_req->AddAttribute(new StunByteStringAttribute( 1069 STUN_ATTR_USERNAME, username_attr->GetString())); 1070 // To make sure we receive error response, adding tiebreaker less than 1071 // what's present in request. 1072 modified_req->AddAttribute(new StunUInt64Attribute( 1073 STUN_ATTR_ICE_CONTROLLING, kTiebreaker1 - 1)); 1074 modified_req->AddMessageIntegrity("lpass"); 1075 modified_req->AddFingerprint(); 1076 1077 lport->Reset(); 1078 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1079 WriteStunMessage(modified_req.get(), buf.get()); 1080 conn1->OnReadPacket(buf->Data(), buf->Length()); 1081 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1082 msg = lport->last_stun_msg(); 1083 EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type()); 1084 } 1085 1086 // This test verifies role conflict signal is received when there is 1087 // conflict in the role. In this case both ports are in controlling and 1088 // |rport| has higher tiebreaker value than |lport|. Since |lport| has lower 1089 // value of tiebreaker, when it receives ping request from |rport| it will 1090 // send role conflict signal. 1091 TEST_F(PortTest, TestIceRoleConflict) { 1092 talk_base::scoped_ptr<TestPort> lport( 1093 CreateTestPort(kLocalAddr1, "lfrag", "lpass")); 1094 lport->SetIceProtocolType(ICEPROTO_RFC5245); 1095 lport->SetIceRole(cricket::ICEROLE_CONTROLLING); 1096 lport->SetIceTiebreaker(kTiebreaker1); 1097 talk_base::scoped_ptr<TestPort> rport( 1098 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1099 rport->SetIceProtocolType(ICEPROTO_RFC5245); 1100 rport->SetIceRole(cricket::ICEROLE_CONTROLLING); 1101 rport->SetIceTiebreaker(kTiebreaker2); 1102 1103 lport->PrepareAddress(); 1104 rport->PrepareAddress(); 1105 ASSERT_FALSE(lport->Candidates().empty()); 1106 ASSERT_FALSE(rport->Candidates().empty()); 1107 Connection* lconn = lport->CreateConnection(rport->Candidates()[0], 1108 Port::ORIGIN_MESSAGE); 1109 Connection* rconn = rport->CreateConnection(lport->Candidates()[0], 1110 Port::ORIGIN_MESSAGE); 1111 rconn->Ping(0); 1112 1113 ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000); 1114 IceMessage* msg = rport->last_stun_msg(); 1115 EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); 1116 // Send rport binding request to lport. 1117 lconn->OnReadPacket(rport->last_stun_buf()->Data(), 1118 rport->last_stun_buf()->Length()); 1119 1120 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1121 EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type()); 1122 EXPECT_TRUE(role_conflict()); 1123 } 1124 1125 TEST_F(PortTest, TestTcpNoDelay) { 1126 TCPPort* port1 = CreateTcpPort(kLocalAddr1); 1127 int option_value = -1; 1128 int success = port1->GetOption(talk_base::Socket::OPT_NODELAY, 1129 &option_value); 1130 ASSERT_EQ(0, success); // GetOption() should complete successfully w/ 0 1131 ASSERT_EQ(1, option_value); 1132 delete port1; 1133 } 1134 1135 TEST_F(PortTest, TestDelayedBindingUdp) { 1136 FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket(); 1137 FakePacketSocketFactory socket_factory; 1138 1139 socket_factory.set_next_udp_socket(socket); 1140 scoped_ptr<UDPPort> port( 1141 CreateUdpPort(kLocalAddr1, &socket_factory)); 1142 1143 socket->set_state(AsyncPacketSocket::STATE_BINDING); 1144 port->PrepareAddress(); 1145 1146 EXPECT_EQ(0U, port->Candidates().size()); 1147 socket->SignalAddressReady(socket, kLocalAddr2); 1148 1149 EXPECT_EQ(1U, port->Candidates().size()); 1150 } 1151 1152 TEST_F(PortTest, TestDelayedBindingTcp) { 1153 FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket(); 1154 FakePacketSocketFactory socket_factory; 1155 1156 socket_factory.set_next_server_tcp_socket(socket); 1157 scoped_ptr<TCPPort> port( 1158 CreateTcpPort(kLocalAddr1, &socket_factory)); 1159 1160 socket->set_state(AsyncPacketSocket::STATE_BINDING); 1161 port->PrepareAddress(); 1162 1163 EXPECT_EQ(0U, port->Candidates().size()); 1164 socket->SignalAddressReady(socket, kLocalAddr2); 1165 1166 EXPECT_EQ(1U, port->Candidates().size()); 1167 } 1168 1169 void PortTest::TestCrossFamilyPorts(int type) { 1170 FakePacketSocketFactory factory; 1171 scoped_ptr<Port> ports[4]; 1172 SocketAddress addresses[4] = {SocketAddress("192.168.1.3", 0), 1173 SocketAddress("192.168.1.4", 0), 1174 SocketAddress("2001:db8::1", 0), 1175 SocketAddress("2001:db8::2", 0)}; 1176 for (int i = 0; i < 4; i++) { 1177 FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket(); 1178 if (type == SOCK_DGRAM) { 1179 factory.set_next_udp_socket(socket); 1180 ports[i].reset(CreateUdpPort(addresses[i], &factory)); 1181 } else if (type == SOCK_STREAM) { 1182 factory.set_next_server_tcp_socket(socket); 1183 ports[i].reset(CreateTcpPort(addresses[i], &factory)); 1184 } 1185 socket->set_state(AsyncPacketSocket::STATE_BINDING); 1186 socket->SignalAddressReady(socket, addresses[i]); 1187 ports[i]->PrepareAddress(); 1188 } 1189 1190 // IPv4 Port, connects to IPv6 candidate and then to IPv4 candidate. 1191 if (type == SOCK_STREAM) { 1192 FakeAsyncPacketSocket* clientsocket = new FakeAsyncPacketSocket(); 1193 factory.set_next_client_tcp_socket(clientsocket); 1194 } 1195 Connection* c = ports[0]->CreateConnection(GetCandidate(ports[2].get()), 1196 Port::ORIGIN_MESSAGE); 1197 EXPECT_TRUE(NULL == c); 1198 EXPECT_EQ(0U, ports[0]->connections().size()); 1199 c = ports[0]->CreateConnection(GetCandidate(ports[1].get()), 1200 Port::ORIGIN_MESSAGE); 1201 EXPECT_FALSE(NULL == c); 1202 EXPECT_EQ(1U, ports[0]->connections().size()); 1203 1204 // IPv6 Port, connects to IPv4 candidate and to IPv6 candidate. 1205 if (type == SOCK_STREAM) { 1206 FakeAsyncPacketSocket* clientsocket = new FakeAsyncPacketSocket(); 1207 factory.set_next_client_tcp_socket(clientsocket); 1208 } 1209 c = ports[2]->CreateConnection(GetCandidate(ports[0].get()), 1210 Port::ORIGIN_MESSAGE); 1211 EXPECT_TRUE(NULL == c); 1212 EXPECT_EQ(0U, ports[2]->connections().size()); 1213 c = ports[2]->CreateConnection(GetCandidate(ports[3].get()), 1214 Port::ORIGIN_MESSAGE); 1215 EXPECT_FALSE(NULL == c); 1216 EXPECT_EQ(1U, ports[2]->connections().size()); 1217 } 1218 1219 TEST_F(PortTest, TestSkipCrossFamilyTcp) { 1220 TestCrossFamilyPorts(SOCK_STREAM); 1221 } 1222 1223 TEST_F(PortTest, TestSkipCrossFamilyUdp) { 1224 TestCrossFamilyPorts(SOCK_DGRAM); 1225 } 1226 1227 // Test sending STUN messages in GICE format. 1228 TEST_F(PortTest, TestSendStunMessageAsGice) { 1229 talk_base::scoped_ptr<TestPort> lport( 1230 CreateTestPort(kLocalAddr1, "lfrag", "lpass")); 1231 talk_base::scoped_ptr<TestPort> rport( 1232 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1233 lport->SetIceProtocolType(ICEPROTO_GOOGLE); 1234 rport->SetIceProtocolType(ICEPROTO_GOOGLE); 1235 1236 // Send a fake ping from lport to rport. 1237 lport->PrepareAddress(); 1238 rport->PrepareAddress(); 1239 ASSERT_FALSE(rport->Candidates().empty()); 1240 Connection* conn = lport->CreateConnection(rport->Candidates()[0], 1241 Port::ORIGIN_MESSAGE); 1242 rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE); 1243 conn->Ping(0); 1244 1245 // Check that it's a proper BINDING-REQUEST. 1246 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1247 IceMessage* msg = lport->last_stun_msg(); 1248 EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); 1249 EXPECT_FALSE(msg->IsLegacy()); 1250 const StunByteStringAttribute* username_attr = msg->GetByteString( 1251 STUN_ATTR_USERNAME); 1252 ASSERT_TRUE(username_attr != NULL); 1253 EXPECT_EQ("rfraglfrag", username_attr->GetString()); 1254 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) == NULL); 1255 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL); 1256 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_FINGERPRINT) == NULL); 1257 1258 // Save a copy of the BINDING-REQUEST for use below. 1259 talk_base::scoped_ptr<IceMessage> request(CopyStunMessage(msg)); 1260 1261 // Respond with a BINDING-RESPONSE. 1262 rport->SendBindingResponse(request.get(), lport->Candidates()[0].address()); 1263 msg = rport->last_stun_msg(); 1264 ASSERT_TRUE(msg != NULL); 1265 EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type()); 1266 EXPECT_FALSE(msg->IsLegacy()); 1267 username_attr = msg->GetByteString(STUN_ATTR_USERNAME); 1268 ASSERT_TRUE(username_attr != NULL); // GICE has a username in the response. 1269 EXPECT_EQ("rfraglfrag", username_attr->GetString()); 1270 const StunAddressAttribute* addr_attr = msg->GetAddress( 1271 STUN_ATTR_MAPPED_ADDRESS); 1272 ASSERT_TRUE(addr_attr != NULL); 1273 EXPECT_EQ(lport->Candidates()[0].address(), addr_attr->GetAddress()); 1274 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_XOR_MAPPED_ADDRESS) == NULL); 1275 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) == NULL); 1276 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL); 1277 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_FINGERPRINT) == NULL); 1278 1279 // Respond with a BINDING-ERROR-RESPONSE. This wouldn't happen in real life, 1280 // but we can do it here. 1281 rport->SendBindingErrorResponse(request.get(), 1282 rport->Candidates()[0].address(), 1283 STUN_ERROR_SERVER_ERROR, 1284 STUN_ERROR_REASON_SERVER_ERROR); 1285 msg = rport->last_stun_msg(); 1286 ASSERT_TRUE(msg != NULL); 1287 EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type()); 1288 EXPECT_FALSE(msg->IsLegacy()); 1289 username_attr = msg->GetByteString(STUN_ATTR_USERNAME); 1290 ASSERT_TRUE(username_attr != NULL); // GICE has a username in the response. 1291 EXPECT_EQ("rfraglfrag", username_attr->GetString()); 1292 const StunErrorCodeAttribute* error_attr = msg->GetErrorCode(); 1293 ASSERT_TRUE(error_attr != NULL); 1294 // The GICE wire format for error codes is incorrect. 1295 EXPECT_EQ(STUN_ERROR_SERVER_ERROR_AS_GICE, error_attr->code()); 1296 EXPECT_EQ(STUN_ERROR_SERVER_ERROR / 256, error_attr->eclass()); 1297 EXPECT_EQ(STUN_ERROR_SERVER_ERROR % 256, error_attr->number()); 1298 EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR), error_attr->reason()); 1299 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL); 1300 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) == NULL); 1301 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_FINGERPRINT) == NULL); 1302 } 1303 1304 // Test sending STUN messages in ICE format. 1305 TEST_F(PortTest, TestSendStunMessageAsIce) { 1306 talk_base::scoped_ptr<TestPort> lport( 1307 CreateTestPort(kLocalAddr1, "lfrag", "lpass")); 1308 talk_base::scoped_ptr<TestPort> rport( 1309 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1310 lport->SetIceProtocolType(ICEPROTO_RFC5245); 1311 lport->SetIceRole(cricket::ICEROLE_CONTROLLING); 1312 lport->SetIceTiebreaker(kTiebreaker1); 1313 rport->SetIceProtocolType(ICEPROTO_RFC5245); 1314 rport->SetIceRole(cricket::ICEROLE_CONTROLLED); 1315 rport->SetIceTiebreaker(kTiebreaker2); 1316 1317 // Send a fake ping from lport to rport. 1318 lport->PrepareAddress(); 1319 rport->PrepareAddress(); 1320 ASSERT_FALSE(rport->Candidates().empty()); 1321 Connection* lconn = lport->CreateConnection( 1322 rport->Candidates()[0], Port::ORIGIN_MESSAGE); 1323 Connection* rconn = rport->CreateConnection( 1324 lport->Candidates()[0], Port::ORIGIN_MESSAGE); 1325 lconn->Ping(0); 1326 1327 // Check that it's a proper BINDING-REQUEST. 1328 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1329 IceMessage* msg = lport->last_stun_msg(); 1330 EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); 1331 EXPECT_FALSE(msg->IsLegacy()); 1332 const StunByteStringAttribute* username_attr = 1333 msg->GetByteString(STUN_ATTR_USERNAME); 1334 ASSERT_TRUE(username_attr != NULL); 1335 const StunUInt32Attribute* priority_attr = msg->GetUInt32(STUN_ATTR_PRIORITY); 1336 ASSERT_TRUE(priority_attr != NULL); 1337 EXPECT_EQ(kDefaultPrflxPriority, priority_attr->value()); 1338 EXPECT_EQ("rfrag:lfrag", username_attr->GetString()); 1339 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL); 1340 EXPECT_TRUE(StunMessage::ValidateMessageIntegrity( 1341 lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length(), 1342 "rpass")); 1343 const StunUInt64Attribute* ice_controlling_attr = 1344 msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING); 1345 ASSERT_TRUE(ice_controlling_attr != NULL); 1346 EXPECT_EQ(lport->IceTiebreaker(), ice_controlling_attr->value()); 1347 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLED) == NULL); 1348 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL); 1349 EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL); 1350 EXPECT_TRUE(StunMessage::ValidateFingerprint( 1351 lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length())); 1352 1353 // Request should not include ping count. 1354 ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL); 1355 1356 // Save a copy of the BINDING-REQUEST for use below. 1357 talk_base::scoped_ptr<IceMessage> request(CopyStunMessage(msg)); 1358 1359 // Respond with a BINDING-RESPONSE. 1360 rport->SendBindingResponse(request.get(), lport->Candidates()[0].address()); 1361 msg = rport->last_stun_msg(); 1362 ASSERT_TRUE(msg != NULL); 1363 EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type()); 1364 1365 1366 EXPECT_FALSE(msg->IsLegacy()); 1367 const StunAddressAttribute* addr_attr = msg->GetAddress( 1368 STUN_ATTR_XOR_MAPPED_ADDRESS); 1369 ASSERT_TRUE(addr_attr != NULL); 1370 EXPECT_EQ(lport->Candidates()[0].address(), addr_attr->GetAddress()); 1371 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL); 1372 EXPECT_TRUE(StunMessage::ValidateMessageIntegrity( 1373 rport->last_stun_buf()->Data(), rport->last_stun_buf()->Length(), 1374 "rpass")); 1375 EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL); 1376 EXPECT_TRUE(StunMessage::ValidateFingerprint( 1377 lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length())); 1378 // No USERNAME or PRIORITY in ICE responses. 1379 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL); 1380 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL); 1381 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MAPPED_ADDRESS) == NULL); 1382 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLING) == NULL); 1383 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLED) == NULL); 1384 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL); 1385 1386 // Response should not include ping count. 1387 ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL); 1388 1389 // Respond with a BINDING-ERROR-RESPONSE. This wouldn't happen in real life, 1390 // but we can do it here. 1391 rport->SendBindingErrorResponse(request.get(), 1392 lport->Candidates()[0].address(), 1393 STUN_ERROR_SERVER_ERROR, 1394 STUN_ERROR_REASON_SERVER_ERROR); 1395 msg = rport->last_stun_msg(); 1396 ASSERT_TRUE(msg != NULL); 1397 EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type()); 1398 EXPECT_FALSE(msg->IsLegacy()); 1399 const StunErrorCodeAttribute* error_attr = msg->GetErrorCode(); 1400 ASSERT_TRUE(error_attr != NULL); 1401 EXPECT_EQ(STUN_ERROR_SERVER_ERROR, error_attr->code()); 1402 EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR), error_attr->reason()); 1403 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL); 1404 EXPECT_TRUE(StunMessage::ValidateMessageIntegrity( 1405 rport->last_stun_buf()->Data(), rport->last_stun_buf()->Length(), 1406 "rpass")); 1407 EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL); 1408 EXPECT_TRUE(StunMessage::ValidateFingerprint( 1409 lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length())); 1410 // No USERNAME with ICE. 1411 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL); 1412 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL); 1413 1414 // Testing STUN binding requests from rport --> lport, having ICE_CONTROLLED 1415 // and (incremented) RETRANSMIT_COUNT attributes. 1416 rport->Reset(); 1417 rport->set_send_retransmit_count_attribute(true); 1418 rconn->Ping(0); 1419 rconn->Ping(0); 1420 rconn->Ping(0); 1421 ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000); 1422 msg = rport->last_stun_msg(); 1423 EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); 1424 const StunUInt64Attribute* ice_controlled_attr = 1425 msg->GetUInt64(STUN_ATTR_ICE_CONTROLLED); 1426 ASSERT_TRUE(ice_controlled_attr != NULL); 1427 EXPECT_EQ(rport->IceTiebreaker(), ice_controlled_attr->value()); 1428 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL); 1429 1430 // Request should include ping count. 1431 const StunUInt32Attribute* retransmit_attr = 1432 msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT); 1433 ASSERT_TRUE(retransmit_attr != NULL); 1434 EXPECT_EQ(2U, retransmit_attr->value()); 1435 1436 // Respond with a BINDING-RESPONSE. 1437 request.reset(CopyStunMessage(msg)); 1438 lport->SendBindingResponse(request.get(), rport->Candidates()[0].address()); 1439 msg = lport->last_stun_msg(); 1440 1441 // Response should include same ping count. 1442 retransmit_attr = msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT); 1443 ASSERT_TRUE(retransmit_attr != NULL); 1444 EXPECT_EQ(2U, retransmit_attr->value()); 1445 } 1446 1447 TEST_F(PortTest, TestUseCandidateAttribute) { 1448 talk_base::scoped_ptr<TestPort> lport( 1449 CreateTestPort(kLocalAddr1, "lfrag", "lpass")); 1450 talk_base::scoped_ptr<TestPort> rport( 1451 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1452 lport->SetIceProtocolType(ICEPROTO_RFC5245); 1453 lport->SetIceRole(cricket::ICEROLE_CONTROLLING); 1454 lport->SetIceTiebreaker(kTiebreaker1); 1455 rport->SetIceProtocolType(ICEPROTO_RFC5245); 1456 rport->SetIceRole(cricket::ICEROLE_CONTROLLED); 1457 rport->SetIceTiebreaker(kTiebreaker2); 1458 1459 // Send a fake ping from lport to rport. 1460 lport->PrepareAddress(); 1461 rport->PrepareAddress(); 1462 ASSERT_FALSE(rport->Candidates().empty()); 1463 Connection* lconn = lport->CreateConnection( 1464 rport->Candidates()[0], Port::ORIGIN_MESSAGE); 1465 lconn->Ping(0); 1466 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1467 IceMessage* msg = lport->last_stun_msg(); 1468 const StunUInt64Attribute* ice_controlling_attr = 1469 msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING); 1470 ASSERT_TRUE(ice_controlling_attr != NULL); 1471 const StunByteStringAttribute* use_candidate_attr = msg->GetByteString( 1472 STUN_ATTR_USE_CANDIDATE); 1473 ASSERT_TRUE(use_candidate_attr != NULL); 1474 } 1475 1476 // Test handling STUN messages in GICE format. 1477 TEST_F(PortTest, TestHandleStunMessageAsGice) { 1478 // Our port will act as the "remote" port. 1479 talk_base::scoped_ptr<TestPort> port( 1480 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1481 port->SetIceProtocolType(ICEPROTO_GOOGLE); 1482 1483 talk_base::scoped_ptr<IceMessage> in_msg, out_msg; 1484 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1485 talk_base::SocketAddress addr(kLocalAddr1); 1486 std::string username; 1487 1488 // BINDING-REQUEST from local to remote with valid GICE username and no M-I. 1489 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1490 "rfraglfrag")); 1491 WriteStunMessage(in_msg.get(), buf.get()); 1492 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1493 out_msg.accept(), &username)); 1494 EXPECT_TRUE(out_msg.get() != NULL); // Succeeds, since this is GICE. 1495 EXPECT_EQ("lfrag", username); 1496 1497 // Add M-I; should be ignored and rest of message parsed normally. 1498 in_msg->AddMessageIntegrity("password"); 1499 WriteStunMessage(in_msg.get(), buf.get()); 1500 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1501 out_msg.accept(), &username)); 1502 EXPECT_TRUE(out_msg.get() != NULL); 1503 EXPECT_EQ("lfrag", username); 1504 1505 // BINDING-RESPONSE with username, as done in GICE. Should succeed. 1506 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_RESPONSE, 1507 "rfraglfrag")); 1508 in_msg->AddAttribute( 1509 new StunAddressAttribute(STUN_ATTR_MAPPED_ADDRESS, kLocalAddr2)); 1510 WriteStunMessage(in_msg.get(), buf.get()); 1511 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1512 out_msg.accept(), &username)); 1513 EXPECT_TRUE(out_msg.get() != NULL); 1514 EXPECT_EQ("", username); 1515 1516 // BINDING-RESPONSE without username. Should be tolerated as well. 1517 in_msg.reset(CreateStunMessage(STUN_BINDING_RESPONSE)); 1518 in_msg->AddAttribute( 1519 new StunAddressAttribute(STUN_ATTR_MAPPED_ADDRESS, kLocalAddr2)); 1520 WriteStunMessage(in_msg.get(), buf.get()); 1521 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1522 out_msg.accept(), &username)); 1523 EXPECT_TRUE(out_msg.get() != NULL); 1524 EXPECT_EQ("", username); 1525 1526 // BINDING-ERROR-RESPONSE with username and error code. 1527 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_ERROR_RESPONSE, 1528 "rfraglfrag")); 1529 in_msg->AddAttribute(new StunErrorCodeAttribute(STUN_ATTR_ERROR_CODE, 1530 STUN_ERROR_SERVER_ERROR_AS_GICE, STUN_ERROR_REASON_SERVER_ERROR)); 1531 WriteStunMessage(in_msg.get(), buf.get()); 1532 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1533 out_msg.accept(), &username)); 1534 ASSERT_TRUE(out_msg.get() != NULL); 1535 EXPECT_EQ("", username); 1536 ASSERT_TRUE(out_msg->GetErrorCode() != NULL); 1537 // GetStunMessage doesn't unmunge the GICE error code (happens downstream). 1538 EXPECT_EQ(STUN_ERROR_SERVER_ERROR_AS_GICE, out_msg->GetErrorCode()->code()); 1539 EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR), 1540 out_msg->GetErrorCode()->reason()); 1541 } 1542 1543 // Test handling STUN messages in ICE format. 1544 TEST_F(PortTest, TestHandleStunMessageAsIce) { 1545 // Our port will act as the "remote" port. 1546 talk_base::scoped_ptr<TestPort> port( 1547 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1548 port->SetIceProtocolType(ICEPROTO_RFC5245); 1549 1550 talk_base::scoped_ptr<IceMessage> in_msg, out_msg; 1551 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1552 talk_base::SocketAddress addr(kLocalAddr1); 1553 std::string username; 1554 1555 // BINDING-REQUEST from local to remote with valid ICE username, 1556 // MESSAGE-INTEGRITY, and FINGERPRINT. 1557 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1558 "rfrag:lfrag")); 1559 in_msg->AddMessageIntegrity("rpass"); 1560 in_msg->AddFingerprint(); 1561 WriteStunMessage(in_msg.get(), buf.get()); 1562 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1563 out_msg.accept(), &username)); 1564 EXPECT_TRUE(out_msg.get() != NULL); 1565 EXPECT_EQ("lfrag", username); 1566 1567 // BINDING-RESPONSE without username, with MESSAGE-INTEGRITY and FINGERPRINT. 1568 in_msg.reset(CreateStunMessage(STUN_BINDING_RESPONSE)); 1569 in_msg->AddAttribute( 1570 new StunXorAddressAttribute(STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2)); 1571 in_msg->AddMessageIntegrity("rpass"); 1572 in_msg->AddFingerprint(); 1573 WriteStunMessage(in_msg.get(), buf.get()); 1574 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1575 out_msg.accept(), &username)); 1576 EXPECT_TRUE(out_msg.get() != NULL); 1577 EXPECT_EQ("", username); 1578 1579 // BINDING-ERROR-RESPONSE without username, with error, M-I, and FINGERPRINT. 1580 in_msg.reset(CreateStunMessage(STUN_BINDING_ERROR_RESPONSE)); 1581 in_msg->AddAttribute(new StunErrorCodeAttribute(STUN_ATTR_ERROR_CODE, 1582 STUN_ERROR_SERVER_ERROR, STUN_ERROR_REASON_SERVER_ERROR)); 1583 in_msg->AddFingerprint(); 1584 WriteStunMessage(in_msg.get(), buf.get()); 1585 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1586 out_msg.accept(), &username)); 1587 EXPECT_TRUE(out_msg.get() != NULL); 1588 EXPECT_EQ("", username); 1589 ASSERT_TRUE(out_msg->GetErrorCode() != NULL); 1590 EXPECT_EQ(STUN_ERROR_SERVER_ERROR, out_msg->GetErrorCode()->code()); 1591 EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR), 1592 out_msg->GetErrorCode()->reason()); 1593 } 1594 1595 // Tests handling of GICE binding requests with missing or incorrect usernames. 1596 TEST_F(PortTest, TestHandleStunMessageAsGiceBadUsername) { 1597 talk_base::scoped_ptr<TestPort> port( 1598 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1599 port->SetIceProtocolType(ICEPROTO_GOOGLE); 1600 1601 talk_base::scoped_ptr<IceMessage> in_msg, out_msg; 1602 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1603 talk_base::SocketAddress addr(kLocalAddr1); 1604 std::string username; 1605 1606 // BINDING-REQUEST with no username. 1607 in_msg.reset(CreateStunMessage(STUN_BINDING_REQUEST)); 1608 WriteStunMessage(in_msg.get(), buf.get()); 1609 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1610 out_msg.accept(), &username)); 1611 EXPECT_TRUE(out_msg.get() == NULL); 1612 EXPECT_EQ("", username); 1613 EXPECT_EQ(STUN_ERROR_BAD_REQUEST_AS_GICE, port->last_stun_error_code()); 1614 1615 // BINDING-REQUEST with empty username. 1616 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "")); 1617 WriteStunMessage(in_msg.get(), buf.get()); 1618 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1619 out_msg.accept(), &username)); 1620 EXPECT_TRUE(out_msg.get() == NULL); 1621 EXPECT_EQ("", username); 1622 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED_AS_GICE, port->last_stun_error_code()); 1623 1624 // BINDING-REQUEST with too-short username. 1625 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "lfra")); 1626 WriteStunMessage(in_msg.get(), buf.get()); 1627 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1628 out_msg.accept(), &username)); 1629 EXPECT_TRUE(out_msg.get() == NULL); 1630 EXPECT_EQ("", username); 1631 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED_AS_GICE, port->last_stun_error_code()); 1632 1633 // BINDING-REQUEST with reversed username. 1634 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1635 "lfragrfrag")); 1636 WriteStunMessage(in_msg.get(), buf.get()); 1637 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1638 out_msg.accept(), &username)); 1639 EXPECT_TRUE(out_msg.get() == NULL); 1640 EXPECT_EQ("", username); 1641 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED_AS_GICE, port->last_stun_error_code()); 1642 1643 // BINDING-REQUEST with garbage username. 1644 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1645 "abcdefgh")); 1646 WriteStunMessage(in_msg.get(), buf.get()); 1647 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1648 out_msg.accept(), &username)); 1649 EXPECT_TRUE(out_msg.get() == NULL); 1650 EXPECT_EQ("", username); 1651 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED_AS_GICE, port->last_stun_error_code()); 1652 } 1653 1654 // Tests handling of ICE binding requests with missing or incorrect usernames. 1655 TEST_F(PortTest, TestHandleStunMessageAsIceBadUsername) { 1656 talk_base::scoped_ptr<TestPort> port( 1657 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1658 port->SetIceProtocolType(ICEPROTO_RFC5245); 1659 1660 talk_base::scoped_ptr<IceMessage> in_msg, out_msg; 1661 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1662 talk_base::SocketAddress addr(kLocalAddr1); 1663 std::string username; 1664 1665 // BINDING-REQUEST with no username. 1666 in_msg.reset(CreateStunMessage(STUN_BINDING_REQUEST)); 1667 in_msg->AddMessageIntegrity("rpass"); 1668 in_msg->AddFingerprint(); 1669 WriteStunMessage(in_msg.get(), buf.get()); 1670 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1671 out_msg.accept(), &username)); 1672 EXPECT_TRUE(out_msg.get() == NULL); 1673 EXPECT_EQ("", username); 1674 EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code()); 1675 1676 // BINDING-REQUEST with empty username. 1677 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "")); 1678 in_msg->AddMessageIntegrity("rpass"); 1679 in_msg->AddFingerprint(); 1680 WriteStunMessage(in_msg.get(), buf.get()); 1681 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1682 out_msg.accept(), &username)); 1683 EXPECT_TRUE(out_msg.get() == NULL); 1684 EXPECT_EQ("", username); 1685 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); 1686 1687 // BINDING-REQUEST with too-short username. 1688 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfra")); 1689 in_msg->AddMessageIntegrity("rpass"); 1690 in_msg->AddFingerprint(); 1691 WriteStunMessage(in_msg.get(), buf.get()); 1692 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1693 out_msg.accept(), &username)); 1694 EXPECT_TRUE(out_msg.get() == NULL); 1695 EXPECT_EQ("", username); 1696 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); 1697 1698 // BINDING-REQUEST with reversed username. 1699 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1700 "lfrag:rfrag")); 1701 in_msg->AddMessageIntegrity("rpass"); 1702 in_msg->AddFingerprint(); 1703 WriteStunMessage(in_msg.get(), buf.get()); 1704 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1705 out_msg.accept(), &username)); 1706 EXPECT_TRUE(out_msg.get() == NULL); 1707 EXPECT_EQ("", username); 1708 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); 1709 1710 // BINDING-REQUEST with garbage username. 1711 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1712 "abcd:efgh")); 1713 in_msg->AddMessageIntegrity("rpass"); 1714 in_msg->AddFingerprint(); 1715 WriteStunMessage(in_msg.get(), buf.get()); 1716 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1717 out_msg.accept(), &username)); 1718 EXPECT_TRUE(out_msg.get() == NULL); 1719 EXPECT_EQ("", username); 1720 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); 1721 } 1722 1723 // Test handling STUN messages (as ICE) with missing or malformed M-I. 1724 TEST_F(PortTest, TestHandleStunMessageAsIceBadMessageIntegrity) { 1725 // Our port will act as the "remote" port. 1726 talk_base::scoped_ptr<TestPort> port( 1727 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1728 port->SetIceProtocolType(ICEPROTO_RFC5245); 1729 1730 talk_base::scoped_ptr<IceMessage> in_msg, out_msg; 1731 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1732 talk_base::SocketAddress addr(kLocalAddr1); 1733 std::string username; 1734 1735 // BINDING-REQUEST from local to remote with valid ICE username and 1736 // FINGERPRINT, but no MESSAGE-INTEGRITY. 1737 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1738 "rfrag:lfrag")); 1739 in_msg->AddFingerprint(); 1740 WriteStunMessage(in_msg.get(), buf.get()); 1741 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1742 out_msg.accept(), &username)); 1743 EXPECT_TRUE(out_msg.get() == NULL); 1744 EXPECT_EQ("", username); 1745 EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code()); 1746 1747 // BINDING-REQUEST from local to remote with valid ICE username and 1748 // FINGERPRINT, but invalid MESSAGE-INTEGRITY. 1749 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1750 "rfrag:lfrag")); 1751 in_msg->AddMessageIntegrity("invalid"); 1752 in_msg->AddFingerprint(); 1753 WriteStunMessage(in_msg.get(), buf.get()); 1754 EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1755 out_msg.accept(), &username)); 1756 EXPECT_TRUE(out_msg.get() == NULL); 1757 EXPECT_EQ("", username); 1758 EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); 1759 1760 // TODO: BINDING-RESPONSES and BINDING-ERROR-RESPONSES are checked 1761 // by the Connection, not the Port, since they require the remote username. 1762 // Change this test to pass in data via Connection::OnReadPacket instead. 1763 } 1764 1765 // Test handling STUN messages (as ICE) with missing or malformed FINGERPRINT. 1766 TEST_F(PortTest, TestHandleStunMessageAsIceBadFingerprint) { 1767 // Our port will act as the "remote" port. 1768 talk_base::scoped_ptr<TestPort> port( 1769 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1770 port->SetIceProtocolType(ICEPROTO_RFC5245); 1771 1772 talk_base::scoped_ptr<IceMessage> in_msg, out_msg; 1773 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1774 talk_base::SocketAddress addr(kLocalAddr1); 1775 std::string username; 1776 1777 // BINDING-REQUEST from local to remote with valid ICE username and 1778 // MESSAGE-INTEGRITY, but no FINGERPRINT; GetStunMessage should fail. 1779 in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, 1780 "rfrag:lfrag")); 1781 in_msg->AddMessageIntegrity("rpass"); 1782 WriteStunMessage(in_msg.get(), buf.get()); 1783 EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1784 out_msg.accept(), &username)); 1785 EXPECT_EQ(0, port->last_stun_error_code()); 1786 1787 // Now, add a fingerprint, but munge the message so it's not valid. 1788 in_msg->AddFingerprint(); 1789 in_msg->SetTransactionID("TESTTESTBADD"); 1790 WriteStunMessage(in_msg.get(), buf.get()); 1791 EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1792 out_msg.accept(), &username)); 1793 EXPECT_EQ(0, port->last_stun_error_code()); 1794 1795 // Valid BINDING-RESPONSE, except no FINGERPRINT. 1796 in_msg.reset(CreateStunMessage(STUN_BINDING_RESPONSE)); 1797 in_msg->AddAttribute( 1798 new StunXorAddressAttribute(STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2)); 1799 in_msg->AddMessageIntegrity("rpass"); 1800 WriteStunMessage(in_msg.get(), buf.get()); 1801 EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1802 out_msg.accept(), &username)); 1803 EXPECT_EQ(0, port->last_stun_error_code()); 1804 1805 // Now, add a fingerprint, but munge the message so it's not valid. 1806 in_msg->AddFingerprint(); 1807 in_msg->SetTransactionID("TESTTESTBADD"); 1808 WriteStunMessage(in_msg.get(), buf.get()); 1809 EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1810 out_msg.accept(), &username)); 1811 EXPECT_EQ(0, port->last_stun_error_code()); 1812 1813 // Valid BINDING-ERROR-RESPONSE, except no FINGERPRINT. 1814 in_msg.reset(CreateStunMessage(STUN_BINDING_ERROR_RESPONSE)); 1815 in_msg->AddAttribute(new StunErrorCodeAttribute(STUN_ATTR_ERROR_CODE, 1816 STUN_ERROR_SERVER_ERROR, STUN_ERROR_REASON_SERVER_ERROR)); 1817 in_msg->AddMessageIntegrity("rpass"); 1818 WriteStunMessage(in_msg.get(), buf.get()); 1819 EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1820 out_msg.accept(), &username)); 1821 EXPECT_EQ(0, port->last_stun_error_code()); 1822 1823 // Now, add a fingerprint, but munge the message so it's not valid. 1824 in_msg->AddFingerprint(); 1825 in_msg->SetTransactionID("TESTTESTBADD"); 1826 WriteStunMessage(in_msg.get(), buf.get()); 1827 EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, 1828 out_msg.accept(), &username)); 1829 EXPECT_EQ(0, port->last_stun_error_code()); 1830 } 1831 1832 // Test handling of STUN binding indication messages (as ICE). STUN binding 1833 // indications are allowed only to the connection which is in read mode. 1834 TEST_F(PortTest, TestHandleStunBindingIndication) { 1835 talk_base::scoped_ptr<TestPort> lport( 1836 CreateTestPort(kLocalAddr2, "lfrag", "lpass")); 1837 lport->SetIceProtocolType(ICEPROTO_RFC5245); 1838 lport->SetIceRole(cricket::ICEROLE_CONTROLLING); 1839 lport->SetIceTiebreaker(kTiebreaker1); 1840 1841 // Verifying encoding and decoding STUN indication message. 1842 talk_base::scoped_ptr<IceMessage> in_msg, out_msg; 1843 talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer()); 1844 talk_base::SocketAddress addr(kLocalAddr1); 1845 std::string username; 1846 1847 in_msg.reset(CreateStunMessage(STUN_BINDING_INDICATION)); 1848 in_msg->AddFingerprint(); 1849 WriteStunMessage(in_msg.get(), buf.get()); 1850 EXPECT_TRUE(lport->GetStunMessage(buf->Data(), buf->Length(), addr, 1851 out_msg.accept(), &username)); 1852 EXPECT_TRUE(out_msg.get() != NULL); 1853 EXPECT_EQ(out_msg->type(), STUN_BINDING_INDICATION); 1854 EXPECT_EQ("", username); 1855 1856 // Verify connection can handle STUN indication and updates 1857 // last_ping_received. 1858 talk_base::scoped_ptr<TestPort> rport( 1859 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 1860 rport->SetIceProtocolType(ICEPROTO_RFC5245); 1861 rport->SetIceRole(cricket::ICEROLE_CONTROLLED); 1862 rport->SetIceTiebreaker(kTiebreaker2); 1863 1864 lport->PrepareAddress(); 1865 rport->PrepareAddress(); 1866 ASSERT_FALSE(lport->Candidates().empty()); 1867 ASSERT_FALSE(rport->Candidates().empty()); 1868 1869 Connection* lconn = lport->CreateConnection(rport->Candidates()[0], 1870 Port::ORIGIN_MESSAGE); 1871 Connection* rconn = rport->CreateConnection(lport->Candidates()[0], 1872 Port::ORIGIN_MESSAGE); 1873 rconn->Ping(0); 1874 1875 ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000); 1876 IceMessage* msg = rport->last_stun_msg(); 1877 EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); 1878 // Send rport binding request to lport. 1879 lconn->OnReadPacket(rport->last_stun_buf()->Data(), 1880 rport->last_stun_buf()->Length()); 1881 ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000); 1882 EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type()); 1883 uint32 last_ping_received1 = lconn->last_ping_received(); 1884 1885 // Adding a delay of 100ms. 1886 talk_base::Thread::Current()->ProcessMessages(100); 1887 // Pinging lconn using stun indication message. 1888 lconn->OnReadPacket(buf->Data(), buf->Length()); 1889 uint32 last_ping_received2 = lconn->last_ping_received(); 1890 EXPECT_GT(last_ping_received2, last_ping_received1); 1891 } 1892 1893 TEST_F(PortTest, TestComputeCandidatePriority) { 1894 talk_base::scoped_ptr<TestPort> port( 1895 CreateTestPort(kLocalAddr1, "name", "pass")); 1896 port->set_type_preference(90); 1897 port->set_component(177); 1898 port->AddCandidateAddress(SocketAddress("192.168.1.4", 1234)); 1899 port->AddCandidateAddress(SocketAddress("2001:db8::1234", 1234)); 1900 port->AddCandidateAddress(SocketAddress("fc12:3456::1234", 1234)); 1901 port->AddCandidateAddress(SocketAddress("::ffff:192.168.1.4", 1234)); 1902 port->AddCandidateAddress(SocketAddress("::192.168.1.4", 1234)); 1903 port->AddCandidateAddress(SocketAddress("2002::1234:5678", 1234)); 1904 port->AddCandidateAddress(SocketAddress("2001::1234:5678", 1234)); 1905 port->AddCandidateAddress(SocketAddress("fecf::1234:5678", 1234)); 1906 port->AddCandidateAddress(SocketAddress("3ffe::1234:5678", 1234)); 1907 // These should all be: 1908 // (90 << 24) | ([rfc3484 pref value] << 8) | (256 - 177) 1909 uint32 expected_priority_v4 = 1509957199U; 1910 uint32 expected_priority_v6 = 1509959759U; 1911 uint32 expected_priority_ula = 1509962319U; 1912 uint32 expected_priority_v4mapped = expected_priority_v4; 1913 uint32 expected_priority_v4compat = 1509949775U; 1914 uint32 expected_priority_6to4 = 1509954639U; 1915 uint32 expected_priority_teredo = 1509952079U; 1916 uint32 expected_priority_sitelocal = 1509949775U; 1917 uint32 expected_priority_6bone = 1509949775U; 1918 ASSERT_EQ(expected_priority_v4, port->Candidates()[0].priority()); 1919 ASSERT_EQ(expected_priority_v6, port->Candidates()[1].priority()); 1920 ASSERT_EQ(expected_priority_ula, port->Candidates()[2].priority()); 1921 ASSERT_EQ(expected_priority_v4mapped, port->Candidates()[3].priority()); 1922 ASSERT_EQ(expected_priority_v4compat, port->Candidates()[4].priority()); 1923 ASSERT_EQ(expected_priority_6to4, port->Candidates()[5].priority()); 1924 ASSERT_EQ(expected_priority_teredo, port->Candidates()[6].priority()); 1925 ASSERT_EQ(expected_priority_sitelocal, port->Candidates()[7].priority()); 1926 ASSERT_EQ(expected_priority_6bone, port->Candidates()[8].priority()); 1927 } 1928 1929 TEST_F(PortTest, TestPortProxyProperties) { 1930 talk_base::scoped_ptr<TestPort> port( 1931 CreateTestPort(kLocalAddr1, "name", "pass")); 1932 port->SetIceRole(cricket::ICEROLE_CONTROLLING); 1933 port->SetIceTiebreaker(kTiebreaker1); 1934 1935 // Create a proxy port. 1936 talk_base::scoped_ptr<PortProxy> proxy(new PortProxy()); 1937 proxy->set_impl(port.get()); 1938 EXPECT_EQ(port->Type(), proxy->Type()); 1939 EXPECT_EQ(port->Network(), proxy->Network()); 1940 EXPECT_EQ(port->GetIceRole(), proxy->GetIceRole()); 1941 EXPECT_EQ(port->IceTiebreaker(), proxy->IceTiebreaker()); 1942 } 1943 1944 // In the case of shared socket, one port may be shared by local and stun. 1945 // Test that candidates with different types will have different foundation. 1946 TEST_F(PortTest, TestFoundation) { 1947 talk_base::scoped_ptr<TestPort> testport( 1948 CreateTestPort(kLocalAddr1, "name", "pass")); 1949 testport->AddCandidateAddress(kLocalAddr1, kLocalAddr1, 1950 LOCAL_PORT_TYPE, 1951 cricket::ICE_TYPE_PREFERENCE_HOST, false); 1952 testport->AddCandidateAddress(kLocalAddr2, kLocalAddr1, 1953 STUN_PORT_TYPE, 1954 cricket::ICE_TYPE_PREFERENCE_SRFLX, true); 1955 EXPECT_NE(testport->Candidates()[0].foundation(), 1956 testport->Candidates()[1].foundation()); 1957 } 1958 1959 // This test verifies the foundation of different types of ICE candidates. 1960 TEST_F(PortTest, TestCandidateFoundation) { 1961 talk_base::scoped_ptr<talk_base::NATServer> nat_server( 1962 CreateNatServer(kNatAddr1, NAT_OPEN_CONE)); 1963 talk_base::scoped_ptr<UDPPort> udpport1(CreateUdpPort(kLocalAddr1)); 1964 udpport1->PrepareAddress(); 1965 talk_base::scoped_ptr<UDPPort> udpport2(CreateUdpPort(kLocalAddr1)); 1966 udpport2->PrepareAddress(); 1967 EXPECT_EQ(udpport1->Candidates()[0].foundation(), 1968 udpport2->Candidates()[0].foundation()); 1969 talk_base::scoped_ptr<TCPPort> tcpport1(CreateTcpPort(kLocalAddr1)); 1970 tcpport1->PrepareAddress(); 1971 talk_base::scoped_ptr<TCPPort> tcpport2(CreateTcpPort(kLocalAddr1)); 1972 tcpport2->PrepareAddress(); 1973 EXPECT_EQ(tcpport1->Candidates()[0].foundation(), 1974 tcpport2->Candidates()[0].foundation()); 1975 talk_base::scoped_ptr<Port> stunport( 1976 CreateStunPort(kLocalAddr1, nat_socket_factory1())); 1977 stunport->PrepareAddress(); 1978 ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kTimeout); 1979 EXPECT_NE(tcpport1->Candidates()[0].foundation(), 1980 stunport->Candidates()[0].foundation()); 1981 EXPECT_NE(tcpport2->Candidates()[0].foundation(), 1982 stunport->Candidates()[0].foundation()); 1983 EXPECT_NE(udpport1->Candidates()[0].foundation(), 1984 stunport->Candidates()[0].foundation()); 1985 EXPECT_NE(udpport2->Candidates()[0].foundation(), 1986 stunport->Candidates()[0].foundation()); 1987 // Verify GTURN candidate foundation. 1988 talk_base::scoped_ptr<RelayPort> relayport( 1989 CreateGturnPort(kLocalAddr1)); 1990 relayport->AddServerAddress( 1991 cricket::ProtocolAddress(kRelayUdpIntAddr, cricket::PROTO_UDP)); 1992 relayport->PrepareAddress(); 1993 ASSERT_EQ_WAIT(1U, relayport->Candidates().size(), kTimeout); 1994 EXPECT_NE(udpport1->Candidates()[0].foundation(), 1995 relayport->Candidates()[0].foundation()); 1996 EXPECT_NE(udpport2->Candidates()[0].foundation(), 1997 relayport->Candidates()[0].foundation()); 1998 // Verifying TURN candidate foundation. 1999 talk_base::scoped_ptr<Port> turnport(CreateTurnPort( 2000 kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP)); 2001 turnport->PrepareAddress(); 2002 ASSERT_EQ_WAIT(1U, turnport->Candidates().size(), kTimeout); 2003 EXPECT_NE(udpport1->Candidates()[0].foundation(), 2004 turnport->Candidates()[0].foundation()); 2005 EXPECT_NE(udpport2->Candidates()[0].foundation(), 2006 turnport->Candidates()[0].foundation()); 2007 EXPECT_NE(stunport->Candidates()[0].foundation(), 2008 turnport->Candidates()[0].foundation()); 2009 } 2010 2011 // This test verifies the related addresses of different types of 2012 // ICE candiates. 2013 TEST_F(PortTest, TestCandidateRelatedAddress) { 2014 talk_base::scoped_ptr<talk_base::NATServer> nat_server( 2015 CreateNatServer(kNatAddr1, NAT_OPEN_CONE)); 2016 talk_base::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1)); 2017 udpport->PrepareAddress(); 2018 // For UDPPort, related address will be empty. 2019 EXPECT_TRUE(udpport->Candidates()[0].related_address().IsNil()); 2020 // Testing related address for stun candidates. 2021 // For stun candidate related address must be equal to the base 2022 // socket address. 2023 talk_base::scoped_ptr<StunPort> stunport( 2024 CreateStunPort(kLocalAddr1, nat_socket_factory1())); 2025 stunport->PrepareAddress(); 2026 ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kTimeout); 2027 // Check STUN candidate address. 2028 EXPECT_EQ(stunport->Candidates()[0].address().ipaddr(), 2029 kNatAddr1.ipaddr()); 2030 // Check STUN candidate related address. 2031 EXPECT_EQ(stunport->Candidates()[0].related_address(), 2032 stunport->GetLocalAddress()); 2033 // Verifying the related address for the GTURN candidates. 2034 // NOTE: In case of GTURN related address will be equal to the mapped 2035 // address, but address(mapped) will not be XOR. 2036 talk_base::scoped_ptr<RelayPort> relayport( 2037 CreateGturnPort(kLocalAddr1)); 2038 relayport->AddServerAddress( 2039 cricket::ProtocolAddress(kRelayUdpIntAddr, cricket::PROTO_UDP)); 2040 relayport->PrepareAddress(); 2041 ASSERT_EQ_WAIT(1U, relayport->Candidates().size(), kTimeout); 2042 // For Gturn related address is set to "0.0.0.0:0" 2043 EXPECT_EQ(talk_base::SocketAddress(), 2044 relayport->Candidates()[0].related_address()); 2045 // Verifying the related address for TURN candidate. 2046 // For TURN related address must be equal to the mapped address. 2047 talk_base::scoped_ptr<Port> turnport(CreateTurnPort( 2048 kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP)); 2049 turnport->PrepareAddress(); 2050 ASSERT_EQ_WAIT(1U, turnport->Candidates().size(), kTimeout); 2051 EXPECT_EQ(kTurnUdpExtAddr.ipaddr(), 2052 turnport->Candidates()[0].address().ipaddr()); 2053 EXPECT_EQ(kNatAddr1.ipaddr(), 2054 turnport->Candidates()[0].related_address().ipaddr()); 2055 } 2056 2057 // Test priority value overflow handling when preference is set to 3. 2058 TEST_F(PortTest, TestCandidatePreference) { 2059 cricket::Candidate cand1; 2060 cand1.set_preference(3); 2061 cricket::Candidate cand2; 2062 cand2.set_preference(1); 2063 EXPECT_TRUE(cand1.preference() > cand2.preference()); 2064 } 2065 2066 // Test the Connection priority is calculated correctly. 2067 TEST_F(PortTest, TestConnectionPriority) { 2068 talk_base::scoped_ptr<TestPort> lport( 2069 CreateTestPort(kLocalAddr1, "lfrag", "lpass")); 2070 lport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_HOST); 2071 talk_base::scoped_ptr<TestPort> rport( 2072 CreateTestPort(kLocalAddr2, "rfrag", "rpass")); 2073 rport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_RELAY); 2074 lport->set_component(123); 2075 lport->AddCandidateAddress(SocketAddress("192.168.1.4", 1234)); 2076 rport->set_component(23); 2077 rport->AddCandidateAddress(SocketAddress("10.1.1.100", 1234)); 2078 2079 EXPECT_EQ(0x7E001E85U, lport->Candidates()[0].priority()); 2080 EXPECT_EQ(0x2001EE9U, rport->Candidates()[0].priority()); 2081 2082 // RFC 5245 2083 // pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0) 2084 lport->SetIceRole(cricket::ICEROLE_CONTROLLING); 2085 rport->SetIceRole(cricket::ICEROLE_CONTROLLED); 2086 Connection* lconn = lport->CreateConnection( 2087 rport->Candidates()[0], Port::ORIGIN_MESSAGE); 2088 #if defined(WIN32) 2089 EXPECT_EQ(0x2001EE9FC003D0BU, lconn->priority()); 2090 #else 2091 EXPECT_EQ(0x2001EE9FC003D0BLLU, lconn->priority()); 2092 #endif 2093 2094 lport->SetIceRole(cricket::ICEROLE_CONTROLLED); 2095 rport->SetIceRole(cricket::ICEROLE_CONTROLLING); 2096 Connection* rconn = rport->CreateConnection( 2097 lport->Candidates()[0], Port::ORIGIN_MESSAGE); 2098 #if defined(WIN32) 2099 EXPECT_EQ(0x2001EE9FC003D0AU, rconn->priority()); 2100 #else 2101 EXPECT_EQ(0x2001EE9FC003D0ALLU, rconn->priority()); 2102 #endif 2103 } 2104 2105 TEST_F(PortTest, TestWritableState) { 2106 UDPPort* port1 = CreateUdpPort(kLocalAddr1); 2107 UDPPort* port2 = CreateUdpPort(kLocalAddr2); 2108 2109 // Set up channels. 2110 TestChannel ch1(port1, port2); 2111 TestChannel ch2(port2, port1); 2112 2113 // Acquire addresses. 2114 ch1.Start(); 2115 ch2.Start(); 2116 ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout); 2117 ASSERT_EQ_WAIT(1, ch2.complete_count(), kTimeout); 2118 2119 // Send a ping from src to dst. 2120 ch1.CreateConnection(); 2121 ASSERT_TRUE(ch1.conn() != NULL); 2122 EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state()); 2123 EXPECT_TRUE_WAIT(ch1.conn()->connected(), kTimeout); // for TCP connect 2124 ch1.Ping(); 2125 WAIT(!ch2.remote_address().IsNil(), kTimeout); 2126 2127 // Data should be unsendable until the connection is accepted. 2128 char data[] = "abcd"; 2129 int data_size = ARRAY_SIZE(data); 2130 EXPECT_EQ(SOCKET_ERROR, ch1.conn()->Send(data, data_size)); 2131 2132 // Accept the connection to return the binding response, transition to 2133 // writable, and allow data to be sent. 2134 ch2.AcceptConnection(); 2135 EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(), 2136 kTimeout); 2137 EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size)); 2138 2139 // Ask the connection to update state as if enough time has passed to lose 2140 // full writability and 5 pings went unresponded to. We'll accomplish the 2141 // latter by sending pings but not pumping messages. 2142 for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) { 2143 ch1.Ping(i); 2144 } 2145 uint32 unreliable_timeout_delay = CONNECTION_WRITE_CONNECT_TIMEOUT + 500u; 2146 ch1.conn()->UpdateState(unreliable_timeout_delay); 2147 EXPECT_EQ(Connection::STATE_WRITE_UNRELIABLE, ch1.conn()->write_state()); 2148 2149 // Data should be able to be sent in this state. 2150 EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size)); 2151 2152 // And now allow the other side to process the pings and send binding 2153 // responses. 2154 EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(), 2155 kTimeout); 2156 2157 // Wait long enough for a full timeout (past however long we've already 2158 // waited). 2159 for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) { 2160 ch1.Ping(unreliable_timeout_delay + i); 2161 } 2162 ch1.conn()->UpdateState(unreliable_timeout_delay + CONNECTION_WRITE_TIMEOUT + 2163 500u); 2164 EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state()); 2165 2166 // Now that the connection has completely timed out, data send should fail. 2167 EXPECT_EQ(SOCKET_ERROR, ch1.conn()->Send(data, data_size)); 2168 2169 ch1.Stop(); 2170 ch2.Stop(); 2171 } 2172 2173 TEST_F(PortTest, TestTimeoutForNeverWritable) { 2174 UDPPort* port1 = CreateUdpPort(kLocalAddr1); 2175 UDPPort* port2 = CreateUdpPort(kLocalAddr2); 2176 2177 // Set up channels. 2178 TestChannel ch1(port1, port2); 2179 TestChannel ch2(port2, port1); 2180 2181 // Acquire addresses. 2182 ch1.Start(); 2183 ch2.Start(); 2184 2185 ch1.CreateConnection(); 2186 ASSERT_TRUE(ch1.conn() != NULL); 2187 EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state()); 2188 2189 // Attempt to go directly to write timeout. 2190 for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) { 2191 ch1.Ping(i); 2192 } 2193 ch1.conn()->UpdateState(CONNECTION_WRITE_TIMEOUT + 500u); 2194 EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state()); 2195 } 2196 2197 // This test verifies the connection setup between ICEMODE_FULL 2198 // and ICEMODE_LITE. 2199 // In this test |ch1| behaves like FULL mode client and we have created 2200 // port which responds to the ping message just like LITE client. 2201 TEST_F(PortTest, TestIceLiteConnectivity) { 2202 TestPort* ice_full_port = CreateTestPort( 2203 kLocalAddr1, "lfrag", "lpass", cricket::ICEPROTO_RFC5245, 2204 cricket::ICEROLE_CONTROLLING, kTiebreaker1); 2205 2206 talk_base::scoped_ptr<TestPort> ice_lite_port(CreateTestPort( 2207 kLocalAddr2, "rfrag", "rpass", cricket::ICEPROTO_RFC5245, 2208 cricket::ICEROLE_CONTROLLED, kTiebreaker2)); 2209 // Setup TestChannel. This behaves like FULL mode client. 2210 TestChannel ch1(ice_full_port, ice_lite_port.get()); 2211 ch1.SetIceMode(ICEMODE_FULL); 2212 2213 // Start gathering candidates. 2214 ch1.Start(); 2215 ice_lite_port->PrepareAddress(); 2216 2217 ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout); 2218 ASSERT_FALSE(ice_lite_port->Candidates().empty()); 2219 2220 ch1.CreateConnection(); 2221 ASSERT_TRUE(ch1.conn() != NULL); 2222 EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state()); 2223 2224 // Send ping from full mode client. 2225 // This ping must not have USE_CANDIDATE_ATTR. 2226 ch1.Ping(); 2227 2228 // Verify stun ping is without USE_CANDIDATE_ATTR. Getting message directly 2229 // from port. 2230 ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, 1000); 2231 IceMessage* msg = ice_full_port->last_stun_msg(); 2232 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL); 2233 2234 // Respond with a BINDING-RESPONSE from litemode client. 2235 // NOTE: Ideally we should't create connection at this stage from lite 2236 // port, as it should be done only after receiving ping with USE_CANDIDATE. 2237 // But we need a connection to send a response message. 2238 ice_lite_port->CreateConnection( 2239 ice_full_port->Candidates()[0], cricket::Port::ORIGIN_MESSAGE); 2240 talk_base::scoped_ptr<IceMessage> request(CopyStunMessage(msg)); 2241 ice_lite_port->SendBindingResponse( 2242 request.get(), ice_full_port->Candidates()[0].address()); 2243 2244 // Feeding the respone message from litemode to the full mode connection. 2245 ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->Data(), 2246 ice_lite_port->last_stun_buf()->Length()); 2247 // Verifying full mode connection becomes writable from the response. 2248 EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(), 2249 kTimeout); 2250 EXPECT_TRUE_WAIT(ch1.nominated(), kTimeout); 2251 2252 // Clear existing stun messsages. Otherwise we will process old stun 2253 // message right after we send ping. 2254 ice_full_port->Reset(); 2255 // Send ping. This must have USE_CANDIDATE_ATTR. 2256 ch1.Ping(); 2257 ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, 1000); 2258 msg = ice_full_port->last_stun_msg(); 2259 EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL); 2260 ch1.Stop(); 2261 } 2262
