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