1 /*
2 * libjingle
3 * Copyright 2009 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "talk/base/dscp.h"
29 #include "talk/base/fakenetwork.h"
30 #include "talk/base/firewallsocketserver.h"
31 #include "talk/base/gunit.h"
32 #include "talk/base/helpers.h"
33 #include "talk/base/logging.h"
34 #include "talk/base/natserver.h"
35 #include "talk/base/natsocketfactory.h"
36 #include "talk/base/physicalsocketserver.h"
37 #include "talk/base/proxyserver.h"
38 #include "talk/base/socketaddress.h"
39 #include "talk/base/thread.h"
40 #include "talk/base/virtualsocketserver.h"
41 #include "talk/p2p/base/p2ptransportchannel.h"
42 #include "talk/p2p/base/testrelayserver.h"
43 #include "talk/p2p/base/teststunserver.h"
44 #include "talk/p2p/client/basicportallocator.h"
45
46 using cricket::kDefaultPortAllocatorFlags;
47 using cricket::kMinimumStepDelay;
48 using cricket::kDefaultStepDelay;
49 using cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG;
50 using cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET;
51 using talk_base::SocketAddress;
52
53 static const int kDefaultTimeout = 1000;
54 static const int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN |
55 cricket::PORTALLOCATOR_DISABLE_RELAY |
56 cricket::PORTALLOCATOR_DISABLE_TCP;
57 // Addresses on the public internet.
58 static const SocketAddress kPublicAddrs[2] =
59 { SocketAddress("11.11.11.11", 0), SocketAddress("22.22.22.22", 0) };
60 // IPv6 Addresses on the public internet.
61 static const SocketAddress kIPv6PublicAddrs[2] = {
62 SocketAddress("2400:4030:1:2c00:be30:abcd:efab:cdef", 0),
63 SocketAddress("2620:0:1000:1b03:2e41:38ff:fea6:f2a4", 0)
64 };
65 // For configuring multihomed clients.
66 static const SocketAddress kAlternateAddrs[2] =
67 { SocketAddress("11.11.11.101", 0), SocketAddress("22.22.22.202", 0) };
68 // Addresses for HTTP proxy servers.
69 static const SocketAddress kHttpsProxyAddrs[2] =
70 { SocketAddress("11.11.11.1", 443), SocketAddress("22.22.22.1", 443) };
71 // Addresses for SOCKS proxy servers.
72 static const SocketAddress kSocksProxyAddrs[2] =
73 { SocketAddress("11.11.11.1", 1080), SocketAddress("22.22.22.1", 1080) };
74 // Internal addresses for NAT boxes.
75 static const SocketAddress kNatAddrs[2] =
76 { SocketAddress("192.168.1.1", 0), SocketAddress("192.168.2.1", 0) };
77 // Private addresses inside the NAT private networks.
78 static const SocketAddress kPrivateAddrs[2] =
79 { SocketAddress("192.168.1.11", 0), SocketAddress("192.168.2.22", 0) };
80 // For cascaded NATs, the internal addresses of the inner NAT boxes.
81 static const SocketAddress kCascadedNatAddrs[2] =
82 { SocketAddress("192.168.10.1", 0), SocketAddress("192.168.20.1", 0) };
83 // For cascaded NATs, private addresses inside the inner private networks.
84 static const SocketAddress kCascadedPrivateAddrs[2] =
85 { SocketAddress("192.168.10.11", 0), SocketAddress("192.168.20.22", 0) };
86 // The address of the public STUN server.
87 static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
88 // The addresses for the public relay server.
89 static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
90 static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
91 static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
92 static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
93 static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
94 static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
95
96 // Based on ICE_UFRAG_LENGTH
97 static const char* kIceUfrag[4] = {"TESTICEUFRAG0000", "TESTICEUFRAG0001",
98 "TESTICEUFRAG0002", "TESTICEUFRAG0003"};
99 // Based on ICE_PWD_LENGTH
100 static const char* kIcePwd[4] = {"TESTICEPWD00000000000000",
101 "TESTICEPWD00000000000001",
102 "TESTICEPWD00000000000002",
103 "TESTICEPWD00000000000003"};
104
105 static const uint64 kTiebreaker1 = 11111;
106 static const uint64 kTiebreaker2 = 22222;
107
108 // This test simulates 2 P2P endpoints that want to establish connectivity
109 // with each other over various network topologies and conditions, which can be
110 // specified in each individial test.
111 // A virtual network (via VirtualSocketServer) along with virtual firewalls and
112 // NATs (via Firewall/NATSocketServer) are used to simulate the various network
113 // conditions. We can configure the IP addresses of the endpoints,
114 // block various types of connectivity, or add arbitrary levels of NAT.
115 // We also run a STUN server and a relay server on the virtual network to allow
116 // our typical P2P mechanisms to do their thing.
117 // For each case, we expect the P2P stack to eventually settle on a specific
118 // form of connectivity to the other side. The test checks that the P2P
119 // negotiation successfully establishes connectivity within a certain time,
120 // and that the result is what we expect.
121 // Note that this class is a base class for use by other tests, who will provide
122 // specialized test behavior.
123 class P2PTransportChannelTestBase : public testing::Test,
124 public talk_base::MessageHandler,
125 public sigslot::has_slots<> {
126 public:
P2PTransportChannelTestBase()127 P2PTransportChannelTestBase()
128 : main_(talk_base::Thread::Current()),
129 pss_(new talk_base::PhysicalSocketServer),
130 vss_(new talk_base::VirtualSocketServer(pss_.get())),
131 nss_(new talk_base::NATSocketServer(vss_.get())),
132 ss_(new talk_base::FirewallSocketServer(nss_.get())),
133 ss_scope_(ss_.get()),
134 stun_server_(main_, kStunAddr),
135 relay_server_(main_, kRelayUdpIntAddr, kRelayUdpExtAddr,
136 kRelayTcpIntAddr, kRelayTcpExtAddr,
137 kRelaySslTcpIntAddr, kRelaySslTcpExtAddr),
138 socks_server1_(ss_.get(), kSocksProxyAddrs[0],
139 ss_.get(), kSocksProxyAddrs[0]),
140 socks_server2_(ss_.get(), kSocksProxyAddrs[1],
141 ss_.get(), kSocksProxyAddrs[1]),
142 clear_remote_candidates_ufrag_pwd_(false) {
143 ep1_.role_ = cricket::ICEROLE_CONTROLLING;
144 ep2_.role_ = cricket::ICEROLE_CONTROLLED;
145 ep1_.allocator_.reset(new cricket::BasicPortAllocator(
146 &ep1_.network_manager_, kStunAddr, kRelayUdpIntAddr,
147 kRelayTcpIntAddr, kRelaySslTcpIntAddr));
148 ep2_.allocator_.reset(new cricket::BasicPortAllocator(
149 &ep2_.network_manager_, kStunAddr, kRelayUdpIntAddr,
150 kRelayTcpIntAddr, kRelaySslTcpIntAddr));
151 }
152
153 protected:
154 enum Config {
155 OPEN, // Open to the Internet
156 NAT_FULL_CONE, // NAT, no filtering
157 NAT_ADDR_RESTRICTED, // NAT, must send to an addr to recv
158 NAT_PORT_RESTRICTED, // NAT, must send to an addr+port to recv
159 NAT_SYMMETRIC, // NAT, endpoint-dependent bindings
160 NAT_DOUBLE_CONE, // Double NAT, both cone
161 NAT_SYMMETRIC_THEN_CONE, // Double NAT, symmetric outer, cone inner
162 BLOCK_UDP, // Firewall, UDP in/out blocked
163 BLOCK_UDP_AND_INCOMING_TCP, // Firewall, UDP in/out and TCP in blocked
164 BLOCK_ALL_BUT_OUTGOING_HTTP, // Firewall, only TCP out on 80/443
165 PROXY_HTTPS, // All traffic through HTTPS proxy
166 PROXY_SOCKS, // All traffic through SOCKS proxy
167 NUM_CONFIGS
168 };
169
170 struct Result {
ResultP2PTransportChannelTestBase::Result171 Result(const std::string& lt, const std::string& lp,
172 const std::string& rt, const std::string& rp,
173 const std::string& lt2, const std::string& lp2,
174 const std::string& rt2, const std::string& rp2, int wait)
175 : local_type(lt), local_proto(lp), remote_type(rt), remote_proto(rp),
176 local_type2(lt2), local_proto2(lp2), remote_type2(rt2),
177 remote_proto2(rp2), connect_wait(wait) {
178 }
179 std::string local_type;
180 std::string local_proto;
181 std::string remote_type;
182 std::string remote_proto;
183 std::string local_type2;
184 std::string local_proto2;
185 std::string remote_type2;
186 std::string remote_proto2;
187 int connect_wait;
188 };
189
190 struct ChannelData {
CheckDataP2PTransportChannelTestBase::ChannelData191 bool CheckData(const char* data, int len) {
192 bool ret = false;
193 if (!ch_packets_.empty()) {
194 std::string packet = ch_packets_.front();
195 ret = (packet == std::string(data, len));
196 ch_packets_.pop_front();
197 }
198 return ret;
199 }
200
201 std::string name_; // TODO - Currently not used.
202 std::list<std::string> ch_packets_;
203 talk_base::scoped_ptr<cricket::P2PTransportChannel> ch_;
204 };
205
206 struct Endpoint {
EndpointP2PTransportChannelTestBase::Endpoint207 Endpoint() : signaling_delay_(0), role_(cricket::ICEROLE_UNKNOWN),
208 tiebreaker_(0), role_conflict_(false),
209 protocol_type_(cricket::ICEPROTO_GOOGLE) {}
HasChannelP2PTransportChannelTestBase::Endpoint210 bool HasChannel(cricket::TransportChannel* ch) {
211 return (ch == cd1_.ch_.get() || ch == cd2_.ch_.get());
212 }
GetChannelDataP2PTransportChannelTestBase::Endpoint213 ChannelData* GetChannelData(cricket::TransportChannel* ch) {
214 if (!HasChannel(ch)) return NULL;
215 if (cd1_.ch_.get() == ch)
216 return &cd1_;
217 else
218 return &cd2_;
219 }
SetSignalingDelayP2PTransportChannelTestBase::Endpoint220 void SetSignalingDelay(int delay) { signaling_delay_ = delay; }
221
SetIceRoleP2PTransportChannelTestBase::Endpoint222 void SetIceRole(cricket::IceRole role) { role_ = role; }
ice_roleP2PTransportChannelTestBase::Endpoint223 cricket::IceRole ice_role() { return role_; }
SetIceProtocolTypeP2PTransportChannelTestBase::Endpoint224 void SetIceProtocolType(cricket::IceProtocolType type) {
225 protocol_type_ = type;
226 }
protocol_typeP2PTransportChannelTestBase::Endpoint227 cricket::IceProtocolType protocol_type() { return protocol_type_; }
SetIceTiebreakerP2PTransportChannelTestBase::Endpoint228 void SetIceTiebreaker(uint64 tiebreaker) { tiebreaker_ = tiebreaker; }
GetIceTiebreakerP2PTransportChannelTestBase::Endpoint229 uint64 GetIceTiebreaker() { return tiebreaker_; }
OnRoleConflictP2PTransportChannelTestBase::Endpoint230 void OnRoleConflict(bool role_conflict) { role_conflict_ = role_conflict; }
role_conflictP2PTransportChannelTestBase::Endpoint231 bool role_conflict() { return role_conflict_; }
SetAllocationStepDelayP2PTransportChannelTestBase::Endpoint232 void SetAllocationStepDelay(uint32 delay) {
233 allocator_->set_step_delay(delay);
234 }
SetAllowTcpListenP2PTransportChannelTestBase::Endpoint235 void SetAllowTcpListen(bool allow_tcp_listen) {
236 allocator_->set_allow_tcp_listen(allow_tcp_listen);
237 }
238
239 talk_base::FakeNetworkManager network_manager_;
240 talk_base::scoped_ptr<cricket::PortAllocator> allocator_;
241 ChannelData cd1_;
242 ChannelData cd2_;
243 int signaling_delay_;
244 cricket::IceRole role_;
245 uint64 tiebreaker_;
246 bool role_conflict_;
247 cricket::IceProtocolType protocol_type_;
248 };
249
250 struct CandidateData : public talk_base::MessageData {
CandidateDataP2PTransportChannelTestBase::CandidateData251 CandidateData(cricket::TransportChannel* ch, const cricket::Candidate& c)
252 : channel(ch), candidate(c) {
253 }
254 cricket::TransportChannel* channel;
255 cricket::Candidate candidate;
256 };
257
GetChannelData(cricket::TransportChannel * channel)258 ChannelData* GetChannelData(cricket::TransportChannel* channel) {
259 if (ep1_.HasChannel(channel))
260 return ep1_.GetChannelData(channel);
261 else
262 return ep2_.GetChannelData(channel);
263 }
264
CreateChannels(int num)265 void CreateChannels(int num) {
266 std::string ice_ufrag_ep1_cd1_ch = kIceUfrag[0];
267 std::string ice_pwd_ep1_cd1_ch = kIcePwd[0];
268 std::string ice_ufrag_ep2_cd1_ch = kIceUfrag[1];
269 std::string ice_pwd_ep2_cd1_ch = kIcePwd[1];
270 ep1_.cd1_.ch_.reset(CreateChannel(
271 0, cricket::ICE_CANDIDATE_COMPONENT_DEFAULT,
272 ice_ufrag_ep1_cd1_ch, ice_pwd_ep1_cd1_ch,
273 ice_ufrag_ep2_cd1_ch, ice_pwd_ep2_cd1_ch));
274 ep2_.cd1_.ch_.reset(CreateChannel(
275 1, cricket::ICE_CANDIDATE_COMPONENT_DEFAULT,
276 ice_ufrag_ep2_cd1_ch, ice_pwd_ep2_cd1_ch,
277 ice_ufrag_ep1_cd1_ch, ice_pwd_ep1_cd1_ch));
278 if (num == 2) {
279 std::string ice_ufrag_ep1_cd2_ch = kIceUfrag[2];
280 std::string ice_pwd_ep1_cd2_ch = kIcePwd[2];
281 std::string ice_ufrag_ep2_cd2_ch = kIceUfrag[3];
282 std::string ice_pwd_ep2_cd2_ch = kIcePwd[3];
283 // In BUNDLE each endpoint must share common ICE credentials.
284 if (ep1_.allocator_->flags() & cricket::PORTALLOCATOR_ENABLE_BUNDLE) {
285 ice_ufrag_ep1_cd2_ch = ice_ufrag_ep1_cd1_ch;
286 ice_pwd_ep1_cd2_ch = ice_pwd_ep1_cd1_ch;
287 }
288 if (ep2_.allocator_->flags() & cricket::PORTALLOCATOR_ENABLE_BUNDLE) {
289 ice_ufrag_ep2_cd2_ch = ice_ufrag_ep2_cd1_ch;
290 ice_pwd_ep2_cd2_ch = ice_pwd_ep2_cd1_ch;
291 }
292 ep1_.cd2_.ch_.reset(CreateChannel(
293 0, cricket::ICE_CANDIDATE_COMPONENT_DEFAULT,
294 ice_ufrag_ep1_cd2_ch, ice_pwd_ep1_cd2_ch,
295 ice_ufrag_ep2_cd2_ch, ice_pwd_ep2_cd2_ch));
296 ep2_.cd2_.ch_.reset(CreateChannel(
297 1, cricket::ICE_CANDIDATE_COMPONENT_DEFAULT,
298 ice_ufrag_ep2_cd2_ch, ice_pwd_ep2_cd2_ch,
299 ice_ufrag_ep1_cd2_ch, ice_pwd_ep1_cd2_ch));
300 }
301 }
CreateChannel(int endpoint,int component,const std::string & local_ice_ufrag,const std::string & local_ice_pwd,const std::string & remote_ice_ufrag,const std::string & remote_ice_pwd)302 cricket::P2PTransportChannel* CreateChannel(
303 int endpoint,
304 int component,
305 const std::string& local_ice_ufrag,
306 const std::string& local_ice_pwd,
307 const std::string& remote_ice_ufrag,
308 const std::string& remote_ice_pwd) {
309 cricket::P2PTransportChannel* channel = new cricket::P2PTransportChannel(
310 "test content name", component, NULL, GetAllocator(endpoint));
311 channel->SignalRequestSignaling.connect(
312 this, &P2PTransportChannelTestBase::OnChannelRequestSignaling);
313 channel->SignalCandidateReady.connect(this,
314 &P2PTransportChannelTestBase::OnCandidate);
315 channel->SignalReadPacket.connect(
316 this, &P2PTransportChannelTestBase::OnReadPacket);
317 channel->SignalRoleConflict.connect(
318 this, &P2PTransportChannelTestBase::OnRoleConflict);
319 channel->SetIceProtocolType(GetEndpoint(endpoint)->protocol_type());
320 channel->SetIceCredentials(local_ice_ufrag, local_ice_pwd);
321 if (clear_remote_candidates_ufrag_pwd_) {
322 // This only needs to be set if we're clearing them from the
323 // candidates. Some unit tests rely on this not being set.
324 channel->SetRemoteIceCredentials(remote_ice_ufrag, remote_ice_pwd);
325 }
326 channel->SetIceRole(GetEndpoint(endpoint)->ice_role());
327 channel->SetIceTiebreaker(GetEndpoint(endpoint)->GetIceTiebreaker());
328 channel->Connect();
329 return channel;
330 }
DestroyChannels()331 void DestroyChannels() {
332 ep1_.cd1_.ch_.reset();
333 ep2_.cd1_.ch_.reset();
334 ep1_.cd2_.ch_.reset();
335 ep2_.cd2_.ch_.reset();
336 }
ep1_ch1()337 cricket::P2PTransportChannel* ep1_ch1() { return ep1_.cd1_.ch_.get(); }
ep1_ch2()338 cricket::P2PTransportChannel* ep1_ch2() { return ep1_.cd2_.ch_.get(); }
ep2_ch1()339 cricket::P2PTransportChannel* ep2_ch1() { return ep2_.cd1_.ch_.get(); }
ep2_ch2()340 cricket::P2PTransportChannel* ep2_ch2() { return ep2_.cd2_.ch_.get(); }
341
342 // Common results.
343 static const Result kLocalUdpToLocalUdp;
344 static const Result kLocalUdpToStunUdp;
345 static const Result kLocalUdpToPrflxUdp;
346 static const Result kPrflxUdpToLocalUdp;
347 static const Result kStunUdpToLocalUdp;
348 static const Result kStunUdpToStunUdp;
349 static const Result kPrflxUdpToStunUdp;
350 static const Result kLocalUdpToRelayUdp;
351 static const Result kPrflxUdpToRelayUdp;
352 static const Result kLocalTcpToLocalTcp;
353 static const Result kLocalTcpToPrflxTcp;
354 static const Result kPrflxTcpToLocalTcp;
355
SetUpTestCase()356 static void SetUpTestCase() {
357 // Ensure the RNG is inited.
358 talk_base::InitRandom(NULL, 0);
359 }
360
nat()361 talk_base::NATSocketServer* nat() { return nss_.get(); }
fw()362 talk_base::FirewallSocketServer* fw() { return ss_.get(); }
363
GetEndpoint(int endpoint)364 Endpoint* GetEndpoint(int endpoint) {
365 if (endpoint == 0) {
366 return &ep1_;
367 } else if (endpoint == 1) {
368 return &ep2_;
369 } else {
370 return NULL;
371 }
372 }
GetAllocator(int endpoint)373 cricket::PortAllocator* GetAllocator(int endpoint) {
374 return GetEndpoint(endpoint)->allocator_.get();
375 }
AddAddress(int endpoint,const SocketAddress & addr)376 void AddAddress(int endpoint, const SocketAddress& addr) {
377 GetEndpoint(endpoint)->network_manager_.AddInterface(addr);
378 }
RemoveAddress(int endpoint,const SocketAddress & addr)379 void RemoveAddress(int endpoint, const SocketAddress& addr) {
380 GetEndpoint(endpoint)->network_manager_.RemoveInterface(addr);
381 }
SetProxy(int endpoint,talk_base::ProxyType type)382 void SetProxy(int endpoint, talk_base::ProxyType type) {
383 talk_base::ProxyInfo info;
384 info.type = type;
385 info.address = (type == talk_base::PROXY_HTTPS) ?
386 kHttpsProxyAddrs[endpoint] : kSocksProxyAddrs[endpoint];
387 GetAllocator(endpoint)->set_proxy("unittest/1.0", info);
388 }
SetAllocatorFlags(int endpoint,int flags)389 void SetAllocatorFlags(int endpoint, int flags) {
390 GetAllocator(endpoint)->set_flags(flags);
391 }
SetSignalingDelay(int endpoint,int delay)392 void SetSignalingDelay(int endpoint, int delay) {
393 GetEndpoint(endpoint)->SetSignalingDelay(delay);
394 }
SetIceProtocol(int endpoint,cricket::IceProtocolType type)395 void SetIceProtocol(int endpoint, cricket::IceProtocolType type) {
396 GetEndpoint(endpoint)->SetIceProtocolType(type);
397 }
SetIceRole(int endpoint,cricket::IceRole role)398 void SetIceRole(int endpoint, cricket::IceRole role) {
399 GetEndpoint(endpoint)->SetIceRole(role);
400 }
SetIceTiebreaker(int endpoint,uint64 tiebreaker)401 void SetIceTiebreaker(int endpoint, uint64 tiebreaker) {
402 GetEndpoint(endpoint)->SetIceTiebreaker(tiebreaker);
403 }
GetRoleConflict(int endpoint)404 bool GetRoleConflict(int endpoint) {
405 return GetEndpoint(endpoint)->role_conflict();
406 }
SetAllocationStepDelay(int endpoint,uint32 delay)407 void SetAllocationStepDelay(int endpoint, uint32 delay) {
408 return GetEndpoint(endpoint)->SetAllocationStepDelay(delay);
409 }
SetAllowTcpListen(int endpoint,bool allow_tcp_listen)410 void SetAllowTcpListen(int endpoint, bool allow_tcp_listen) {
411 return GetEndpoint(endpoint)->SetAllowTcpListen(allow_tcp_listen);
412 }
413
Test(const Result & expected)414 void Test(const Result& expected) {
415 int32 connect_start = talk_base::Time(), connect_time;
416
417 // Create the channels and wait for them to connect.
418 CreateChannels(1);
419 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL &&
420 ep2_ch1() != NULL &&
421 ep1_ch1()->readable() &&
422 ep1_ch1()->writable() &&
423 ep2_ch1()->readable() &&
424 ep2_ch1()->writable(),
425 expected.connect_wait,
426 1000);
427 connect_time = talk_base::TimeSince(connect_start);
428 if (connect_time < expected.connect_wait) {
429 LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
430 } else {
431 LOG(LS_INFO) << "Connect time: " << "TIMEOUT ("
432 << expected.connect_wait << " ms)";
433 }
434
435 // Allow a few turns of the crank for the best connections to emerge.
436 // This may take up to 2 seconds.
437 if (ep1_ch1()->best_connection() &&
438 ep2_ch1()->best_connection()) {
439 int32 converge_start = talk_base::Time(), converge_time;
440 int converge_wait = 2000;
441 EXPECT_TRUE_WAIT_MARGIN(
442 LocalCandidate(ep1_ch1())->type() == expected.local_type &&
443 LocalCandidate(ep1_ch1())->protocol() == expected.local_proto &&
444 RemoteCandidate(ep1_ch1())->type() == expected.remote_type &&
445 RemoteCandidate(ep1_ch1())->protocol() == expected.remote_proto,
446 converge_wait,
447 converge_wait);
448
449 // Also do EXPECT_EQ on each part so that failures are more verbose.
450 EXPECT_EQ(expected.local_type, LocalCandidate(ep1_ch1())->type());
451 EXPECT_EQ(expected.local_proto, LocalCandidate(ep1_ch1())->protocol());
452 EXPECT_EQ(expected.remote_type, RemoteCandidate(ep1_ch1())->type());
453 EXPECT_EQ(expected.remote_proto, RemoteCandidate(ep1_ch1())->protocol());
454
455 // Verifying remote channel best connection information. This is done
456 // only for the RFC 5245 as controlled agent will use USE-CANDIDATE
457 // from controlling (ep1) agent. We can easily predict from EP1 result
458 // matrix.
459 if (ep2_.protocol_type_ == cricket::ICEPROTO_RFC5245) {
460 // Checking for best connection candidates information at remote.
461 EXPECT_TRUE_WAIT(
462 LocalCandidate(ep2_ch1())->type() == expected.local_type2 &&
463 LocalCandidate(ep2_ch1())->protocol() == expected.local_proto2 &&
464 RemoteCandidate(ep2_ch1())->protocol() == expected.remote_proto2,
465 kDefaultTimeout);
466
467 // For verbose
468 EXPECT_EQ(expected.local_type2, LocalCandidate(ep2_ch1())->type());
469 EXPECT_EQ(expected.local_proto2, LocalCandidate(ep2_ch1())->protocol());
470 EXPECT_EQ(expected.remote_proto2,
471 RemoteCandidate(ep2_ch1())->protocol());
472 // Removed remote_type comparision aginst best connection remote
473 // candidate. This is done to handle remote type discrepancy from
474 // local to stun based on the test type.
475 // For example in case of Open -> NAT, ep2 channels will have LULU
476 // and in other cases like NAT -> NAT it will be LUSU. To avoid these
477 // mismatches and we are doing comparision in different way.
478 // i.e. when don't match its remote type is either local or stun.
479 // TODO(ronghuawu): Refine the test criteria.
480 // https://code.google.com/p/webrtc/issues/detail?id=1953
481 if (expected.remote_type2 != RemoteCandidate(ep2_ch1())->type())
482 EXPECT_TRUE(expected.remote_type2 == cricket::LOCAL_PORT_TYPE ||
483 expected.remote_type2 == cricket::STUN_PORT_TYPE);
484 EXPECT_TRUE(
485 RemoteCandidate(ep2_ch1())->type() == cricket::LOCAL_PORT_TYPE ||
486 RemoteCandidate(ep2_ch1())->type() == cricket::STUN_PORT_TYPE ||
487 RemoteCandidate(ep2_ch1())->type() == cricket::PRFLX_PORT_TYPE);
488 }
489
490 converge_time = talk_base::TimeSince(converge_start);
491 if (converge_time < converge_wait) {
492 LOG(LS_INFO) << "Converge time: " << converge_time << " ms";
493 } else {
494 LOG(LS_INFO) << "Converge time: " << "TIMEOUT ("
495 << converge_wait << " ms)";
496 }
497 }
498 // Try sending some data to other end.
499 TestSendRecv(1);
500
501 // Destroy the channels, and wait for them to be fully cleaned up.
502 DestroyChannels();
503 }
504
TestSendRecv(int channels)505 void TestSendRecv(int channels) {
506 for (int i = 0; i < 10; ++i) {
507 const char* data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
508 int len = static_cast<int>(strlen(data));
509 // local_channel1 <==> remote_channel1
510 EXPECT_EQ_WAIT(len, SendData(ep1_ch1(), data, len), 1000);
511 EXPECT_TRUE_WAIT(CheckDataOnChannel(ep2_ch1(), data, len), 1000);
512 EXPECT_EQ_WAIT(len, SendData(ep2_ch1(), data, len), 1000);
513 EXPECT_TRUE_WAIT(CheckDataOnChannel(ep1_ch1(), data, len), 1000);
514 if (channels == 2 && ep1_ch2() && ep2_ch2()) {
515 // local_channel2 <==> remote_channel2
516 EXPECT_EQ_WAIT(len, SendData(ep1_ch2(), data, len), 1000);
517 EXPECT_TRUE_WAIT(CheckDataOnChannel(ep2_ch2(), data, len), 1000);
518 EXPECT_EQ_WAIT(len, SendData(ep2_ch2(), data, len), 1000);
519 EXPECT_TRUE_WAIT(CheckDataOnChannel(ep1_ch2(), data, len), 1000);
520 }
521 }
522 }
523
524 // This test waits for the transport to become readable and writable on both
525 // end points. Once they are, the end points set new local ice credentials to
526 // restart the ice gathering. Finally it waits for the transport to select a
527 // new connection using the newly generated ice candidates.
528 // Before calling this function the end points must be configured.
TestHandleIceUfragPasswordChanged()529 void TestHandleIceUfragPasswordChanged() {
530 ep1_ch1()->SetRemoteIceCredentials(kIceUfrag[1], kIcePwd[1]);
531 ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[0], kIcePwd[0]);
532 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1()->readable() && ep1_ch1()->writable() &&
533 ep2_ch1()->readable() && ep2_ch1()->writable(),
534 1000, 1000);
535
536 const cricket::Candidate* old_local_candidate1 = LocalCandidate(ep1_ch1());
537 const cricket::Candidate* old_local_candidate2 = LocalCandidate(ep2_ch1());
538 const cricket::Candidate* old_remote_candidate1 =
539 RemoteCandidate(ep1_ch1());
540 const cricket::Candidate* old_remote_candidate2 =
541 RemoteCandidate(ep2_ch1());
542
543 ep1_ch1()->SetIceCredentials(kIceUfrag[2], kIcePwd[2]);
544 ep1_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]);
545 ep2_ch1()->SetIceCredentials(kIceUfrag[3], kIcePwd[3]);
546 ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[2], kIcePwd[2]);
547
548 EXPECT_TRUE_WAIT_MARGIN(LocalCandidate(ep1_ch1())->generation() !=
549 old_local_candidate1->generation(),
550 1000, 1000);
551 EXPECT_TRUE_WAIT_MARGIN(LocalCandidate(ep2_ch1())->generation() !=
552 old_local_candidate2->generation(),
553 1000, 1000);
554 EXPECT_TRUE_WAIT_MARGIN(RemoteCandidate(ep1_ch1())->generation() !=
555 old_remote_candidate1->generation(),
556 1000, 1000);
557 EXPECT_TRUE_WAIT_MARGIN(RemoteCandidate(ep2_ch1())->generation() !=
558 old_remote_candidate2->generation(),
559 1000, 1000);
560 EXPECT_EQ(1u, RemoteCandidate(ep2_ch1())->generation());
561 EXPECT_EQ(1u, RemoteCandidate(ep1_ch1())->generation());
562 }
563
TestSignalRoleConflict()564 void TestSignalRoleConflict() {
565 SetIceProtocol(0, cricket::ICEPROTO_RFC5245);
566 SetIceTiebreaker(0, kTiebreaker1); // Default EP1 is in controlling state.
567
568 SetIceProtocol(1, cricket::ICEPROTO_RFC5245);
569 SetIceRole(1, cricket::ICEROLE_CONTROLLING);
570 SetIceTiebreaker(1, kTiebreaker2);
571
572 // Creating channels with both channels role set to CONTROLLING.
573 CreateChannels(1);
574 // Since both the channels initiated with controlling state and channel2
575 // has higher tiebreaker value, channel1 should receive SignalRoleConflict.
576 EXPECT_TRUE_WAIT(GetRoleConflict(0), 1000);
577 EXPECT_FALSE(GetRoleConflict(1));
578
579 EXPECT_TRUE_WAIT(ep1_ch1()->readable() &&
580 ep1_ch1()->writable() &&
581 ep2_ch1()->readable() &&
582 ep2_ch1()->writable(),
583 1000);
584
585 EXPECT_TRUE(ep1_ch1()->best_connection() &&
586 ep2_ch1()->best_connection());
587
588 TestSendRecv(1);
589 }
590
OnChannelRequestSignaling(cricket::TransportChannelImpl * channel)591 void OnChannelRequestSignaling(cricket::TransportChannelImpl* channel) {
592 channel->OnSignalingReady();
593 }
594 // We pass the candidates directly to the other side.
OnCandidate(cricket::TransportChannelImpl * ch,const cricket::Candidate & c)595 void OnCandidate(cricket::TransportChannelImpl* ch,
596 const cricket::Candidate& c) {
597 main_->PostDelayed(GetEndpoint(ch)->signaling_delay_, this, 0,
598 new CandidateData(ch, c));
599 }
OnMessage(talk_base::Message * msg)600 void OnMessage(talk_base::Message* msg) {
601 talk_base::scoped_ptr<CandidateData> data(
602 static_cast<CandidateData*>(msg->pdata));
603 cricket::P2PTransportChannel* rch = GetRemoteChannel(data->channel);
604 cricket::Candidate c = data->candidate;
605 if (clear_remote_candidates_ufrag_pwd_) {
606 c.set_username("");
607 c.set_password("");
608 }
609 LOG(LS_INFO) << "Candidate(" << data->channel->component() << "->"
610 << rch->component() << "): " << c.type() << ", " << c.protocol()
611 << ", " << c.address().ToString() << ", " << c.username()
612 << ", " << c.generation();
613 rch->OnCandidate(c);
614 }
OnReadPacket(cricket::TransportChannel * channel,const char * data,size_t len,const talk_base::PacketTime & packet_time,int flags)615 void OnReadPacket(cricket::TransportChannel* channel, const char* data,
616 size_t len, const talk_base::PacketTime& packet_time,
617 int flags) {
618 std::list<std::string>& packets = GetPacketList(channel);
619 packets.push_front(std::string(data, len));
620 }
OnRoleConflict(cricket::TransportChannelImpl * channel)621 void OnRoleConflict(cricket::TransportChannelImpl* channel) {
622 GetEndpoint(channel)->OnRoleConflict(true);
623 cricket::IceRole new_role =
624 GetEndpoint(channel)->ice_role() == cricket::ICEROLE_CONTROLLING ?
625 cricket::ICEROLE_CONTROLLED : cricket::ICEROLE_CONTROLLING;
626 channel->SetIceRole(new_role);
627 }
SendData(cricket::TransportChannel * channel,const char * data,size_t len)628 int SendData(cricket::TransportChannel* channel,
629 const char* data, size_t len) {
630 return channel->SendPacket(data, len, talk_base::DSCP_NO_CHANGE, 0);
631 }
CheckDataOnChannel(cricket::TransportChannel * channel,const char * data,int len)632 bool CheckDataOnChannel(cricket::TransportChannel* channel,
633 const char* data, int len) {
634 return GetChannelData(channel)->CheckData(data, len);
635 }
LocalCandidate(cricket::P2PTransportChannel * ch)636 static const cricket::Candidate* LocalCandidate(
637 cricket::P2PTransportChannel* ch) {
638 return (ch && ch->best_connection()) ?
639 &ch->best_connection()->local_candidate() : NULL;
640 }
RemoteCandidate(cricket::P2PTransportChannel * ch)641 static const cricket::Candidate* RemoteCandidate(
642 cricket::P2PTransportChannel* ch) {
643 return (ch && ch->best_connection()) ?
644 &ch->best_connection()->remote_candidate() : NULL;
645 }
GetEndpoint(cricket::TransportChannel * ch)646 Endpoint* GetEndpoint(cricket::TransportChannel* ch) {
647 if (ep1_.HasChannel(ch)) {
648 return &ep1_;
649 } else if (ep2_.HasChannel(ch)) {
650 return &ep2_;
651 } else {
652 return NULL;
653 }
654 }
GetRemoteChannel(cricket::TransportChannel * ch)655 cricket::P2PTransportChannel* GetRemoteChannel(
656 cricket::TransportChannel* ch) {
657 if (ch == ep1_ch1())
658 return ep2_ch1();
659 else if (ch == ep1_ch2())
660 return ep2_ch2();
661 else if (ch == ep2_ch1())
662 return ep1_ch1();
663 else if (ch == ep2_ch2())
664 return ep1_ch2();
665 else
666 return NULL;
667 }
GetPacketList(cricket::TransportChannel * ch)668 std::list<std::string>& GetPacketList(cricket::TransportChannel* ch) {
669 return GetChannelData(ch)->ch_packets_;
670 }
671
set_clear_remote_candidates_ufrag_pwd(bool clear)672 void set_clear_remote_candidates_ufrag_pwd(bool clear) {
673 clear_remote_candidates_ufrag_pwd_ = clear;
674 }
675
676 private:
677 talk_base::Thread* main_;
678 talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
679 talk_base::scoped_ptr<talk_base::VirtualSocketServer> vss_;
680 talk_base::scoped_ptr<talk_base::NATSocketServer> nss_;
681 talk_base::scoped_ptr<talk_base::FirewallSocketServer> ss_;
682 talk_base::SocketServerScope ss_scope_;
683 cricket::TestStunServer stun_server_;
684 cricket::TestRelayServer relay_server_;
685 talk_base::SocksProxyServer socks_server1_;
686 talk_base::SocksProxyServer socks_server2_;
687 Endpoint ep1_;
688 Endpoint ep2_;
689 bool clear_remote_candidates_ufrag_pwd_;
690 };
691
692 // The tests have only a few outcomes, which we predefine.
693 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
694 kLocalUdpToLocalUdp("local", "udp", "local", "udp",
695 "local", "udp", "local", "udp", 1000);
696 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
697 kLocalUdpToStunUdp("local", "udp", "stun", "udp",
698 "local", "udp", "stun", "udp", 1000);
699 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
700 kLocalUdpToPrflxUdp("local", "udp", "prflx", "udp",
701 "prflx", "udp", "local", "udp", 1000);
702 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
703 kPrflxUdpToLocalUdp("prflx", "udp", "local", "udp",
704 "local", "udp", "prflx", "udp", 1000);
705 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
706 kStunUdpToLocalUdp("stun", "udp", "local", "udp",
707 "local", "udp", "stun", "udp", 1000);
708 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
709 kStunUdpToStunUdp("stun", "udp", "stun", "udp",
710 "stun", "udp", "stun", "udp", 1000);
711 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
712 kPrflxUdpToStunUdp("prflx", "udp", "stun", "udp",
713 "local", "udp", "prflx", "udp", 1000);
714 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
715 kLocalUdpToRelayUdp("local", "udp", "relay", "udp",
716 "relay", "udp", "local", "udp", 2000);
717 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
718 kPrflxUdpToRelayUdp("prflx", "udp", "relay", "udp",
719 "relay", "udp", "prflx", "udp", 2000);
720 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
721 kLocalTcpToLocalTcp("local", "tcp", "local", "tcp",
722 "local", "tcp", "local", "tcp", 3000);
723 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
724 kLocalTcpToPrflxTcp("local", "tcp", "prflx", "tcp",
725 "prflx", "tcp", "local", "tcp", 3000);
726 const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
727 kPrflxTcpToLocalTcp("prflx", "tcp", "local", "tcp",
728 "local", "tcp", "prflx", "tcp", 3000);
729
730 // Test the matrix of all the connectivity types we expect to see in the wild.
731 // Just test every combination of the configs in the Config enum.
732 class P2PTransportChannelTest : public P2PTransportChannelTestBase {
733 protected:
734 static const Result* kMatrix[NUM_CONFIGS][NUM_CONFIGS];
735 static const Result* kMatrixSharedUfrag[NUM_CONFIGS][NUM_CONFIGS];
736 static const Result* kMatrixSharedSocketAsGice[NUM_CONFIGS][NUM_CONFIGS];
737 static const Result* kMatrixSharedSocketAsIce[NUM_CONFIGS][NUM_CONFIGS];
ConfigureEndpoints(Config config1,Config config2,int allocator_flags1,int allocator_flags2,int delay1,int delay2,cricket::IceProtocolType type)738 void ConfigureEndpoints(Config config1, Config config2,
739 int allocator_flags1, int allocator_flags2,
740 int delay1, int delay2,
741 cricket::IceProtocolType type) {
742 ConfigureEndpoint(0, config1);
743 SetIceProtocol(0, type);
744 SetAllocatorFlags(0, allocator_flags1);
745 SetAllocationStepDelay(0, delay1);
746 ConfigureEndpoint(1, config2);
747 SetIceProtocol(1, type);
748 SetAllocatorFlags(1, allocator_flags2);
749 SetAllocationStepDelay(1, delay2);
750 }
ConfigureEndpoint(int endpoint,Config config)751 void ConfigureEndpoint(int endpoint, Config config) {
752 switch (config) {
753 case OPEN:
754 AddAddress(endpoint, kPublicAddrs[endpoint]);
755 break;
756 case NAT_FULL_CONE:
757 case NAT_ADDR_RESTRICTED:
758 case NAT_PORT_RESTRICTED:
759 case NAT_SYMMETRIC:
760 AddAddress(endpoint, kPrivateAddrs[endpoint]);
761 // Add a single NAT of the desired type
762 nat()->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
763 static_cast<talk_base::NATType>(config - NAT_FULL_CONE))->
764 AddClient(kPrivateAddrs[endpoint]);
765 break;
766 case NAT_DOUBLE_CONE:
767 case NAT_SYMMETRIC_THEN_CONE:
768 AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
769 // Add a two cascaded NATs of the desired types
770 nat()->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
771 (config == NAT_DOUBLE_CONE) ?
772 talk_base::NAT_OPEN_CONE : talk_base::NAT_SYMMETRIC)->
773 AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
774 talk_base::NAT_OPEN_CONE)->
775 AddClient(kCascadedPrivateAddrs[endpoint]);
776 break;
777 case BLOCK_UDP:
778 case BLOCK_UDP_AND_INCOMING_TCP:
779 case BLOCK_ALL_BUT_OUTGOING_HTTP:
780 case PROXY_HTTPS:
781 case PROXY_SOCKS:
782 AddAddress(endpoint, kPublicAddrs[endpoint]);
783 // Block all UDP
784 fw()->AddRule(false, talk_base::FP_UDP, talk_base::FD_ANY,
785 kPublicAddrs[endpoint]);
786 if (config == BLOCK_UDP_AND_INCOMING_TCP) {
787 // Block TCP inbound to the endpoint
788 fw()->AddRule(false, talk_base::FP_TCP, SocketAddress(),
789 kPublicAddrs[endpoint]);
790 } else if (config == BLOCK_ALL_BUT_OUTGOING_HTTP) {
791 // Block all TCP to/from the endpoint except 80/443 out
792 fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
793 SocketAddress(talk_base::IPAddress(INADDR_ANY), 80));
794 fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
795 SocketAddress(talk_base::IPAddress(INADDR_ANY), 443));
796 fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
797 kPublicAddrs[endpoint]);
798 } else if (config == PROXY_HTTPS) {
799 // Block all TCP to/from the endpoint except to the proxy server
800 fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
801 kHttpsProxyAddrs[endpoint]);
802 fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
803 kPublicAddrs[endpoint]);
804 SetProxy(endpoint, talk_base::PROXY_HTTPS);
805 } else if (config == PROXY_SOCKS) {
806 // Block all TCP to/from the endpoint except to the proxy server
807 fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
808 kSocksProxyAddrs[endpoint]);
809 fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
810 kPublicAddrs[endpoint]);
811 SetProxy(endpoint, talk_base::PROXY_SOCKS5);
812 }
813 break;
814 default:
815 break;
816 }
817 }
818 };
819
820 // Shorthands for use in the test matrix.
821 #define LULU &kLocalUdpToLocalUdp
822 #define LUSU &kLocalUdpToStunUdp
823 #define LUPU &kLocalUdpToPrflxUdp
824 #define PULU &kPrflxUdpToLocalUdp
825 #define SULU &kStunUdpToLocalUdp
826 #define SUSU &kStunUdpToStunUdp
827 #define PUSU &kPrflxUdpToStunUdp
828 #define LURU &kLocalUdpToRelayUdp
829 #define PURU &kPrflxUdpToRelayUdp
830 #define LTLT &kLocalTcpToLocalTcp
831 #define LTPT &kLocalTcpToPrflxTcp
832 #define PTLT &kPrflxTcpToLocalTcp
833 // TODO: Enable these once TestRelayServer can accept external TCP.
834 #define LTRT NULL
835 #define LSRS NULL
836
837 // Test matrix. Originator behavior defined by rows, receiever by columns.
838
839 // Currently the p2ptransportchannel.cc (specifically the
840 // P2PTransportChannel::OnUnknownAddress) operates in 2 modes depend on the
841 // remote candidates - ufrag per port or shared ufrag.
842 // For example, if the remote candidates have the shared ufrag, for the unknown
843 // address reaches the OnUnknownAddress, we will try to find the matched
844 // remote candidate based on the address and protocol, if not found, a new
845 // remote candidate will be created for this address. But if the remote
846 // candidates have different ufrags, we will try to find the matched remote
847 // candidate by comparing the ufrag. If not found, an error will be returned.
848 // Because currently the shared ufrag feature is under the experiment and will
849 // be rolled out gradually. We want to test the different combinations of peers
850 // with/without the shared ufrag enabled. And those different combinations have
851 // different expectation of the best connection. For example in the OpenToCONE
852 // case, an unknown address will be updated to a "host" remote candidate if the
853 // remote peer uses different ufrag per port. But in the shared ufrag case,
854 // a "stun" (should be peer-reflexive eventually) candidate will be created for
855 // that. So the expected best candidate will be LUSU instead of LULU.
856 // With all these, we have to keep 2 test matrixes for the tests:
857 // kMatrix - for the tests that the remote peer uses different ufrag per port.
858 // kMatrixSharedUfrag - for the tests that remote peer uses shared ufrag.
859 // The different between the two matrixes are on:
860 // OPToCONE, OPTo2CON,
861 // COToCONE, COToADDR, COToPORT, COToSYMM, COTo2CON, COToSCON,
862 // ADToCONE, ADToADDR, ADTo2CON,
863 // POToADDR,
864 // SYToADDR,
865 // 2CToCONE, 2CToADDR, 2CToPORT, 2CToSYMM, 2CTo2CON, 2CToSCON,
866 // SCToADDR,
867
868 // TODO: Fix NULLs caused by lack of TCP support in NATSocket.
869 // TODO: Fix NULLs caused by no HTTP proxy support.
870 // TODO: Rearrange rows/columns from best to worst.
871 // TODO(ronghuawu): Keep only one test matrix once the shared ufrag is enabled.
872 const P2PTransportChannelTest::Result*
873 P2PTransportChannelTest::kMatrix[NUM_CONFIGS][NUM_CONFIGS] = {
874 // OPEN CONE ADDR PORT SYMM 2CON SCON !UDP !TCP HTTP PRXH PRXS
875 /*OP*/ {LULU, LULU, LULU, LULU, LULU, LULU, LULU, LTLT, LTLT, LSRS, NULL, LTLT},
876 /*CO*/ {LULU, LULU, LULU, SULU, SULU, LULU, SULU, NULL, NULL, LSRS, NULL, LTRT},
877 /*AD*/ {LULU, LULU, LULU, SUSU, SUSU, LULU, SUSU, NULL, NULL, LSRS, NULL, LTRT},
878 /*PO*/ {LULU, LUSU, LUSU, SUSU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
879 /*SY*/ {LULU, LUSU, LUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
880 /*2C*/ {LULU, LULU, LULU, SULU, SULU, LULU, SULU, NULL, NULL, LSRS, NULL, LTRT},
881 /*SC*/ {LULU, LUSU, LUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
882 /*!U*/ {LTLT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTLT, LSRS, NULL, LTRT},
883 /*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTRT, LSRS, NULL, LTRT},
884 /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
885 /*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
886 /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
887 };
888 const P2PTransportChannelTest::Result*
889 P2PTransportChannelTest::kMatrixSharedUfrag[NUM_CONFIGS][NUM_CONFIGS] = {
890 // OPEN CONE ADDR PORT SYMM 2CON SCON !UDP !TCP HTTP PRXH PRXS
891 /*OP*/ {LULU, LUSU, LULU, LULU, LULU, LUSU, LULU, LTLT, LTLT, LSRS, NULL, LTLT},
892 /*CO*/ {LULU, LUSU, LUSU, SUSU, SUSU, LUSU, SUSU, NULL, NULL, LSRS, NULL, LTRT},
893 /*AD*/ {LULU, LUSU, LUSU, SUSU, SUSU, LUSU, SUSU, NULL, NULL, LSRS, NULL, LTRT},
894 /*PO*/ {LULU, LUSU, LUSU, SUSU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
895 /*SY*/ {LULU, LUSU, LUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
896 /*2C*/ {LULU, LUSU, LUSU, SUSU, SUSU, LUSU, SUSU, NULL, NULL, LSRS, NULL, LTRT},
897 /*SC*/ {LULU, LUSU, LUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
898 /*!U*/ {LTLT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTLT, LSRS, NULL, LTRT},
899 /*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTRT, LSRS, NULL, LTRT},
900 /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
901 /*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
902 /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
903 };
904 const P2PTransportChannelTest::Result*
905 P2PTransportChannelTest::kMatrixSharedSocketAsGice
906 [NUM_CONFIGS][NUM_CONFIGS] = {
907 // OPEN CONE ADDR PORT SYMM 2CON SCON !UDP !TCP HTTP PRXH PRXS
908 /*OP*/ {LULU, LUSU, LUSU, LUSU, LUSU, LUSU, LUSU, LTLT, LTLT, LSRS, NULL, LTLT},
909 /*CO*/ {LULU, LUSU, LUSU, LUSU, LUSU, LUSU, LUSU, NULL, NULL, LSRS, NULL, LTRT},
910 /*AD*/ {LULU, LUSU, LUSU, LUSU, LUSU, LUSU, LUSU, NULL, NULL, LSRS, NULL, LTRT},
911 /*PO*/ {LULU, LUSU, LUSU, LUSU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
912 /*SY*/ {LULU, LUSU, LUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
913 /*2C*/ {LULU, LUSU, LUSU, LUSU, LUSU, LUSU, LUSU, NULL, NULL, LSRS, NULL, LTRT},
914 /*SC*/ {LULU, LUSU, LUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
915 /*!U*/ {LTLT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTLT, LSRS, NULL, LTRT},
916 /*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTRT, LSRS, NULL, LTRT},
917 /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
918 /*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
919 /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
920 };
921 const P2PTransportChannelTest::Result*
922 P2PTransportChannelTest::kMatrixSharedSocketAsIce
923 [NUM_CONFIGS][NUM_CONFIGS] = {
924 // OPEN CONE ADDR PORT SYMM 2CON SCON !UDP !TCP HTTP PRXH PRXS
925 /*OP*/ {LULU, LUSU, LUSU, LUSU, LUPU, LUSU, LUPU, PTLT, LTPT, LSRS, NULL, PTLT},
926 /*CO*/ {LULU, LUSU, LUSU, LUSU, LUPU, LUSU, LUPU, NULL, NULL, LSRS, NULL, LTRT},
927 /*AD*/ {LULU, LUSU, LUSU, LUSU, LUPU, LUSU, LUPU, NULL, NULL, LSRS, NULL, LTRT},
928 /*PO*/ {LULU, LUSU, LUSU, LUSU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
929 /*SY*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, NULL, NULL, LSRS, NULL, LTRT},
930 /*2C*/ {LULU, LUSU, LUSU, LUSU, LUPU, LUSU, LUPU, NULL, NULL, LSRS, NULL, LTRT},
931 /*SC*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, NULL, NULL, LSRS, NULL, LTRT},
932 /*!U*/ {PTLT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTPT, LSRS, NULL, LTRT},
933 /*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTRT, LSRS, NULL, LTRT},
934 /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
935 /*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
936 /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
937 };
938
939 // The actual tests that exercise all the various configurations.
940 // Test names are of the form P2PTransportChannelTest_TestOPENToNAT_FULL_CONE
941 // Same test case is run in both GICE and ICE mode.
942 // kDefaultStepDelay - is used for all Gice cases.
943 // kMinimumStepDelay - is used when both end points have
944 // PORTALLOCATOR_ENABLE_SHARED_UFRAG flag enabled.
945 // Technically we should be able to use kMinimumStepDelay irrespective of
946 // protocol type. But which might need modifications to current result matrices
947 // for tests in this file.
948 #define P2P_TEST_DECLARATION(x, y, z) \
949 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceNoneSharedUfrag) { \
950 ConfigureEndpoints(x, y, kDefaultPortAllocatorFlags, \
951 kDefaultPortAllocatorFlags, \
952 kDefaultStepDelay, kDefaultStepDelay, \
953 cricket::ICEPROTO_GOOGLE); \
954 if (kMatrix[x][y] != NULL) \
955 Test(*kMatrix[x][y]); \
956 else \
957 LOG(LS_WARNING) << "Not yet implemented"; \
958 } \
959 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceP0SharedUfrag) { \
960 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
961 kDefaultPortAllocatorFlags, \
962 kDefaultStepDelay, kDefaultStepDelay, \
963 cricket::ICEPROTO_GOOGLE); \
964 if (kMatrix[x][y] != NULL) \
965 Test(*kMatrix[x][y]); \
966 else \
967 LOG(LS_WARNING) << "Not yet implemented"; \
968 } \
969 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceP1SharedUfrag) { \
970 ConfigureEndpoints(x, y, kDefaultPortAllocatorFlags, \
971 PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
972 kDefaultStepDelay, kDefaultStepDelay, \
973 cricket::ICEPROTO_GOOGLE); \
974 if (kMatrixSharedUfrag[x][y] != NULL) \
975 Test(*kMatrixSharedUfrag[x][y]); \
976 else \
977 LOG(LS_WARNING) << "Not yet implemented"; \
978 } \
979 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceBothSharedUfrag) { \
980 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
981 PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
982 kDefaultStepDelay, kDefaultStepDelay, \
983 cricket::ICEPROTO_GOOGLE); \
984 if (kMatrixSharedUfrag[x][y] != NULL) \
985 Test(*kMatrixSharedUfrag[x][y]); \
986 else \
987 LOG(LS_WARNING) << "Not yet implemented"; \
988 } \
989 TEST_F(P2PTransportChannelTest, \
990 z##Test##x##To##y##AsGiceBothSharedUfragWithMinimumStepDelay) { \
991 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
992 PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
993 kMinimumStepDelay, kMinimumStepDelay, \
994 cricket::ICEPROTO_GOOGLE); \
995 if (kMatrixSharedUfrag[x][y] != NULL) \
996 Test(*kMatrixSharedUfrag[x][y]); \
997 else \
998 LOG(LS_WARNING) << "Not yet implemented"; \
999 } \
1000 TEST_F(P2PTransportChannelTest, \
1001 z##Test##x##To##y##AsGiceBothSharedUfragSocket) { \
1002 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG | \
1003 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1004 PORTALLOCATOR_ENABLE_SHARED_UFRAG | \
1005 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1006 kMinimumStepDelay, kMinimumStepDelay, \
1007 cricket::ICEPROTO_GOOGLE); \
1008 if (kMatrixSharedSocketAsGice[x][y] != NULL) \
1009 Test(*kMatrixSharedSocketAsGice[x][y]); \
1010 else \
1011 LOG(LS_WARNING) << "Not yet implemented"; \
1012 } \
1013 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsIce) { \
1014 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG | \
1015 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1016 PORTALLOCATOR_ENABLE_SHARED_UFRAG | \
1017 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1018 kMinimumStepDelay, kMinimumStepDelay, \
1019 cricket::ICEPROTO_RFC5245); \
1020 if (kMatrixSharedSocketAsIce[x][y] != NULL) \
1021 Test(*kMatrixSharedSocketAsIce[x][y]); \
1022 else \
1023 LOG(LS_WARNING) << "Not yet implemented"; \
1024 }
1025
1026 #define P2P_TEST(x, y) \
1027 P2P_TEST_DECLARATION(x, y,)
1028
1029 #define FLAKY_P2P_TEST(x, y) \
1030 P2P_TEST_DECLARATION(x, y, DISABLED_)
1031
1032 // TODO(holmer): Disabled due to randomly failing on webrtc buildbots.
1033 // Issue: webrtc/2383
1034 #define P2P_TEST_SET(x) \
1035 P2P_TEST(x, OPEN) \
1036 FLAKY_P2P_TEST(x, NAT_FULL_CONE) \
1037 FLAKY_P2P_TEST(x, NAT_ADDR_RESTRICTED) \
1038 P2P_TEST(x, NAT_PORT_RESTRICTED) \
1039 P2P_TEST(x, NAT_SYMMETRIC) \
1040 FLAKY_P2P_TEST(x, NAT_DOUBLE_CONE) \
1041 P2P_TEST(x, NAT_SYMMETRIC_THEN_CONE) \
1042 P2P_TEST(x, BLOCK_UDP) \
1043 P2P_TEST(x, BLOCK_UDP_AND_INCOMING_TCP) \
1044 P2P_TEST(x, BLOCK_ALL_BUT_OUTGOING_HTTP) \
1045 P2P_TEST(x, PROXY_HTTPS) \
1046 P2P_TEST(x, PROXY_SOCKS)
1047
1048 #define FLAKY_P2P_TEST_SET(x) \
1049 P2P_TEST(x, OPEN) \
1050 P2P_TEST(x, NAT_FULL_CONE) \
1051 P2P_TEST(x, NAT_ADDR_RESTRICTED) \
1052 P2P_TEST(x, NAT_PORT_RESTRICTED) \
1053 P2P_TEST(x, NAT_SYMMETRIC) \
1054 P2P_TEST(x, NAT_DOUBLE_CONE) \
1055 P2P_TEST(x, NAT_SYMMETRIC_THEN_CONE) \
1056 P2P_TEST(x, BLOCK_UDP) \
1057 P2P_TEST(x, BLOCK_UDP_AND_INCOMING_TCP) \
1058 P2P_TEST(x, BLOCK_ALL_BUT_OUTGOING_HTTP) \
1059 P2P_TEST(x, PROXY_HTTPS) \
1060 P2P_TEST(x, PROXY_SOCKS)
1061
1062 P2P_TEST_SET(OPEN)
P2P_TEST_SET(NAT_FULL_CONE)1063 P2P_TEST_SET(NAT_FULL_CONE)
1064 P2P_TEST_SET(NAT_ADDR_RESTRICTED)
1065 P2P_TEST_SET(NAT_PORT_RESTRICTED)
1066 P2P_TEST_SET(NAT_SYMMETRIC)
1067 P2P_TEST_SET(NAT_DOUBLE_CONE)
1068 P2P_TEST_SET(NAT_SYMMETRIC_THEN_CONE)
1069 P2P_TEST_SET(BLOCK_UDP)
1070 P2P_TEST_SET(BLOCK_UDP_AND_INCOMING_TCP)
1071 P2P_TEST_SET(BLOCK_ALL_BUT_OUTGOING_HTTP)
1072 P2P_TEST_SET(PROXY_HTTPS)
1073 P2P_TEST_SET(PROXY_SOCKS)
1074
1075 // Test that we restart candidate allocation when local ufrag&pwd changed.
1076 // Standard Ice protocol is used.
1077 TEST_F(P2PTransportChannelTest, HandleUfragPwdChangeAsIce) {
1078 ConfigureEndpoints(OPEN, OPEN,
1079 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1080 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1081 kMinimumStepDelay, kMinimumStepDelay,
1082 cricket::ICEPROTO_RFC5245);
1083 CreateChannels(1);
1084 TestHandleIceUfragPasswordChanged();
1085 }
1086
1087 // Test that we restart candidate allocation when local ufrag&pwd changed.
1088 // Standard Ice protocol is used.
TEST_F(P2PTransportChannelTest,HandleUfragPwdChangeBundleAsIce)1089 TEST_F(P2PTransportChannelTest, HandleUfragPwdChangeBundleAsIce) {
1090 ConfigureEndpoints(OPEN, OPEN,
1091 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1092 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1093 kMinimumStepDelay, kMinimumStepDelay,
1094 cricket::ICEPROTO_RFC5245);
1095 SetAllocatorFlags(0, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1096 SetAllocatorFlags(1, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1097
1098 CreateChannels(2);
1099 TestHandleIceUfragPasswordChanged();
1100 }
1101
1102 // Test that we restart candidate allocation when local ufrag&pwd changed.
1103 // Google Ice protocol is used.
TEST_F(P2PTransportChannelTest,HandleUfragPwdChangeAsGice)1104 TEST_F(P2PTransportChannelTest, HandleUfragPwdChangeAsGice) {
1105 ConfigureEndpoints(OPEN, OPEN,
1106 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1107 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1108 kDefaultStepDelay, kDefaultStepDelay,
1109 cricket::ICEPROTO_GOOGLE);
1110 CreateChannels(1);
1111 TestHandleIceUfragPasswordChanged();
1112 }
1113
1114 // Test that ICE restart works when bundle is enabled.
1115 // Google Ice protocol is used.
TEST_F(P2PTransportChannelTest,HandleUfragPwdChangeBundleAsGice)1116 TEST_F(P2PTransportChannelTest, HandleUfragPwdChangeBundleAsGice) {
1117 ConfigureEndpoints(OPEN, OPEN,
1118 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1119 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1120 kDefaultStepDelay, kDefaultStepDelay,
1121 cricket::ICEPROTO_GOOGLE);
1122 SetAllocatorFlags(0, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1123 SetAllocatorFlags(1, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1124
1125 CreateChannels(2);
1126 TestHandleIceUfragPasswordChanged();
1127 }
1128
1129 // Test the operation of GetStats.
TEST_F(P2PTransportChannelTest,GetStats)1130 TEST_F(P2PTransportChannelTest, GetStats) {
1131 ConfigureEndpoints(OPEN, OPEN,
1132 kDefaultPortAllocatorFlags,
1133 kDefaultPortAllocatorFlags,
1134 kDefaultStepDelay, kDefaultStepDelay,
1135 cricket::ICEPROTO_GOOGLE);
1136 CreateChannels(1);
1137 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1()->readable() && ep1_ch1()->writable() &&
1138 ep2_ch1()->readable() && ep2_ch1()->writable(),
1139 1000, 1000);
1140 TestSendRecv(1);
1141 cricket::ConnectionInfos infos;
1142 ASSERT_TRUE(ep1_ch1()->GetStats(&infos));
1143 ASSERT_EQ(1U, infos.size());
1144 EXPECT_TRUE(infos[0].new_connection);
1145 EXPECT_TRUE(infos[0].best_connection);
1146 EXPECT_TRUE(infos[0].readable);
1147 EXPECT_TRUE(infos[0].writable);
1148 EXPECT_FALSE(infos[0].timeout);
1149 EXPECT_EQ(10 * 36U, infos[0].sent_total_bytes);
1150 EXPECT_EQ(10 * 36U, infos[0].recv_total_bytes);
1151 EXPECT_GT(infos[0].rtt, 0U);
1152 DestroyChannels();
1153 }
1154
1155 // Test that we properly handle getting a STUN error due to slow signaling.
TEST_F(P2PTransportChannelTest,DISABLED_SlowSignaling)1156 TEST_F(P2PTransportChannelTest, DISABLED_SlowSignaling) {
1157 ConfigureEndpoints(OPEN, NAT_SYMMETRIC,
1158 kDefaultPortAllocatorFlags,
1159 kDefaultPortAllocatorFlags,
1160 kDefaultStepDelay, kDefaultStepDelay,
1161 cricket::ICEPROTO_GOOGLE);
1162 // Make signaling from the callee take 500ms, so that the initial STUN pings
1163 // from the callee beat the signaling, and so the caller responds with a
1164 // unknown username error. We should just eat that and carry on; mishandling
1165 // this will instead cause all the callee's connections to be discarded.
1166 SetSignalingDelay(1, 1000);
1167 CreateChannels(1);
1168 const cricket::Connection* best_connection = NULL;
1169 // Wait until the callee's connections are created.
1170 WAIT((best_connection = ep2_ch1()->best_connection()) != NULL, 1000);
1171 // Wait to see if they get culled; they shouldn't.
1172 WAIT(ep2_ch1()->best_connection() != best_connection, 1000);
1173 EXPECT_TRUE(ep2_ch1()->best_connection() == best_connection);
1174 DestroyChannels();
1175 }
1176
1177 // Test that if remote candidates don't have ufrag and pwd, we still work.
TEST_F(P2PTransportChannelTest,RemoteCandidatesWithoutUfragPwd)1178 TEST_F(P2PTransportChannelTest, RemoteCandidatesWithoutUfragPwd) {
1179 set_clear_remote_candidates_ufrag_pwd(true);
1180 ConfigureEndpoints(OPEN, OPEN,
1181 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1182 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1183 kMinimumStepDelay, kMinimumStepDelay,
1184 cricket::ICEPROTO_GOOGLE);
1185 CreateChannels(1);
1186 const cricket::Connection* best_connection = NULL;
1187 // Wait until the callee's connections are created.
1188 WAIT((best_connection = ep2_ch1()->best_connection()) != NULL, 1000);
1189 // Wait to see if they get culled; they shouldn't.
1190 WAIT(ep2_ch1()->best_connection() != best_connection, 1000);
1191 EXPECT_TRUE(ep2_ch1()->best_connection() == best_connection);
1192 DestroyChannels();
1193 }
1194
1195 // Test that a host behind NAT cannot be reached when incoming_only
1196 // is set to true.
TEST_F(P2PTransportChannelTest,IncomingOnlyBlocked)1197 TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) {
1198 ConfigureEndpoints(NAT_FULL_CONE, OPEN,
1199 kDefaultPortAllocatorFlags,
1200 kDefaultPortAllocatorFlags,
1201 kDefaultStepDelay, kDefaultStepDelay,
1202 cricket::ICEPROTO_GOOGLE);
1203
1204 SetAllocatorFlags(0, kOnlyLocalPorts);
1205 CreateChannels(1);
1206 ep1_ch1()->set_incoming_only(true);
1207
1208 // Pump for 1 second and verify that the channels are not connected.
1209 talk_base::Thread::Current()->ProcessMessages(1000);
1210
1211 EXPECT_FALSE(ep1_ch1()->readable());
1212 EXPECT_FALSE(ep1_ch1()->writable());
1213 EXPECT_FALSE(ep2_ch1()->readable());
1214 EXPECT_FALSE(ep2_ch1()->writable());
1215
1216 DestroyChannels();
1217 }
1218
1219 // Test that a peer behind NAT can connect to a peer that has
1220 // incoming_only flag set.
TEST_F(P2PTransportChannelTest,IncomingOnlyOpen)1221 TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) {
1222 ConfigureEndpoints(OPEN, NAT_FULL_CONE,
1223 kDefaultPortAllocatorFlags,
1224 kDefaultPortAllocatorFlags,
1225 kDefaultStepDelay, kDefaultStepDelay,
1226 cricket::ICEPROTO_GOOGLE);
1227
1228 SetAllocatorFlags(0, kOnlyLocalPorts);
1229 CreateChannels(1);
1230 ep1_ch1()->set_incoming_only(true);
1231
1232 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL && ep2_ch1() != NULL &&
1233 ep1_ch1()->readable() && ep1_ch1()->writable() &&
1234 ep2_ch1()->readable() && ep2_ch1()->writable(),
1235 1000, 1000);
1236
1237 DestroyChannels();
1238 }
1239
TEST_F(P2PTransportChannelTest,TestTcpConnectionsFromActiveToPassive)1240 TEST_F(P2PTransportChannelTest, TestTcpConnectionsFromActiveToPassive) {
1241 AddAddress(0, kPublicAddrs[0]);
1242 AddAddress(1, kPublicAddrs[1]);
1243
1244 SetAllocationStepDelay(0, kMinimumStepDelay);
1245 SetAllocationStepDelay(1, kMinimumStepDelay);
1246
1247 int kOnlyLocalTcpPorts = cricket::PORTALLOCATOR_DISABLE_UDP |
1248 cricket::PORTALLOCATOR_DISABLE_STUN |
1249 cricket::PORTALLOCATOR_DISABLE_RELAY |
1250 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG;
1251 // Disable all protocols except TCP.
1252 SetAllocatorFlags(0, kOnlyLocalTcpPorts);
1253 SetAllocatorFlags(1, kOnlyLocalTcpPorts);
1254
1255 SetAllowTcpListen(0, true); // actpass.
1256 SetAllowTcpListen(1, false); // active.
1257
1258 CreateChannels(1);
1259
1260 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() &&
1261 ep2_ch1()->readable() && ep2_ch1()->writable(),
1262 1000);
1263 EXPECT_TRUE(
1264 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1265 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1266 RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
1267
1268 std::string kTcpProtocol = "tcp";
1269 EXPECT_EQ(kTcpProtocol, RemoteCandidate(ep1_ch1())->protocol());
1270 EXPECT_EQ(kTcpProtocol, LocalCandidate(ep1_ch1())->protocol());
1271 EXPECT_EQ(kTcpProtocol, RemoteCandidate(ep2_ch1())->protocol());
1272 EXPECT_EQ(kTcpProtocol, LocalCandidate(ep2_ch1())->protocol());
1273
1274 TestSendRecv(1);
1275 DestroyChannels();
1276 }
1277
TEST_F(P2PTransportChannelTest,TestBundleAllocatorToBundleAllocator)1278 TEST_F(P2PTransportChannelTest, TestBundleAllocatorToBundleAllocator) {
1279 AddAddress(0, kPublicAddrs[0]);
1280 AddAddress(1, kPublicAddrs[1]);
1281 SetAllocatorFlags(0, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1282 SetAllocatorFlags(1, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1283
1284 CreateChannels(2);
1285
1286 EXPECT_TRUE_WAIT(ep1_ch1()->readable() &&
1287 ep1_ch1()->writable() &&
1288 ep2_ch1()->readable() &&
1289 ep2_ch1()->writable(),
1290 1000);
1291 EXPECT_TRUE(ep1_ch1()->best_connection() &&
1292 ep2_ch1()->best_connection());
1293
1294 EXPECT_FALSE(ep1_ch2()->readable());
1295 EXPECT_FALSE(ep1_ch2()->writable());
1296 EXPECT_FALSE(ep2_ch2()->readable());
1297 EXPECT_FALSE(ep2_ch2()->writable());
1298
1299 TestSendRecv(1); // Only 1 channel is writable per Endpoint.
1300 DestroyChannels();
1301 }
1302
TEST_F(P2PTransportChannelTest,TestBundleAllocatorToNonBundleAllocator)1303 TEST_F(P2PTransportChannelTest, TestBundleAllocatorToNonBundleAllocator) {
1304 AddAddress(0, kPublicAddrs[0]);
1305 AddAddress(1, kPublicAddrs[1]);
1306 // Enable BUNDLE flag at one side.
1307 SetAllocatorFlags(0, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1308
1309 CreateChannels(2);
1310
1311 EXPECT_TRUE_WAIT(ep1_ch1()->readable() &&
1312 ep1_ch1()->writable() &&
1313 ep2_ch1()->readable() &&
1314 ep2_ch1()->writable(),
1315 1000);
1316 EXPECT_TRUE_WAIT(ep1_ch2()->readable() &&
1317 ep1_ch2()->writable() &&
1318 ep2_ch2()->readable() &&
1319 ep2_ch2()->writable(),
1320 1000);
1321
1322 EXPECT_TRUE(ep1_ch1()->best_connection() &&
1323 ep2_ch1()->best_connection());
1324 EXPECT_TRUE(ep1_ch2()->best_connection() &&
1325 ep2_ch2()->best_connection());
1326
1327 TestSendRecv(2);
1328 DestroyChannels();
1329 }
1330
TEST_F(P2PTransportChannelTest,TestIceRoleConflictWithoutBundle)1331 TEST_F(P2PTransportChannelTest, TestIceRoleConflictWithoutBundle) {
1332 AddAddress(0, kPublicAddrs[0]);
1333 AddAddress(1, kPublicAddrs[1]);
1334 TestSignalRoleConflict();
1335 }
1336
TEST_F(P2PTransportChannelTest,TestIceRoleConflictWithBundle)1337 TEST_F(P2PTransportChannelTest, TestIceRoleConflictWithBundle) {
1338 AddAddress(0, kPublicAddrs[0]);
1339 AddAddress(1, kPublicAddrs[1]);
1340 SetAllocatorFlags(0, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1341 SetAllocatorFlags(1, cricket::PORTALLOCATOR_ENABLE_BUNDLE);
1342 TestSignalRoleConflict();
1343 }
1344
1345 // Tests that the ice configs (protocol, tiebreaker and role) can be passed
1346 // down to ports.
TEST_F(P2PTransportChannelTest,TestIceConfigWillPassDownToPort)1347 TEST_F(P2PTransportChannelTest, TestIceConfigWillPassDownToPort) {
1348 AddAddress(0, kPublicAddrs[0]);
1349 AddAddress(1, kPublicAddrs[1]);
1350
1351 SetIceRole(0, cricket::ICEROLE_CONTROLLING);
1352 SetIceProtocol(0, cricket::ICEPROTO_GOOGLE);
1353 SetIceTiebreaker(0, kTiebreaker1);
1354 SetIceRole(1, cricket::ICEROLE_CONTROLLING);
1355 SetIceProtocol(1, cricket::ICEPROTO_RFC5245);
1356 SetIceTiebreaker(1, kTiebreaker2);
1357
1358 CreateChannels(1);
1359
1360 EXPECT_EQ_WAIT(2u, ep1_ch1()->ports().size(), 1000);
1361
1362 const std::vector<cricket::PortInterface *> ports_before = ep1_ch1()->ports();
1363 for (size_t i = 0; i < ports_before.size(); ++i) {
1364 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, ports_before[i]->GetIceRole());
1365 EXPECT_EQ(cricket::ICEPROTO_GOOGLE, ports_before[i]->IceProtocol());
1366 EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker());
1367 }
1368
1369 ep1_ch1()->SetIceRole(cricket::ICEROLE_CONTROLLED);
1370 ep1_ch1()->SetIceProtocolType(cricket::ICEPROTO_RFC5245);
1371 ep1_ch1()->SetIceTiebreaker(kTiebreaker2);
1372
1373 const std::vector<cricket::PortInterface *> ports_after = ep1_ch1()->ports();
1374 for (size_t i = 0; i < ports_after.size(); ++i) {
1375 EXPECT_EQ(cricket::ICEROLE_CONTROLLED, ports_before[i]->GetIceRole());
1376 EXPECT_EQ(cricket::ICEPROTO_RFC5245, ports_before[i]->IceProtocol());
1377 // SetIceTiebreaker after Connect() has been called will fail. So expect the
1378 // original value.
1379 EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker());
1380 }
1381
1382 EXPECT_TRUE_WAIT(ep1_ch1()->readable() &&
1383 ep1_ch1()->writable() &&
1384 ep2_ch1()->readable() &&
1385 ep2_ch1()->writable(),
1386 1000);
1387
1388 EXPECT_TRUE(ep1_ch1()->best_connection() &&
1389 ep2_ch1()->best_connection());
1390
1391 TestSendRecv(1);
1392 }
1393
1394 // Verify that we can set DSCP value and retrieve properly from P2PTC.
TEST_F(P2PTransportChannelTest,TestDefaultDscpValue)1395 TEST_F(P2PTransportChannelTest, TestDefaultDscpValue) {
1396 AddAddress(0, kPublicAddrs[0]);
1397 AddAddress(1, kPublicAddrs[1]);
1398
1399 CreateChannels(1);
1400 EXPECT_EQ(talk_base::DSCP_NO_CHANGE,
1401 GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
1402 EXPECT_EQ(talk_base::DSCP_NO_CHANGE,
1403 GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
1404 GetEndpoint(0)->cd1_.ch_->SetOption(
1405 talk_base::Socket::OPT_DSCP, talk_base::DSCP_CS6);
1406 GetEndpoint(1)->cd1_.ch_->SetOption(
1407 talk_base::Socket::OPT_DSCP, talk_base::DSCP_CS6);
1408 EXPECT_EQ(talk_base::DSCP_CS6,
1409 GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
1410 EXPECT_EQ(talk_base::DSCP_CS6,
1411 GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
1412 GetEndpoint(0)->cd1_.ch_->SetOption(
1413 talk_base::Socket::OPT_DSCP, talk_base::DSCP_AF41);
1414 GetEndpoint(1)->cd1_.ch_->SetOption(
1415 talk_base::Socket::OPT_DSCP, talk_base::DSCP_AF41);
1416 EXPECT_EQ(talk_base::DSCP_AF41,
1417 GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
1418 EXPECT_EQ(talk_base::DSCP_AF41,
1419 GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
1420 }
1421
1422 // Verify IPv6 connection is preferred over IPv4.
TEST_F(P2PTransportChannelTest,TestIPv6Connections)1423 TEST_F(P2PTransportChannelTest, TestIPv6Connections) {
1424 AddAddress(0, kIPv6PublicAddrs[0]);
1425 AddAddress(0, kPublicAddrs[0]);
1426 AddAddress(1, kIPv6PublicAddrs[1]);
1427 AddAddress(1, kPublicAddrs[1]);
1428
1429 SetAllocationStepDelay(0, kMinimumStepDelay);
1430 SetAllocationStepDelay(1, kMinimumStepDelay);
1431
1432 // Enable IPv6
1433 SetAllocatorFlags(0, cricket::PORTALLOCATOR_ENABLE_IPV6);
1434 SetAllocatorFlags(1, cricket::PORTALLOCATOR_ENABLE_IPV6);
1435
1436 CreateChannels(1);
1437
1438 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() &&
1439 ep2_ch1()->readable() && ep2_ch1()->writable(),
1440 1000);
1441 EXPECT_TRUE(
1442 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1443 LocalCandidate(ep1_ch1())->address().EqualIPs(kIPv6PublicAddrs[0]) &&
1444 RemoteCandidate(ep1_ch1())->address().EqualIPs(kIPv6PublicAddrs[1]));
1445
1446 TestSendRecv(1);
1447 DestroyChannels();
1448 }
1449
1450 // Test what happens when we have 2 users behind the same NAT. This can lead
1451 // to interesting behavior because the STUN server will only give out the
1452 // address of the outermost NAT.
1453 class P2PTransportChannelSameNatTest : public P2PTransportChannelTestBase {
1454 protected:
ConfigureEndpoints(Config nat_type,Config config1,Config config2)1455 void ConfigureEndpoints(Config nat_type, Config config1, Config config2) {
1456 ASSERT(nat_type >= NAT_FULL_CONE && nat_type <= NAT_SYMMETRIC);
1457 talk_base::NATSocketServer::Translator* outer_nat =
1458 nat()->AddTranslator(kPublicAddrs[0], kNatAddrs[0],
1459 static_cast<talk_base::NATType>(nat_type - NAT_FULL_CONE));
1460 ConfigureEndpoint(outer_nat, 0, config1);
1461 ConfigureEndpoint(outer_nat, 1, config2);
1462 }
ConfigureEndpoint(talk_base::NATSocketServer::Translator * nat,int endpoint,Config config)1463 void ConfigureEndpoint(talk_base::NATSocketServer::Translator* nat,
1464 int endpoint, Config config) {
1465 ASSERT(config <= NAT_SYMMETRIC);
1466 if (config == OPEN) {
1467 AddAddress(endpoint, kPrivateAddrs[endpoint]);
1468 nat->AddClient(kPrivateAddrs[endpoint]);
1469 } else {
1470 AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
1471 nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
1472 static_cast<talk_base::NATType>(config - NAT_FULL_CONE))->AddClient(
1473 kCascadedPrivateAddrs[endpoint]);
1474 }
1475 }
1476 };
1477
TEST_F(P2PTransportChannelSameNatTest,TestConesBehindSameCone)1478 TEST_F(P2PTransportChannelSameNatTest, TestConesBehindSameCone) {
1479 ConfigureEndpoints(NAT_FULL_CONE, NAT_FULL_CONE, NAT_FULL_CONE);
1480 Test(kLocalUdpToStunUdp);
1481 }
1482
1483 // Test what happens when we have multiple available pathways.
1484 // In the future we will try different RTTs and configs for the different
1485 // interfaces, so that we can simulate a user with Ethernet and VPN networks.
1486 class P2PTransportChannelMultihomedTest : public P2PTransportChannelTestBase {
1487 };
1488
1489 // Test that we can establish connectivity when both peers are multihomed.
TEST_F(P2PTransportChannelMultihomedTest,DISABLED_TestBasic)1490 TEST_F(P2PTransportChannelMultihomedTest, DISABLED_TestBasic) {
1491 AddAddress(0, kPublicAddrs[0]);
1492 AddAddress(0, kAlternateAddrs[0]);
1493 AddAddress(1, kPublicAddrs[1]);
1494 AddAddress(1, kAlternateAddrs[1]);
1495 Test(kLocalUdpToLocalUdp);
1496 }
1497
1498 // Test that we can quickly switch links if an interface goes down.
TEST_F(P2PTransportChannelMultihomedTest,TestFailover)1499 TEST_F(P2PTransportChannelMultihomedTest, TestFailover) {
1500 AddAddress(0, kPublicAddrs[0]);
1501 AddAddress(1, kPublicAddrs[1]);
1502 AddAddress(1, kAlternateAddrs[1]);
1503 // Use only local ports for simplicity.
1504 SetAllocatorFlags(0, kOnlyLocalPorts);
1505 SetAllocatorFlags(1, kOnlyLocalPorts);
1506
1507 // Create channels and let them go writable, as usual.
1508 CreateChannels(1);
1509 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() &&
1510 ep2_ch1()->readable() && ep2_ch1()->writable(),
1511 1000);
1512 EXPECT_TRUE(
1513 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1514 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1515 RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
1516
1517 // Blackhole any traffic to or from the public addrs.
1518 LOG(LS_INFO) << "Failing over...";
1519 fw()->AddRule(false, talk_base::FP_ANY, talk_base::FD_ANY,
1520 kPublicAddrs[1]);
1521
1522 // We should detect loss of connectivity within 5 seconds or so.
1523 EXPECT_TRUE_WAIT(!ep1_ch1()->writable(), 7000);
1524
1525 // We should switch over to use the alternate addr immediately
1526 // when we lose writability.
1527 EXPECT_TRUE_WAIT(
1528 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1529 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1530 RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]),
1531 3000);
1532
1533 DestroyChannels();
1534 }
1535
1536 // Test that we can switch links in a coordinated fashion.
TEST_F(P2PTransportChannelMultihomedTest,TestDrain)1537 TEST_F(P2PTransportChannelMultihomedTest, TestDrain) {
1538 AddAddress(0, kPublicAddrs[0]);
1539 AddAddress(1, kPublicAddrs[1]);
1540 // Use only local ports for simplicity.
1541 SetAllocatorFlags(0, kOnlyLocalPorts);
1542 SetAllocatorFlags(1, kOnlyLocalPorts);
1543
1544 // Create channels and let them go writable, as usual.
1545 CreateChannels(1);
1546 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() &&
1547 ep2_ch1()->readable() && ep2_ch1()->writable(),
1548 1000);
1549 EXPECT_TRUE(
1550 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1551 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1552 RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
1553
1554 // Remove the public interface, add the alternate interface, and allocate
1555 // a new generation of candidates for the new interface (via Connect()).
1556 LOG(LS_INFO) << "Draining...";
1557 AddAddress(1, kAlternateAddrs[1]);
1558 RemoveAddress(1, kPublicAddrs[1]);
1559 ep2_ch1()->Connect();
1560
1561 // We should switch over to use the alternate address after
1562 // an exchange of pings.
1563 EXPECT_TRUE_WAIT(
1564 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1565 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1566 RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]),
1567 3000);
1568
1569 DestroyChannels();
1570 }
1571