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/base/network.h"
12
13 #include <vector>
14 #if defined(WEBRTC_POSIX)
15 #include <sys/types.h>
16 #if !defined(WEBRTC_ANDROID)
17 #include <ifaddrs.h>
18 #else
19 #include "webrtc/base/ifaddrs-android.h"
20 #endif
21 #endif
22 #include "webrtc/base/gunit.h"
23 #if defined(WEBRTC_WIN)
24 #include "webrtc/base/logging.h" // For LOG_GLE
25 #endif
26
27 namespace rtc {
28
29 class NetworkTest : public testing::Test, public sigslot::has_slots<> {
30 public:
NetworkTest()31 NetworkTest() : callback_called_(false) {}
32
OnNetworksChanged()33 void OnNetworksChanged() {
34 callback_called_ = true;
35 }
36
MergeNetworkList(BasicNetworkManager & network_manager,const NetworkManager::NetworkList & list,bool * changed)37 NetworkManager::Stats MergeNetworkList(
38 BasicNetworkManager& network_manager,
39 const NetworkManager::NetworkList& list,
40 bool* changed) {
41 NetworkManager::Stats stats;
42 network_manager.MergeNetworkList(list, changed, &stats);
43 return stats;
44 }
45
IsIgnoredNetwork(BasicNetworkManager & network_manager,const Network & network)46 bool IsIgnoredNetwork(BasicNetworkManager& network_manager,
47 const Network& network) {
48 return network_manager.IsIgnoredNetwork(network);
49 }
50
GetNetworks(const BasicNetworkManager & network_manager,bool include_ignored)51 NetworkManager::NetworkList GetNetworks(
52 const BasicNetworkManager& network_manager, bool include_ignored) {
53 NetworkManager::NetworkList list;
54 network_manager.CreateNetworks(include_ignored, &list);
55 return list;
56 }
57
58 #if defined(WEBRTC_POSIX)
59 // Separated from CreateNetworks for tests.
CallConvertIfAddrs(const BasicNetworkManager & network_manager,struct ifaddrs * interfaces,bool include_ignored,NetworkManager::NetworkList * networks)60 static void CallConvertIfAddrs(const BasicNetworkManager& network_manager,
61 struct ifaddrs* interfaces,
62 bool include_ignored,
63 NetworkManager::NetworkList* networks) {
64 network_manager.ConvertIfAddrs(interfaces, include_ignored, networks);
65 }
66 #endif // defined(WEBRTC_POSIX)
67
68 protected:
69 bool callback_called_;
70 };
71
72 // Test that the Network ctor works properly.
TEST_F(NetworkTest,TestNetworkConstruct)73 TEST_F(NetworkTest, TestNetworkConstruct) {
74 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
75 IPAddress(0x12345600U), 24);
76 EXPECT_EQ("test_eth0", ipv4_network1.name());
77 EXPECT_EQ("Test Network Adapter 1", ipv4_network1.description());
78 EXPECT_EQ(IPAddress(0x12345600U), ipv4_network1.prefix());
79 EXPECT_EQ(24, ipv4_network1.prefix_length());
80 EXPECT_FALSE(ipv4_network1.ignored());
81 }
82
83 // Tests that our ignore function works properly.
TEST_F(NetworkTest,TestIsIgnoredNetworkIgnoresOnlyLoopbackByDefault)84 TEST_F(NetworkTest, TestIsIgnoredNetworkIgnoresOnlyLoopbackByDefault) {
85 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
86 IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET);
87 Network ipv4_network2("test_wlan0", "Test Network Adapter 2",
88 IPAddress(0x12345601U), 16, ADAPTER_TYPE_WIFI);
89 Network ipv4_network3("test_cell0", "Test Network Adapter 3",
90 IPAddress(0x12345602U), 16, ADAPTER_TYPE_CELLULAR);
91 Network ipv4_network4("test_vpn0", "Test Network Adapter 4",
92 IPAddress(0x12345603U), 16, ADAPTER_TYPE_VPN);
93 Network ipv4_network5("test_lo", "Test Network Adapter 5",
94 IPAddress(0x12345604U), 16, ADAPTER_TYPE_LOOPBACK);
95 BasicNetworkManager network_manager;
96 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1));
97 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network2));
98 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network3));
99 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network4));
100 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network5));
101 }
102
TEST_F(NetworkTest,TestIsIgnoredNetworkIgnoresIPsStartingWith0)103 TEST_F(NetworkTest, TestIsIgnoredNetworkIgnoresIPsStartingWith0) {
104 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
105 IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET);
106 Network ipv4_network2("test_eth1", "Test Network Adapter 2",
107 IPAddress(0x010000U), 24, ADAPTER_TYPE_ETHERNET);
108 BasicNetworkManager network_manager;
109 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1));
110 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network2));
111 }
112
TEST_F(NetworkTest,TestIsIgnoredNetworkIgnoresNetworksAccordingToIgnoreMask)113 TEST_F(NetworkTest, TestIsIgnoredNetworkIgnoresNetworksAccordingToIgnoreMask) {
114 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
115 IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET);
116 Network ipv4_network2("test_wlan0", "Test Network Adapter 2",
117 IPAddress(0x12345601U), 16, ADAPTER_TYPE_WIFI);
118 Network ipv4_network3("test_cell0", "Test Network Adapter 3",
119 IPAddress(0x12345602U), 16, ADAPTER_TYPE_CELLULAR);
120 BasicNetworkManager network_manager;
121 network_manager.set_network_ignore_mask(
122 ADAPTER_TYPE_ETHERNET | ADAPTER_TYPE_LOOPBACK | ADAPTER_TYPE_WIFI);
123 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network1));
124 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network2));
125 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network3));
126 }
127
128 // TODO(phoglund): Remove when ignore list goes away.
TEST_F(NetworkTest,TestIgnoreList)129 TEST_F(NetworkTest, TestIgnoreList) {
130 Network ignore_me("ignore_me", "Ignore me please!",
131 IPAddress(0x12345600U), 24);
132 Network include_me("include_me", "Include me please!",
133 IPAddress(0x12345600U), 24);
134 BasicNetworkManager network_manager;
135 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ignore_me));
136 EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me));
137 std::vector<std::string> ignore_list;
138 ignore_list.push_back("ignore_me");
139 network_manager.set_network_ignore_list(ignore_list);
140 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ignore_me));
141 EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me));
142 }
143
144 // Test is failing on Windows opt: b/11288214
TEST_F(NetworkTest,DISABLED_TestCreateNetworks)145 TEST_F(NetworkTest, DISABLED_TestCreateNetworks) {
146 BasicNetworkManager manager;
147 NetworkManager::NetworkList result = GetNetworks(manager, true);
148 // We should be able to bind to any addresses we find.
149 NetworkManager::NetworkList::iterator it;
150 for (it = result.begin();
151 it != result.end();
152 ++it) {
153 sockaddr_storage storage;
154 memset(&storage, 0, sizeof(storage));
155 IPAddress ip = (*it)->GetBestIP();
156 SocketAddress bindaddress(ip, 0);
157 bindaddress.SetScopeID((*it)->scope_id());
158 // TODO(thaloun): Use rtc::AsyncSocket once it supports IPv6.
159 int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
160 if (fd > 0) {
161 size_t ipsize = bindaddress.ToSockAddrStorage(&storage);
162 EXPECT_GE(ipsize, 0U);
163 int success = ::bind(fd,
164 reinterpret_cast<sockaddr*>(&storage),
165 static_cast<int>(ipsize));
166 #if defined(WEBRTC_WIN)
167 if (success) LOG_GLE(LS_ERROR) << "Socket bind failed.";
168 #endif
169 EXPECT_EQ(0, success);
170 #if defined(WEBRTC_WIN)
171 closesocket(fd);
172 #else
173 close(fd);
174 #endif
175 }
176 delete (*it);
177 }
178 }
179
180 // Test that UpdateNetworks succeeds.
TEST_F(NetworkTest,TestUpdateNetworks)181 TEST_F(NetworkTest, TestUpdateNetworks) {
182 BasicNetworkManager manager;
183 manager.SignalNetworksChanged.connect(
184 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
185 manager.StartUpdating();
186 Thread::Current()->ProcessMessages(0);
187 EXPECT_TRUE(callback_called_);
188 callback_called_ = false;
189 // Callback should be triggered immediately when StartUpdating
190 // is called, after network update signal is already sent.
191 manager.StartUpdating();
192 EXPECT_TRUE(manager.started());
193 Thread::Current()->ProcessMessages(0);
194 EXPECT_TRUE(callback_called_);
195 manager.StopUpdating();
196 EXPECT_TRUE(manager.started());
197 manager.StopUpdating();
198 EXPECT_FALSE(manager.started());
199 manager.StopUpdating();
200 EXPECT_FALSE(manager.started());
201 callback_called_ = false;
202 // Callback should be triggered immediately after StartUpdating is called
203 // when start_count_ is reset to 0.
204 manager.StartUpdating();
205 Thread::Current()->ProcessMessages(0);
206 EXPECT_TRUE(callback_called_);
207 }
208
209 // Verify that MergeNetworkList() merges network lists properly.
TEST_F(NetworkTest,TestBasicMergeNetworkList)210 TEST_F(NetworkTest, TestBasicMergeNetworkList) {
211 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
212 IPAddress(0x12345600U), 24);
213 Network ipv4_network2("test_eth1", "Test Network Adapter 2",
214 IPAddress(0x00010000U), 16);
215 ipv4_network1.AddIP(IPAddress(0x12345678));
216 ipv4_network2.AddIP(IPAddress(0x00010004));
217 BasicNetworkManager manager;
218
219 // Add ipv4_network1 to the list of networks.
220 NetworkManager::NetworkList list;
221 list.push_back(new Network(ipv4_network1));
222 bool changed;
223 NetworkManager::Stats stats = MergeNetworkList(manager, list, &changed);
224 EXPECT_TRUE(changed);
225 EXPECT_EQ(stats.ipv6_network_count, 0);
226 EXPECT_EQ(stats.ipv4_network_count, 1);
227 list.clear();
228
229 manager.GetNetworks(&list);
230 EXPECT_EQ(1U, list.size());
231 EXPECT_EQ(ipv4_network1.ToString(), list[0]->ToString());
232 Network* net1 = list[0];
233 list.clear();
234
235 // Replace ipv4_network1 with ipv4_network2.
236 list.push_back(new Network(ipv4_network2));
237 stats = MergeNetworkList(manager, list, &changed);
238 EXPECT_TRUE(changed);
239 EXPECT_EQ(stats.ipv6_network_count, 0);
240 EXPECT_EQ(stats.ipv4_network_count, 1);
241 list.clear();
242
243 manager.GetNetworks(&list);
244 EXPECT_EQ(1U, list.size());
245 EXPECT_EQ(ipv4_network2.ToString(), list[0]->ToString());
246 Network* net2 = list[0];
247 list.clear();
248
249 // Add Network2 back.
250 list.push_back(new Network(ipv4_network1));
251 list.push_back(new Network(ipv4_network2));
252 stats = MergeNetworkList(manager, list, &changed);
253 EXPECT_TRUE(changed);
254 EXPECT_EQ(stats.ipv6_network_count, 0);
255 EXPECT_EQ(stats.ipv4_network_count, 2);
256 list.clear();
257
258 // Verify that we get previous instances of Network objects.
259 manager.GetNetworks(&list);
260 EXPECT_EQ(2U, list.size());
261 EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
262 (net1 == list[1] && net2 == list[0]));
263 list.clear();
264
265 // Call MergeNetworkList() again and verify that we don't get update
266 // notification.
267 list.push_back(new Network(ipv4_network2));
268 list.push_back(new Network(ipv4_network1));
269 stats = MergeNetworkList(manager, list, &changed);
270 EXPECT_FALSE(changed);
271 EXPECT_EQ(stats.ipv6_network_count, 0);
272 EXPECT_EQ(stats.ipv4_network_count, 2);
273 list.clear();
274
275 // Verify that we get previous instances of Network objects.
276 manager.GetNetworks(&list);
277 EXPECT_EQ(2U, list.size());
278 EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
279 (net1 == list[1] && net2 == list[0]));
280 list.clear();
281 }
282
283 // Sets up some test IPv6 networks and appends them to list.
284 // Four networks are added - public and link local, for two interfaces.
SetupNetworks(NetworkManager::NetworkList * list)285 void SetupNetworks(NetworkManager::NetworkList* list) {
286 IPAddress ip;
287 IPAddress prefix;
288 EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:ef12", &ip));
289 EXPECT_TRUE(IPFromString("abcd::", &prefix));
290 // First, fake link-locals.
291 Network ipv6_eth0_linklocalnetwork("test_eth0", "Test NetworkAdapter 1",
292 prefix, 64);
293 ipv6_eth0_linklocalnetwork.AddIP(ip);
294 EXPECT_TRUE(IPFromString("abcd::5678:abcd:ef12:3456", &ip));
295 Network ipv6_eth1_linklocalnetwork("test_eth1", "Test NetworkAdapter 2",
296 prefix, 64);
297 ipv6_eth1_linklocalnetwork.AddIP(ip);
298 // Public networks:
299 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip));
300 prefix = TruncateIP(ip, 64);
301 Network ipv6_eth0_publicnetwork1_ip1("test_eth0", "Test NetworkAdapter 1",
302 prefix, 64);
303 ipv6_eth0_publicnetwork1_ip1.AddIP(ip);
304 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
305 prefix = TruncateIP(ip, 64);
306 Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 1",
307 prefix, 64);
308 ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
309 list->push_back(new Network(ipv6_eth0_linklocalnetwork));
310 list->push_back(new Network(ipv6_eth1_linklocalnetwork));
311 list->push_back(new Network(ipv6_eth0_publicnetwork1_ip1));
312 list->push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
313 }
314
315 // Test that the basic network merging case works.
TEST_F(NetworkTest,TestIPv6MergeNetworkList)316 TEST_F(NetworkTest, TestIPv6MergeNetworkList) {
317 BasicNetworkManager manager;
318 manager.SignalNetworksChanged.connect(
319 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
320 NetworkManager::NetworkList original_list;
321 SetupNetworks(&original_list);
322 bool changed = false;
323 NetworkManager::Stats stats =
324 MergeNetworkList(manager, original_list, &changed);
325 EXPECT_TRUE(changed);
326 EXPECT_EQ(stats.ipv6_network_count, 4);
327 EXPECT_EQ(stats.ipv4_network_count, 0);
328 NetworkManager::NetworkList list;
329 manager.GetNetworks(&list);
330 EXPECT_EQ(original_list.size(), list.size());
331 // Verify that the original members are in the merged list.
332 for (NetworkManager::NetworkList::iterator it = original_list.begin();
333 it != original_list.end(); ++it) {
334 EXPECT_NE(list.end(), std::find(list.begin(), list.end(), *it));
335 }
336 }
337
338 // Test that no more than manager.max_ipv6_networks() IPv6 networks get
339 // returned.
TEST_F(NetworkTest,TestIPv6MergeNetworkListTrimExcessive)340 TEST_F(NetworkTest, TestIPv6MergeNetworkListTrimExcessive) {
341 BasicNetworkManager manager;
342 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
343 &NetworkTest::OnNetworksChanged);
344 NetworkManager::NetworkList original_list;
345
346 // Add twice the allowed number of IPv6 networks.
347 for (int i = 0; i < 2 * manager.max_ipv6_networks(); i++) {
348 // Make a network with different prefix length.
349 IPAddress ip;
350 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip));
351 IPAddress prefix = TruncateIP(ip, 64 - i);
352 Network* ipv6_network =
353 new Network("test_eth0", "Test Network Adapter 1", prefix, 64 - i);
354 ipv6_network->AddIP(ip);
355 original_list.push_back(ipv6_network);
356 }
357
358 // Add one IPv4 network.
359 Network* ipv4_network = new Network("test_eth0", "Test Network Adapter 1",
360 IPAddress(0x12345600U), 24);
361 ipv4_network->AddIP(IPAddress(0x12345600U));
362 original_list.push_back(ipv4_network);
363
364 bool changed = false;
365 MergeNetworkList(manager, original_list, &changed);
366 EXPECT_TRUE(changed);
367 NetworkManager::NetworkList list;
368 manager.GetNetworks(&list);
369
370 // List size should be the max allowed IPv6 networks plus one IPv4 network.
371 EXPECT_EQ(manager.max_ipv6_networks() + 1, (int)list.size());
372
373 // Verify that the IPv4 network is in the list.
374 EXPECT_NE(list.end(), std::find(list.begin(), list.end(), ipv4_network));
375 }
376
377 // Tests that when two network lists that describe the same set of networks are
378 // merged, that the changed callback is not called, and that the original
379 // objects remain in the result list.
TEST_F(NetworkTest,TestNoChangeMerge)380 TEST_F(NetworkTest, TestNoChangeMerge) {
381 BasicNetworkManager manager;
382 manager.SignalNetworksChanged.connect(
383 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
384 NetworkManager::NetworkList original_list;
385 SetupNetworks(&original_list);
386 bool changed = false;
387 MergeNetworkList(manager, original_list, &changed);
388 EXPECT_TRUE(changed);
389 // Second list that describes the same networks but with new objects.
390 NetworkManager::NetworkList second_list;
391 SetupNetworks(&second_list);
392 changed = false;
393 MergeNetworkList(manager, second_list, &changed);
394 EXPECT_FALSE(changed);
395 NetworkManager::NetworkList resulting_list;
396 manager.GetNetworks(&resulting_list);
397 EXPECT_EQ(original_list.size(), resulting_list.size());
398 // Verify that the original members are in the merged list.
399 for (NetworkManager::NetworkList::iterator it = original_list.begin();
400 it != original_list.end(); ++it) {
401 EXPECT_NE(resulting_list.end(),
402 std::find(resulting_list.begin(), resulting_list.end(), *it));
403 }
404 // Doublecheck that the new networks aren't in the list.
405 for (NetworkManager::NetworkList::iterator it = second_list.begin();
406 it != second_list.end(); ++it) {
407 EXPECT_EQ(resulting_list.end(),
408 std::find(resulting_list.begin(), resulting_list.end(), *it));
409 }
410 }
411
412 // Test that we can merge a network that is the same as another network but with
413 // a different IP. The original network should remain in the list, but have its
414 // IP changed.
TEST_F(NetworkTest,MergeWithChangedIP)415 TEST_F(NetworkTest, MergeWithChangedIP) {
416 BasicNetworkManager manager;
417 manager.SignalNetworksChanged.connect(
418 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
419 NetworkManager::NetworkList original_list;
420 SetupNetworks(&original_list);
421 // Make a network that we're going to change.
422 IPAddress ip;
423 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip));
424 IPAddress prefix = TruncateIP(ip, 64);
425 Network* network_to_change = new Network("test_eth0",
426 "Test Network Adapter 1",
427 prefix, 64);
428 Network* changed_network = new Network(*network_to_change);
429 network_to_change->AddIP(ip);
430 IPAddress changed_ip;
431 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip));
432 changed_network->AddIP(changed_ip);
433 original_list.push_back(network_to_change);
434 bool changed = false;
435 MergeNetworkList(manager, original_list, &changed);
436 NetworkManager::NetworkList second_list;
437 SetupNetworks(&second_list);
438 second_list.push_back(changed_network);
439 changed = false;
440 MergeNetworkList(manager, second_list, &changed);
441 EXPECT_TRUE(changed);
442 NetworkManager::NetworkList list;
443 manager.GetNetworks(&list);
444 EXPECT_EQ(original_list.size(), list.size());
445 // Make sure the original network is still in the merged list.
446 EXPECT_NE(list.end(),
447 std::find(list.begin(), list.end(), network_to_change));
448 EXPECT_EQ(changed_ip, network_to_change->GetIPs().at(0));
449 }
450
451 // Testing a similar case to above, but checking that a network can be updated
452 // with additional IPs (not just a replacement).
TEST_F(NetworkTest,TestMultipleIPMergeNetworkList)453 TEST_F(NetworkTest, TestMultipleIPMergeNetworkList) {
454 BasicNetworkManager manager;
455 manager.SignalNetworksChanged.connect(
456 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
457 NetworkManager::NetworkList original_list;
458 SetupNetworks(&original_list);
459 bool changed = false;
460 MergeNetworkList(manager, original_list, &changed);
461 EXPECT_TRUE(changed);
462 IPAddress ip;
463 IPAddress check_ip;
464 IPAddress prefix;
465 // Add a second IP to the public network on eth0 (2401:fa00:4:1000/64).
466 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip));
467 prefix = TruncateIP(ip, 64);
468 Network ipv6_eth0_publicnetwork1_ip2("test_eth0", "Test NetworkAdapter 1",
469 prefix, 64);
470 // This is the IP that already existed in the public network on eth0.
471 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip));
472 ipv6_eth0_publicnetwork1_ip2.AddIP(ip);
473 original_list.push_back(new Network(ipv6_eth0_publicnetwork1_ip2));
474 changed = false;
475 MergeNetworkList(manager, original_list, &changed);
476 EXPECT_TRUE(changed);
477 // There should still be four networks.
478 NetworkManager::NetworkList list;
479 manager.GetNetworks(&list);
480 EXPECT_EQ(4U, list.size());
481 // Check the gathered IPs.
482 int matchcount = 0;
483 for (NetworkManager::NetworkList::iterator it = list.begin();
484 it != list.end(); ++it) {
485 if ((*it)->ToString() == original_list[2]->ToString()) {
486 ++matchcount;
487 EXPECT_EQ(1, matchcount);
488 // This should be the same network object as before.
489 EXPECT_EQ((*it), original_list[2]);
490 // But with two addresses now.
491 EXPECT_EQ(2U, (*it)->GetIPs().size());
492 EXPECT_NE((*it)->GetIPs().end(),
493 std::find((*it)->GetIPs().begin(),
494 (*it)->GetIPs().end(),
495 check_ip));
496 EXPECT_NE((*it)->GetIPs().end(),
497 std::find((*it)->GetIPs().begin(),
498 (*it)->GetIPs().end(),
499 ip));
500 } else {
501 // Check the IP didn't get added anywhere it wasn't supposed to.
502 EXPECT_EQ((*it)->GetIPs().end(),
503 std::find((*it)->GetIPs().begin(),
504 (*it)->GetIPs().end(),
505 ip));
506 }
507 }
508 }
509
510 // Test that merge correctly distinguishes multiple networks on an interface.
TEST_F(NetworkTest,TestMultiplePublicNetworksOnOneInterfaceMerge)511 TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) {
512 BasicNetworkManager manager;
513 manager.SignalNetworksChanged.connect(
514 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
515 NetworkManager::NetworkList original_list;
516 SetupNetworks(&original_list);
517 bool changed = false;
518 MergeNetworkList(manager, original_list, &changed);
519 EXPECT_TRUE(changed);
520 IPAddress ip;
521 IPAddress prefix;
522 // A second network for eth0.
523 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip));
524 prefix = TruncateIP(ip, 64);
525 Network ipv6_eth0_publicnetwork2_ip1("test_eth0", "Test NetworkAdapter 1",
526 prefix, 64);
527 ipv6_eth0_publicnetwork2_ip1.AddIP(ip);
528 original_list.push_back(new Network(ipv6_eth0_publicnetwork2_ip1));
529 changed = false;
530 MergeNetworkList(manager, original_list, &changed);
531 EXPECT_TRUE(changed);
532 // There should be five networks now.
533 NetworkManager::NetworkList list;
534 manager.GetNetworks(&list);
535 EXPECT_EQ(5U, list.size());
536 // Check the resulting addresses.
537 for (NetworkManager::NetworkList::iterator it = list.begin();
538 it != list.end(); ++it) {
539 if ((*it)->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() &&
540 (*it)->name() == ipv6_eth0_publicnetwork2_ip1.name()) {
541 // Check the new network has 1 IP and that it's the correct one.
542 EXPECT_EQ(1U, (*it)->GetIPs().size());
543 EXPECT_EQ(ip, (*it)->GetIPs().at(0));
544 } else {
545 // Check the IP didn't get added anywhere it wasn't supposed to.
546 EXPECT_EQ((*it)->GetIPs().end(),
547 std::find((*it)->GetIPs().begin(),
548 (*it)->GetIPs().end(),
549 ip));
550 }
551 }
552 }
553
554 // Test that DumpNetworks works.
TEST_F(NetworkTest,TestDumpNetworks)555 TEST_F(NetworkTest, TestDumpNetworks) {
556 BasicNetworkManager manager;
557 manager.DumpNetworks(true);
558 }
559
560 // Test that we can toggle IPv6 on and off.
TEST_F(NetworkTest,TestIPv6Toggle)561 TEST_F(NetworkTest, TestIPv6Toggle) {
562 BasicNetworkManager manager;
563 bool ipv6_found = false;
564 NetworkManager::NetworkList list;
565 #if !defined(WEBRTC_WIN)
566 // There should be at least one IPv6 network (fe80::/64 should be in there).
567 // TODO(thaloun): Disabling this test on windows for the moment as the test
568 // machines don't seem to have IPv6 installed on them at all.
569 manager.set_ipv6_enabled(true);
570 list = GetNetworks(manager, true);
571 for (NetworkManager::NetworkList::iterator it = list.begin();
572 it != list.end(); ++it) {
573 if ((*it)->prefix().family() == AF_INET6) {
574 ipv6_found = true;
575 break;
576 }
577 }
578 EXPECT_TRUE(ipv6_found);
579 for (NetworkManager::NetworkList::iterator it = list.begin();
580 it != list.end(); ++it) {
581 delete (*it);
582 }
583 #endif
584 ipv6_found = false;
585 manager.set_ipv6_enabled(false);
586 list = GetNetworks(manager, true);
587 for (NetworkManager::NetworkList::iterator it = list.begin();
588 it != list.end(); ++it) {
589 if ((*it)->prefix().family() == AF_INET6) {
590 ipv6_found = true;
591 break;
592 }
593 }
594 EXPECT_FALSE(ipv6_found);
595 for (NetworkManager::NetworkList::iterator it = list.begin();
596 it != list.end(); ++it) {
597 delete (*it);
598 }
599 }
600
TEST_F(NetworkTest,TestNetworkListSorting)601 TEST_F(NetworkTest, TestNetworkListSorting) {
602 BasicNetworkManager manager;
603 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
604 IPAddress(0x12345600U), 24);
605 ipv4_network1.AddIP(IPAddress(0x12345600U));
606
607 IPAddress ip;
608 IPAddress prefix;
609 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
610 prefix = TruncateIP(ip, 64);
611 Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 2",
612 prefix, 64);
613 ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
614
615 NetworkManager::NetworkList list;
616 list.push_back(new Network(ipv4_network1));
617 list.push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
618 Network* net1 = list[0];
619 Network* net2 = list[1];
620
621 bool changed = false;
622 MergeNetworkList(manager, list, &changed);
623 ASSERT_TRUE(changed);
624 // After sorting IPv6 network should be higher order than IPv4 networks.
625 EXPECT_TRUE(net1->preference() < net2->preference());
626 }
627
TEST_F(NetworkTest,TestNetworkAdapterTypes)628 TEST_F(NetworkTest, TestNetworkAdapterTypes) {
629 Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24,
630 ADAPTER_TYPE_WIFI);
631 EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type());
632 Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24,
633 ADAPTER_TYPE_ETHERNET);
634 EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type());
635 Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24,
636 ADAPTER_TYPE_CELLULAR);
637 EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type());
638 Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24,
639 ADAPTER_TYPE_VPN);
640 EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type());
641 Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24,
642 ADAPTER_TYPE_UNKNOWN);
643 EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type());
644 }
645
646 #if defined(WEBRTC_POSIX)
647 // Verify that we correctly handle interfaces with no address.
TEST_F(NetworkTest,TestConvertIfAddrsNoAddress)648 TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) {
649 ifaddrs list;
650 memset(&list, 0, sizeof(list));
651 list.ifa_name = const_cast<char*>("test_iface");
652
653 NetworkManager::NetworkList result;
654 BasicNetworkManager manager;
655 CallConvertIfAddrs(manager, &list, true, &result);
656 EXPECT_TRUE(result.empty());
657 }
658 #endif // defined(WEBRTC_POSIX)
659
660 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
661 // If you want to test non-default routes, you can do the following on a linux
662 // machine:
663 // 1) Load the dummy network driver:
664 // sudo modprobe dummy
665 // sudo ifconfig dummy0 127.0.0.1
666 // 2) Run this test and confirm the output says it found a dummy route (and
667 // passes).
668 // 3) When done:
669 // sudo rmmmod dummy
TEST_F(NetworkTest,TestIgnoreNonDefaultRoutes)670 TEST_F(NetworkTest, TestIgnoreNonDefaultRoutes) {
671 BasicNetworkManager manager;
672 NetworkManager::NetworkList list;
673 list = GetNetworks(manager, false);
674 bool found_dummy = false;
675 LOG(LS_INFO) << "Looking for dummy network: ";
676 for (NetworkManager::NetworkList::iterator it = list.begin();
677 it != list.end(); ++it) {
678 LOG(LS_INFO) << " Network name: " << (*it)->name();
679 found_dummy |= (*it)->name().find("dummy0") != std::string::npos;
680 }
681 for (NetworkManager::NetworkList::iterator it = list.begin();
682 it != list.end(); ++it) {
683 delete (*it);
684 }
685 if (!found_dummy) {
686 LOG(LS_INFO) << "No dummy found, quitting.";
687 return;
688 }
689 LOG(LS_INFO) << "Found dummy, running again while ignoring non-default "
690 << "routes.";
691 manager.set_ignore_non_default_routes(true);
692 list = GetNetworks(manager, false);
693 for (NetworkManager::NetworkList::iterator it = list.begin();
694 it != list.end(); ++it) {
695 LOG(LS_INFO) << " Network name: " << (*it)->name();
696 EXPECT_TRUE((*it)->name().find("dummy0") == std::string::npos);
697 }
698 for (NetworkManager::NetworkList::iterator it = list.begin();
699 it != list.end(); ++it) {
700 delete (*it);
701 }
702 }
703 #endif
704
705 // Test MergeNetworkList successfully combines all IPs for the same
706 // prefix/length into a single Network.
TEST_F(NetworkTest,TestMergeNetworkList)707 TEST_F(NetworkTest, TestMergeNetworkList) {
708 BasicNetworkManager manager;
709 NetworkManager::NetworkList list;
710
711 // Create 2 IPAddress classes with only last digit different.
712 IPAddress ip1, ip2;
713 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
714 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:2", &ip2));
715
716 // Create 2 networks with the same prefix and length.
717 Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
718 Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
719
720 // Add different IP into each.
721 net1->AddIP(ip1);
722 net2->AddIP(ip2);
723
724 list.push_back(net1);
725 list.push_back(net2);
726 bool changed;
727 MergeNetworkList(manager, list, &changed);
728 EXPECT_TRUE(changed);
729
730 NetworkManager::NetworkList list2;
731 manager.GetNetworks(&list2);
732
733 // Make sure the resulted networklist has only 1 element and 2
734 // IPAddresses.
735 EXPECT_EQ(list2.size(), 1uL);
736 EXPECT_EQ(list2[0]->GetIPs().size(), 2uL);
737 EXPECT_EQ(list2[0]->GetIPs()[0], ip1);
738 EXPECT_EQ(list2[0]->GetIPs()[1], ip2);
739 }
740
741 // Test that the filtering logic follows the defined ruleset in network.h.
TEST_F(NetworkTest,TestIPv6Selection)742 TEST_F(NetworkTest, TestIPv6Selection) {
743 InterfaceAddress ip;
744 std::string ipstr;
745
746 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3";
747 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
748
749 // Create a network with this prefix.
750 Network ipv6_network(
751 "test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64), 64);
752
753 // When there is no address added, it should return an unspecified
754 // address.
755 EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
756 EXPECT_TRUE(IPIsUnspec(ipv6_network.GetBestIP()));
757
758 // Deprecated one should not be returned.
759 ipv6_network.AddIP(ip);
760 EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
761
762 // Add ULA one. ULA is unique local address which is starting either
763 // with 0xfc or 0xfd.
764 ipstr = "fd00:fa00:4:1000:be30:5bff:fee5:c4";
765 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
766 ipv6_network.AddIP(ip);
767 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
768
769 // Add global one.
770 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c5";
771 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
772 ipv6_network.AddIP(ip);
773 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
774
775 // Add global dynamic temporary one.
776 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6";
777 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
778 ipv6_network.AddIP(ip);
779 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
780 }
781
782 } // namespace rtc
783