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