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 "rtc_base/network.h"
12
13 #include <stdlib.h>
14
15 #include <algorithm>
16 #include <memory>
17 #include <vector>
18
19 #include "absl/algorithm/container.h"
20 #include "absl/strings/match.h"
21 #include "rtc_base/checks.h"
22 #include "rtc_base/net_helpers.h"
23 #include "rtc_base/network_monitor.h"
24 #include "rtc_base/network_monitor_factory.h"
25 #if defined(WEBRTC_POSIX)
26 #include <net/if.h>
27 #include <sys/types.h>
28
29 #include "rtc_base/ifaddrs_converter.h"
30 #endif // defined(WEBRTC_POSIX)
31 #include "rtc_base/gunit.h"
32 #include "test/gmock.h"
33 #if defined(WEBRTC_WIN)
34 #include "rtc_base/logging.h" // For RTC_LOG_GLE
35 #endif
36
37 using ::testing::Contains;
38 using ::testing::Not;
39 using ::testing::UnorderedElementsAre;
40 using ::testing::UnorderedElementsAreArray;
41
42 namespace rtc {
43
44 namespace {
45
46 class FakeNetworkMonitor : public NetworkMonitorInterface {
47 public:
Start()48 void Start() override { started_ = true; }
Stop()49 void Stop() override { started_ = false; }
started()50 bool started() { return started_; }
GetAdapterType(const std::string & if_name)51 AdapterType GetAdapterType(const std::string& if_name) override {
52 // Note that the name matching rules are different from the
53 // GetAdapterTypeFromName in NetworkManager.
54 if (absl::StartsWith(if_name, "wifi")) {
55 return ADAPTER_TYPE_WIFI;
56 }
57 if (absl::StartsWith(if_name, "cellular")) {
58 return ADAPTER_TYPE_CELLULAR;
59 }
60 return ADAPTER_TYPE_UNKNOWN;
61 }
GetVpnUnderlyingAdapterType(const std::string & if_name)62 AdapterType GetVpnUnderlyingAdapterType(const std::string& if_name) override {
63 return ADAPTER_TYPE_UNKNOWN;
64 }
GetNetworkPreference(const std::string & if_name)65 NetworkPreference GetNetworkPreference(const std::string& if_name) override {
66 return NetworkPreference::NEUTRAL;
67 }
68
IsAdapterAvailable(const std::string & if_name)69 bool IsAdapterAvailable(const std::string& if_name) override {
70 return absl::c_count(unavailable_adapters_, if_name) == 0;
71 }
72
73 // Used to test IsAdapterAvailable.
set_unavailable_adapters(std::vector<std::string> unavailable_adapters)74 void set_unavailable_adapters(std::vector<std::string> unavailable_adapters) {
75 unavailable_adapters_ = unavailable_adapters;
76 }
77
78 private:
79 bool started_ = false;
80 std::vector<std::string> unavailable_adapters_;
81 };
82
83 class FakeNetworkMonitorFactory : public NetworkMonitorFactory {
84 public:
FakeNetworkMonitorFactory()85 FakeNetworkMonitorFactory() {}
CreateNetworkMonitor()86 NetworkMonitorInterface* CreateNetworkMonitor() override {
87 return new FakeNetworkMonitor();
88 }
89 };
90
SameNameAndPrefix(const rtc::Network & a,const rtc::Network & b)91 bool SameNameAndPrefix(const rtc::Network& a, const rtc::Network& b) {
92 if (a.name() != b.name()) {
93 RTC_LOG(INFO) << "Different interface names.";
94 return false;
95 }
96 if (a.prefix_length() != b.prefix_length() || a.prefix() != b.prefix()) {
97 RTC_LOG(INFO) << "Different IP prefixes.";
98 return false;
99 }
100 return true;
101 }
102
103 } // namespace
104
105 class NetworkTest : public ::testing::Test, public sigslot::has_slots<> {
106 public:
NetworkTest()107 NetworkTest() : callback_called_(false) {}
108
OnNetworksChanged()109 void OnNetworksChanged() { callback_called_ = true; }
110
MergeNetworkList(BasicNetworkManager & network_manager,const NetworkManager::NetworkList & list,bool * changed)111 NetworkManager::Stats MergeNetworkList(
112 BasicNetworkManager& network_manager,
113 const NetworkManager::NetworkList& list,
114 bool* changed) {
115 NetworkManager::Stats stats;
116 network_manager.MergeNetworkList(list, changed, &stats);
117 return stats;
118 }
119
IsIgnoredNetwork(BasicNetworkManager & network_manager,const Network & network)120 bool IsIgnoredNetwork(BasicNetworkManager& network_manager,
121 const Network& network) {
122 RTC_DCHECK_RUN_ON(network_manager.thread_);
123 return network_manager.IsIgnoredNetwork(network);
124 }
125
QueryDefaultLocalAddress(BasicNetworkManager & network_manager,int family)126 IPAddress QueryDefaultLocalAddress(BasicNetworkManager& network_manager,
127 int family) {
128 RTC_DCHECK_RUN_ON(network_manager.thread_);
129 return network_manager.QueryDefaultLocalAddress(family);
130 }
131
GetNetworks(const BasicNetworkManager & network_manager,bool include_ignored)132 NetworkManager::NetworkList GetNetworks(
133 const BasicNetworkManager& network_manager,
134 bool include_ignored) {
135 RTC_DCHECK_RUN_ON(network_manager.thread_);
136 NetworkManager::NetworkList list;
137 network_manager.CreateNetworks(include_ignored, &list);
138 return list;
139 }
140
GetNetworkMonitor(BasicNetworkManager & network_manager)141 FakeNetworkMonitor* GetNetworkMonitor(BasicNetworkManager& network_manager) {
142 RTC_DCHECK_RUN_ON(network_manager.thread_);
143 return static_cast<FakeNetworkMonitor*>(
144 network_manager.network_monitor_.get());
145 }
ClearNetworks(BasicNetworkManager & network_manager)146 void ClearNetworks(BasicNetworkManager& network_manager) {
147 for (const auto& kv : network_manager.networks_map_) {
148 delete kv.second;
149 }
150 network_manager.networks_.clear();
151 network_manager.networks_map_.clear();
152 }
153
GetAdapterType(BasicNetworkManager & network_manager)154 AdapterType GetAdapterType(BasicNetworkManager& network_manager) {
155 BasicNetworkManager::NetworkList list;
156 network_manager.GetNetworks(&list);
157 RTC_CHECK_EQ(1, list.size());
158 return list[0]->type();
159 }
160
161 #if defined(WEBRTC_POSIX)
162 // Separated from CreateNetworks for tests.
CallConvertIfAddrs(const BasicNetworkManager & network_manager,struct ifaddrs * interfaces,bool include_ignored,NetworkManager::NetworkList * networks)163 static void CallConvertIfAddrs(const BasicNetworkManager& network_manager,
164 struct ifaddrs* interfaces,
165 bool include_ignored,
166 NetworkManager::NetworkList* networks) {
167 RTC_DCHECK_RUN_ON(network_manager.thread_);
168 // Use the base IfAddrsConverter for test cases.
169 std::unique_ptr<IfAddrsConverter> ifaddrs_converter(new IfAddrsConverter());
170 network_manager.ConvertIfAddrs(interfaces, ifaddrs_converter.get(),
171 include_ignored, networks);
172 }
173
CreateIpv6Addr(const std::string & ip_string,uint32_t scope_id)174 struct sockaddr_in6* CreateIpv6Addr(const std::string& ip_string,
175 uint32_t scope_id) {
176 struct sockaddr_in6* ipv6_addr =
177 static_cast<struct sockaddr_in6*>(malloc(sizeof(struct sockaddr_in6)));
178 memset(ipv6_addr, 0, sizeof(struct sockaddr_in6));
179 ipv6_addr->sin6_family = AF_INET6;
180 ipv6_addr->sin6_scope_id = scope_id;
181 IPAddress ip;
182 IPFromString(ip_string, &ip);
183 ipv6_addr->sin6_addr = ip.ipv6_address();
184 return ipv6_addr;
185 }
186
187 // Pointers created here need to be released via ReleaseIfAddrs.
AddIpv6Address(struct ifaddrs * list,char * if_name,const std::string & ipv6_address,const std::string & ipv6_netmask,uint32_t scope_id)188 struct ifaddrs* AddIpv6Address(struct ifaddrs* list,
189 char* if_name,
190 const std::string& ipv6_address,
191 const std::string& ipv6_netmask,
192 uint32_t scope_id) {
193 struct ifaddrs* if_addr = new struct ifaddrs;
194 memset(if_addr, 0, sizeof(struct ifaddrs));
195 if_addr->ifa_name = if_name;
196 if_addr->ifa_addr = reinterpret_cast<struct sockaddr*>(
197 CreateIpv6Addr(ipv6_address, scope_id));
198 if_addr->ifa_netmask =
199 reinterpret_cast<struct sockaddr*>(CreateIpv6Addr(ipv6_netmask, 0));
200 if_addr->ifa_next = list;
201 if_addr->ifa_flags = IFF_RUNNING;
202 return if_addr;
203 }
204
InstallIpv6Network(char * if_name,const std::string & ipv6_address,const std::string & ipv6_mask,BasicNetworkManager & network_manager)205 struct ifaddrs* InstallIpv6Network(char* if_name,
206 const std::string& ipv6_address,
207 const std::string& ipv6_mask,
208 BasicNetworkManager& network_manager) {
209 ifaddrs* addr_list = nullptr;
210 addr_list = AddIpv6Address(addr_list, if_name, ipv6_address, ipv6_mask, 0);
211 NetworkManager::NetworkList result;
212 bool changed;
213 NetworkManager::Stats stats;
214 CallConvertIfAddrs(network_manager, addr_list, true, &result);
215 network_manager.MergeNetworkList(result, &changed, &stats);
216 return addr_list;
217 }
218
CreateIpv4Addr(const std::string & ip_string)219 struct sockaddr_in* CreateIpv4Addr(const std::string& ip_string) {
220 struct sockaddr_in* ipv4_addr =
221 static_cast<struct sockaddr_in*>(malloc(sizeof(struct sockaddr_in)));
222 memset(ipv4_addr, 0, sizeof(struct sockaddr_in));
223 ipv4_addr->sin_family = AF_INET;
224 IPAddress ip;
225 IPFromString(ip_string, &ip);
226 ipv4_addr->sin_addr = ip.ipv4_address();
227 return ipv4_addr;
228 }
229
230 // Pointers created here need to be released via ReleaseIfAddrs.
AddIpv4Address(struct ifaddrs * list,char * if_name,const std::string & ipv4_address,const std::string & ipv4_netmask)231 struct ifaddrs* AddIpv4Address(struct ifaddrs* list,
232 char* if_name,
233 const std::string& ipv4_address,
234 const std::string& ipv4_netmask) {
235 struct ifaddrs* if_addr = new struct ifaddrs;
236 memset(if_addr, 0, sizeof(struct ifaddrs));
237 if_addr->ifa_name = if_name;
238 if_addr->ifa_addr =
239 reinterpret_cast<struct sockaddr*>(CreateIpv4Addr(ipv4_address));
240 if_addr->ifa_netmask =
241 reinterpret_cast<struct sockaddr*>(CreateIpv4Addr(ipv4_netmask));
242 if_addr->ifa_next = list;
243 if_addr->ifa_flags = IFF_RUNNING;
244 return if_addr;
245 }
246
InstallIpv4Network(char * if_name,const std::string & ipv4_address,const std::string & ipv4_mask,BasicNetworkManager & network_manager)247 struct ifaddrs* InstallIpv4Network(char* if_name,
248 const std::string& ipv4_address,
249 const std::string& ipv4_mask,
250 BasicNetworkManager& network_manager) {
251 ifaddrs* addr_list = nullptr;
252 addr_list = AddIpv4Address(addr_list, if_name, ipv4_address, ipv4_mask);
253 NetworkManager::NetworkList result;
254 bool changed;
255 NetworkManager::Stats stats;
256 CallConvertIfAddrs(network_manager, addr_list, true, &result);
257 network_manager.MergeNetworkList(result, &changed, &stats);
258 return addr_list;
259 }
260
ReleaseIfAddrs(struct ifaddrs * list)261 void ReleaseIfAddrs(struct ifaddrs* list) {
262 struct ifaddrs* if_addr = list;
263 while (if_addr != nullptr) {
264 struct ifaddrs* next_addr = if_addr->ifa_next;
265 free(if_addr->ifa_addr);
266 free(if_addr->ifa_netmask);
267 delete if_addr;
268 if_addr = next_addr;
269 }
270 }
271 #endif // defined(WEBRTC_POSIX)
272
273 protected:
274 bool callback_called_;
275 };
276
277 class TestBasicNetworkManager : public BasicNetworkManager {
278 public:
TestBasicNetworkManager(NetworkMonitorFactory * network_monitor_factory)279 TestBasicNetworkManager(NetworkMonitorFactory* network_monitor_factory)
280 : BasicNetworkManager(network_monitor_factory) {}
281 using BasicNetworkManager::QueryDefaultLocalAddress;
282 using BasicNetworkManager::set_default_local_addresses;
283 };
284
285 // Test that the Network ctor works properly.
TEST_F(NetworkTest,TestNetworkConstruct)286 TEST_F(NetworkTest, TestNetworkConstruct) {
287 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
288 IPAddress(0x12345600U), 24);
289 EXPECT_EQ("test_eth0", ipv4_network1.name());
290 EXPECT_EQ("Test Network Adapter 1", ipv4_network1.description());
291 EXPECT_EQ(IPAddress(0x12345600U), ipv4_network1.prefix());
292 EXPECT_EQ(24, ipv4_network1.prefix_length());
293 EXPECT_FALSE(ipv4_network1.ignored());
294 }
295
TEST_F(NetworkTest,TestIsIgnoredNetworkIgnoresIPsStartingWith0)296 TEST_F(NetworkTest, TestIsIgnoredNetworkIgnoresIPsStartingWith0) {
297 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
298 IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET);
299 Network ipv4_network2("test_eth1", "Test Network Adapter 2",
300 IPAddress(0x010000U), 24, ADAPTER_TYPE_ETHERNET);
301 BasicNetworkManager network_manager;
302 network_manager.StartUpdating();
303 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1));
304 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network2));
305 }
306
307 // TODO(phoglund): Remove when ignore list goes away.
TEST_F(NetworkTest,TestIgnoreList)308 TEST_F(NetworkTest, TestIgnoreList) {
309 Network ignore_me("ignore_me", "Ignore me please!", IPAddress(0x12345600U),
310 24);
311 Network include_me("include_me", "Include me please!", IPAddress(0x12345600U),
312 24);
313 BasicNetworkManager default_network_manager;
314 default_network_manager.StartUpdating();
315 EXPECT_FALSE(IsIgnoredNetwork(default_network_manager, ignore_me));
316 EXPECT_FALSE(IsIgnoredNetwork(default_network_manager, include_me));
317
318 BasicNetworkManager ignoring_network_manager;
319 std::vector<std::string> ignore_list;
320 ignore_list.push_back("ignore_me");
321 ignoring_network_manager.set_network_ignore_list(ignore_list);
322 ignoring_network_manager.StartUpdating();
323 EXPECT_TRUE(IsIgnoredNetwork(ignoring_network_manager, ignore_me));
324 EXPECT_FALSE(IsIgnoredNetwork(ignoring_network_manager, include_me));
325 }
326
327 // Test is failing on Windows opt: b/11288214
TEST_F(NetworkTest,DISABLED_TestCreateNetworks)328 TEST_F(NetworkTest, DISABLED_TestCreateNetworks) {
329 BasicNetworkManager manager;
330 NetworkManager::NetworkList result = GetNetworks(manager, true);
331 // We should be able to bind to any addresses we find.
332 NetworkManager::NetworkList::iterator it;
333 for (it = result.begin(); it != result.end(); ++it) {
334 sockaddr_storage storage;
335 memset(&storage, 0, sizeof(storage));
336 IPAddress ip = (*it)->GetBestIP();
337 SocketAddress bindaddress(ip, 0);
338 bindaddress.SetScopeID((*it)->scope_id());
339 // TODO(thaloun): Use rtc::AsyncSocket once it supports IPv6.
340 int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
341 if (fd > 0) {
342 size_t ipsize = bindaddress.ToSockAddrStorage(&storage);
343 EXPECT_GE(ipsize, 0U);
344 int success = ::bind(fd, reinterpret_cast<sockaddr*>(&storage),
345 static_cast<int>(ipsize));
346 #if defined(WEBRTC_WIN)
347 if (success)
348 RTC_LOG_GLE(LS_ERROR) << "Socket bind failed.";
349 #endif
350 EXPECT_EQ(0, success);
351 #if defined(WEBRTC_WIN)
352 closesocket(fd);
353 #else
354 close(fd);
355 #endif
356 }
357 delete (*it);
358 }
359 }
360
361 // Test StartUpdating() and StopUpdating(). network_permission_state starts with
362 // ALLOWED.
TEST_F(NetworkTest,TestUpdateNetworks)363 TEST_F(NetworkTest, TestUpdateNetworks) {
364 BasicNetworkManager manager;
365 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
366 &NetworkTest::OnNetworksChanged);
367 EXPECT_EQ(NetworkManager::ENUMERATION_ALLOWED,
368 manager.enumeration_permission());
369 manager.StartUpdating();
370 Thread::Current()->ProcessMessages(0);
371 EXPECT_TRUE(callback_called_);
372 callback_called_ = false;
373 // Callback should be triggered immediately when StartUpdating
374 // is called, after network update signal is already sent.
375 manager.StartUpdating();
376 EXPECT_TRUE(manager.started());
377 Thread::Current()->ProcessMessages(0);
378 EXPECT_TRUE(callback_called_);
379 manager.StopUpdating();
380 EXPECT_TRUE(manager.started());
381 manager.StopUpdating();
382 EXPECT_EQ(NetworkManager::ENUMERATION_ALLOWED,
383 manager.enumeration_permission());
384 EXPECT_FALSE(manager.started());
385 manager.StopUpdating();
386 EXPECT_FALSE(manager.started());
387 callback_called_ = false;
388 // Callback should be triggered immediately after StartUpdating is called
389 // when start_count_ is reset to 0.
390 manager.StartUpdating();
391 Thread::Current()->ProcessMessages(0);
392 EXPECT_TRUE(callback_called_);
393 }
394
395 // Verify that MergeNetworkList() merges network lists properly.
TEST_F(NetworkTest,TestBasicMergeNetworkList)396 TEST_F(NetworkTest, TestBasicMergeNetworkList) {
397 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
398 IPAddress(0x12345600U), 24);
399 Network ipv4_network2("test_eth1", "Test Network Adapter 2",
400 IPAddress(0x00010000U), 16);
401 ipv4_network1.AddIP(IPAddress(0x12345678));
402 ipv4_network2.AddIP(IPAddress(0x00010004));
403 BasicNetworkManager manager;
404
405 // Add ipv4_network1 to the list of networks.
406 NetworkManager::NetworkList list;
407 list.push_back(new Network(ipv4_network1));
408 bool changed;
409 NetworkManager::Stats stats = MergeNetworkList(manager, list, &changed);
410 EXPECT_TRUE(changed);
411 EXPECT_EQ(stats.ipv6_network_count, 0);
412 EXPECT_EQ(stats.ipv4_network_count, 1);
413 list.clear();
414
415 manager.GetNetworks(&list);
416 EXPECT_EQ(1U, list.size());
417 EXPECT_TRUE(SameNameAndPrefix(ipv4_network1, *list[0]));
418 Network* net1 = list[0];
419 uint16_t net_id1 = net1->id();
420 EXPECT_EQ(1, net_id1);
421 list.clear();
422
423 // Replace ipv4_network1 with ipv4_network2.
424 list.push_back(new Network(ipv4_network2));
425 stats = MergeNetworkList(manager, list, &changed);
426 EXPECT_TRUE(changed);
427 EXPECT_EQ(stats.ipv6_network_count, 0);
428 EXPECT_EQ(stats.ipv4_network_count, 1);
429 list.clear();
430
431 manager.GetNetworks(&list);
432 EXPECT_EQ(1U, list.size());
433 EXPECT_TRUE(SameNameAndPrefix(ipv4_network2, *list[0]));
434 Network* net2 = list[0];
435 uint16_t net_id2 = net2->id();
436 // Network id will increase.
437 EXPECT_LT(net_id1, net_id2);
438 list.clear();
439
440 // Add Network2 back.
441 list.push_back(new Network(ipv4_network1));
442 list.push_back(new Network(ipv4_network2));
443 stats = MergeNetworkList(manager, list, &changed);
444 EXPECT_TRUE(changed);
445 EXPECT_EQ(stats.ipv6_network_count, 0);
446 EXPECT_EQ(stats.ipv4_network_count, 2);
447 list.clear();
448
449 // Verify that we get previous instances of Network objects.
450 manager.GetNetworks(&list);
451 EXPECT_EQ(2U, list.size());
452 EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
453 (net1 == list[1] && net2 == list[0]));
454 EXPECT_TRUE((net_id1 == list[0]->id() && net_id2 == list[1]->id()) ||
455 (net_id1 == list[1]->id() && net_id2 == list[0]->id()));
456 list.clear();
457
458 // Call MergeNetworkList() again and verify that we don't get update
459 // notification.
460 list.push_back(new Network(ipv4_network2));
461 list.push_back(new Network(ipv4_network1));
462 stats = MergeNetworkList(manager, list, &changed);
463 EXPECT_FALSE(changed);
464 EXPECT_EQ(stats.ipv6_network_count, 0);
465 EXPECT_EQ(stats.ipv4_network_count, 2);
466 list.clear();
467
468 // Verify that we get previous instances of Network objects.
469 manager.GetNetworks(&list);
470 EXPECT_EQ(2U, list.size());
471 EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
472 (net1 == list[1] && net2 == list[0]));
473 EXPECT_TRUE((net_id1 == list[0]->id() && net_id2 == list[1]->id()) ||
474 (net_id1 == list[1]->id() && net_id2 == list[0]->id()));
475 list.clear();
476 }
477
478 // Sets up some test IPv6 networks and appends them to list.
479 // Four networks are added - public and link local, for two interfaces.
SetupNetworks(NetworkManager::NetworkList * list)480 void SetupNetworks(NetworkManager::NetworkList* list) {
481 IPAddress ip;
482 IPAddress prefix;
483 EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:ef12", &ip));
484 EXPECT_TRUE(IPFromString("abcd::", &prefix));
485 // First, fake link-locals.
486 Network ipv6_eth0_linklocalnetwork("test_eth0", "Test NetworkAdapter 1",
487 prefix, 64);
488 ipv6_eth0_linklocalnetwork.AddIP(ip);
489 EXPECT_TRUE(IPFromString("abcd::5678:abcd:ef12:3456", &ip));
490 Network ipv6_eth1_linklocalnetwork("test_eth1", "Test NetworkAdapter 2",
491 prefix, 64);
492 ipv6_eth1_linklocalnetwork.AddIP(ip);
493 // Public networks:
494 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip));
495 prefix = TruncateIP(ip, 64);
496 Network ipv6_eth0_publicnetwork1_ip1("test_eth0", "Test NetworkAdapter 1",
497 prefix, 64);
498 ipv6_eth0_publicnetwork1_ip1.AddIP(ip);
499 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
500 prefix = TruncateIP(ip, 64);
501 Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 1",
502 prefix, 64);
503 ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
504 list->push_back(new Network(ipv6_eth0_linklocalnetwork));
505 list->push_back(new Network(ipv6_eth1_linklocalnetwork));
506 list->push_back(new Network(ipv6_eth0_publicnetwork1_ip1));
507 list->push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
508 }
509
510 // Test that the basic network merging case works.
TEST_F(NetworkTest,TestIPv6MergeNetworkList)511 TEST_F(NetworkTest, TestIPv6MergeNetworkList) {
512 BasicNetworkManager manager;
513 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
514 &NetworkTest::OnNetworksChanged);
515 NetworkManager::NetworkList original_list;
516 SetupNetworks(&original_list);
517 bool changed = false;
518 NetworkManager::Stats stats =
519 MergeNetworkList(manager, original_list, &changed);
520 EXPECT_TRUE(changed);
521 EXPECT_EQ(stats.ipv6_network_count, 4);
522 EXPECT_EQ(stats.ipv4_network_count, 0);
523 NetworkManager::NetworkList list;
524 manager.GetNetworks(&list);
525 // Verify that the original members are in the merged list.
526 EXPECT_THAT(list, UnorderedElementsAreArray(original_list));
527 }
528
529 // Tests that when two network lists that describe the same set of networks are
530 // merged, that the changed callback is not called, and that the original
531 // objects remain in the result list.
TEST_F(NetworkTest,TestNoChangeMerge)532 TEST_F(NetworkTest, TestNoChangeMerge) {
533 BasicNetworkManager manager;
534 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
535 &NetworkTest::OnNetworksChanged);
536 NetworkManager::NetworkList original_list;
537 SetupNetworks(&original_list);
538 bool changed = false;
539 MergeNetworkList(manager, original_list, &changed);
540 EXPECT_TRUE(changed);
541 // Second list that describes the same networks but with new objects.
542 NetworkManager::NetworkList second_list;
543 SetupNetworks(&second_list);
544 changed = false;
545 MergeNetworkList(manager, second_list, &changed);
546 EXPECT_FALSE(changed);
547 NetworkManager::NetworkList resulting_list;
548 manager.GetNetworks(&resulting_list);
549 // Verify that the original members are in the merged list.
550 EXPECT_THAT(resulting_list, UnorderedElementsAreArray(original_list));
551 // Doublecheck that the new networks aren't in the list.
552 for (const Network* network : second_list) {
553 EXPECT_THAT(resulting_list, Not(Contains(network)));
554 }
555 }
556
557 // Test that we can merge a network that is the same as another network but with
558 // a different IP. The original network should remain in the list, but have its
559 // IP changed.
TEST_F(NetworkTest,MergeWithChangedIP)560 TEST_F(NetworkTest, MergeWithChangedIP) {
561 BasicNetworkManager manager;
562 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
563 &NetworkTest::OnNetworksChanged);
564 NetworkManager::NetworkList original_list;
565 SetupNetworks(&original_list);
566 // Make a network that we're going to change.
567 IPAddress ip;
568 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip));
569 IPAddress prefix = TruncateIP(ip, 64);
570 Network* network_to_change =
571 new Network("test_eth0", "Test Network Adapter 1", prefix, 64);
572 Network* changed_network = new Network(*network_to_change);
573 network_to_change->AddIP(ip);
574 IPAddress changed_ip;
575 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip));
576 changed_network->AddIP(changed_ip);
577 original_list.push_back(network_to_change);
578 bool changed = false;
579 MergeNetworkList(manager, original_list, &changed);
580 NetworkManager::NetworkList second_list;
581 SetupNetworks(&second_list);
582 second_list.push_back(changed_network);
583 changed = false;
584 MergeNetworkList(manager, second_list, &changed);
585 EXPECT_TRUE(changed);
586 NetworkManager::NetworkList list;
587 manager.GetNetworks(&list);
588 EXPECT_EQ(original_list.size(), list.size());
589 // Make sure the original network is still in the merged list.
590 EXPECT_THAT(list, Contains(network_to_change));
591 EXPECT_EQ(changed_ip, network_to_change->GetIPs().at(0));
592 }
593
594 // Testing a similar case to above, but checking that a network can be updated
595 // with additional IPs (not just a replacement).
TEST_F(NetworkTest,TestMultipleIPMergeNetworkList)596 TEST_F(NetworkTest, TestMultipleIPMergeNetworkList) {
597 BasicNetworkManager manager;
598 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
599 &NetworkTest::OnNetworksChanged);
600 NetworkManager::NetworkList original_list;
601 SetupNetworks(&original_list);
602 bool changed = false;
603 MergeNetworkList(manager, original_list, &changed);
604 EXPECT_TRUE(changed);
605 IPAddress ip;
606 IPAddress check_ip;
607 IPAddress prefix;
608 // Add a second IP to the public network on eth0 (2401:fa00:4:1000/64).
609 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip));
610 prefix = TruncateIP(ip, 64);
611 Network ipv6_eth0_publicnetwork1_ip2("test_eth0", "Test NetworkAdapter 1",
612 prefix, 64);
613 // This is the IP that already existed in the public network on eth0.
614 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip));
615 ipv6_eth0_publicnetwork1_ip2.AddIP(ip);
616 original_list.push_back(new Network(ipv6_eth0_publicnetwork1_ip2));
617 changed = false;
618 MergeNetworkList(manager, original_list, &changed);
619 EXPECT_TRUE(changed);
620 // There should still be four networks.
621 NetworkManager::NetworkList list;
622 manager.GetNetworks(&list);
623 EXPECT_EQ(4U, list.size());
624 // Check the gathered IPs.
625 int matchcount = 0;
626 for (NetworkManager::NetworkList::iterator it = list.begin();
627 it != list.end(); ++it) {
628 if (SameNameAndPrefix(**it, *original_list[2])) {
629 ++matchcount;
630 EXPECT_EQ(1, matchcount);
631 // This should be the same network object as before.
632 EXPECT_EQ((*it), original_list[2]);
633 // But with two addresses now.
634 EXPECT_THAT((*it)->GetIPs(),
635 UnorderedElementsAre(InterfaceAddress(check_ip),
636 InterfaceAddress(ip)));
637 } else {
638 // Check the IP didn't get added anywhere it wasn't supposed to.
639 EXPECT_THAT((*it)->GetIPs(), Not(Contains(InterfaceAddress(ip))));
640 }
641 }
642 }
643
644 // Test that merge correctly distinguishes multiple networks on an interface.
TEST_F(NetworkTest,TestMultiplePublicNetworksOnOneInterfaceMerge)645 TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) {
646 BasicNetworkManager manager;
647 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
648 &NetworkTest::OnNetworksChanged);
649 NetworkManager::NetworkList original_list;
650 SetupNetworks(&original_list);
651 bool changed = false;
652 MergeNetworkList(manager, original_list, &changed);
653 EXPECT_TRUE(changed);
654 IPAddress ip;
655 IPAddress prefix;
656 // A second network for eth0.
657 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip));
658 prefix = TruncateIP(ip, 64);
659 Network ipv6_eth0_publicnetwork2_ip1("test_eth0", "Test NetworkAdapter 1",
660 prefix, 64);
661 ipv6_eth0_publicnetwork2_ip1.AddIP(ip);
662 original_list.push_back(new Network(ipv6_eth0_publicnetwork2_ip1));
663 changed = false;
664 MergeNetworkList(manager, original_list, &changed);
665 EXPECT_TRUE(changed);
666 // There should be five networks now.
667 NetworkManager::NetworkList list;
668 manager.GetNetworks(&list);
669 EXPECT_EQ(5U, list.size());
670 // Check the resulting addresses.
671 for (NetworkManager::NetworkList::iterator it = list.begin();
672 it != list.end(); ++it) {
673 if ((*it)->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() &&
674 (*it)->name() == ipv6_eth0_publicnetwork2_ip1.name()) {
675 // Check the new network has 1 IP and that it's the correct one.
676 EXPECT_EQ(1U, (*it)->GetIPs().size());
677 EXPECT_EQ(ip, (*it)->GetIPs().at(0));
678 } else {
679 // Check the IP didn't get added anywhere it wasn't supposed to.
680 EXPECT_THAT((*it)->GetIPs(), Not(Contains(InterfaceAddress(ip))));
681 }
682 }
683 }
684
685 // Test that DumpNetworks does not crash.
TEST_F(NetworkTest,TestCreateAndDumpNetworks)686 TEST_F(NetworkTest, TestCreateAndDumpNetworks) {
687 BasicNetworkManager manager;
688 manager.StartUpdating();
689 NetworkManager::NetworkList list = GetNetworks(manager, true);
690 bool changed;
691 MergeNetworkList(manager, list, &changed);
692 manager.DumpNetworks();
693 }
694
TEST_F(NetworkTest,TestIPv6Toggle)695 TEST_F(NetworkTest, TestIPv6Toggle) {
696 BasicNetworkManager manager;
697 manager.StartUpdating();
698 bool ipv6_found = false;
699 NetworkManager::NetworkList list;
700 list = GetNetworks(manager, true);
701 for (NetworkManager::NetworkList::iterator it = list.begin();
702 it != list.end(); ++it) {
703 if ((*it)->prefix().family() == AF_INET6) {
704 ipv6_found = true;
705 break;
706 }
707 }
708 EXPECT_TRUE(ipv6_found);
709 for (NetworkManager::NetworkList::iterator it = list.begin();
710 it != list.end(); ++it) {
711 delete (*it);
712 }
713 }
714
715 // Test that when network interfaces are sorted and given preference values,
716 // IPv6 comes first.
TEST_F(NetworkTest,IPv6NetworksPreferredOverIPv4)717 TEST_F(NetworkTest, IPv6NetworksPreferredOverIPv4) {
718 BasicNetworkManager manager;
719 Network ipv4_network1("test_eth0", "Test Network Adapter 1",
720 IPAddress(0x12345600U), 24);
721 ipv4_network1.AddIP(IPAddress(0x12345600U));
722
723 IPAddress ip;
724 IPAddress prefix;
725 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
726 prefix = TruncateIP(ip, 64);
727 Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 2",
728 prefix, 64);
729 ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
730
731 NetworkManager::NetworkList list;
732 list.push_back(new Network(ipv4_network1));
733 list.push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
734 Network* net1 = list[0];
735 Network* net2 = list[1];
736
737 bool changed = false;
738 MergeNetworkList(manager, list, &changed);
739 ASSERT_TRUE(changed);
740 // After sorting IPv6 network should be higher order than IPv4 networks.
741 EXPECT_TRUE(net1->preference() < net2->preference());
742 }
743
744 // When two interfaces are equivalent in everything but name, they're expected
745 // to be preference-ordered by name. For example, "eth0" before "eth1".
TEST_F(NetworkTest,NetworksSortedByInterfaceName)746 TEST_F(NetworkTest, NetworksSortedByInterfaceName) {
747 BasicNetworkManager manager;
748 Network* eth0 = new Network("test_eth0", "Test Network Adapter 1",
749 IPAddress(0x65432100U), 24);
750 eth0->AddIP(IPAddress(0x65432100U));
751 Network* eth1 = new Network("test_eth1", "Test Network Adapter 2",
752 IPAddress(0x12345600U), 24);
753 eth1->AddIP(IPAddress(0x12345600U));
754 NetworkManager::NetworkList list;
755 // Add them to the list in the opposite of the expected sorted order, to
756 // ensure sorting actually occurs.
757 list.push_back(eth1);
758 list.push_back(eth0);
759
760 bool changed = false;
761 MergeNetworkList(manager, list, &changed);
762 ASSERT_TRUE(changed);
763 // "test_eth0" should be preferred over "test_eth1".
764 EXPECT_TRUE(eth0->preference() > eth1->preference());
765 }
766
TEST_F(NetworkTest,TestNetworkAdapterTypes)767 TEST_F(NetworkTest, TestNetworkAdapterTypes) {
768 Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24,
769 ADAPTER_TYPE_WIFI);
770 EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type());
771 Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24,
772 ADAPTER_TYPE_ETHERNET);
773 EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type());
774 Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24,
775 ADAPTER_TYPE_CELLULAR);
776 EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type());
777 Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24,
778 ADAPTER_TYPE_VPN);
779 EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type());
780 Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24,
781 ADAPTER_TYPE_UNKNOWN);
782 EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type());
783 }
784
785 #if defined(WEBRTC_POSIX)
786 // Verify that we correctly handle interfaces with no address.
TEST_F(NetworkTest,TestConvertIfAddrsNoAddress)787 TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) {
788 ifaddrs list;
789 memset(&list, 0, sizeof(list));
790 list.ifa_name = const_cast<char*>("test_iface");
791
792 NetworkManager::NetworkList result;
793 BasicNetworkManager manager;
794 manager.StartUpdating();
795 CallConvertIfAddrs(manager, &list, true, &result);
796 EXPECT_TRUE(result.empty());
797 }
798
799 // Verify that if there are two addresses on one interface, only one network
800 // is generated.
TEST_F(NetworkTest,TestConvertIfAddrsMultiAddressesOnOneInterface)801 TEST_F(NetworkTest, TestConvertIfAddrsMultiAddressesOnOneInterface) {
802 char if_name[20] = "rmnet0";
803 ifaddrs* list = nullptr;
804 list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:1",
805 "FFFF:FFFF:FFFF:FFFF::", 0);
806 list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:2",
807 "FFFF:FFFF:FFFF:FFFF::", 0);
808 NetworkManager::NetworkList result;
809 BasicNetworkManager manager;
810 manager.StartUpdating();
811 CallConvertIfAddrs(manager, list, true, &result);
812 EXPECT_EQ(1U, result.size());
813 bool changed;
814 // This ensures we release the objects created in CallConvertIfAddrs.
815 MergeNetworkList(manager, result, &changed);
816 ReleaseIfAddrs(list);
817 }
818
TEST_F(NetworkTest,TestConvertIfAddrsNotRunning)819 TEST_F(NetworkTest, TestConvertIfAddrsNotRunning) {
820 ifaddrs list;
821 memset(&list, 0, sizeof(list));
822 list.ifa_name = const_cast<char*>("test_iface");
823 sockaddr ifa_addr;
824 sockaddr ifa_netmask;
825 list.ifa_addr = &ifa_addr;
826 list.ifa_netmask = &ifa_netmask;
827
828 NetworkManager::NetworkList result;
829 BasicNetworkManager manager;
830 manager.StartUpdating();
831 CallConvertIfAddrs(manager, &list, true, &result);
832 EXPECT_TRUE(result.empty());
833 }
834
835 // Tests that the network type can be determined from the network monitor when
836 // it would otherwise be unknown.
TEST_F(NetworkTest,TestGetAdapterTypeFromNetworkMonitor)837 TEST_F(NetworkTest, TestGetAdapterTypeFromNetworkMonitor) {
838 char if_name[20] = "wifi0";
839 std::string ipv6_address = "1000:2000:3000:4000:0:0:0:1";
840 std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::";
841 BasicNetworkManager manager_without_monitor;
842 manager_without_monitor.StartUpdating();
843 // A network created without a network monitor will get UNKNOWN type.
844 ifaddrs* addr_list = InstallIpv6Network(if_name, ipv6_address, ipv6_mask,
845 manager_without_monitor);
846 EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, GetAdapterType(manager_without_monitor));
847 ReleaseIfAddrs(addr_list);
848
849 // With the fake network monitor the type should be correctly determined.
850 FakeNetworkMonitorFactory factory;
851 BasicNetworkManager manager_with_monitor(&factory);
852 manager_with_monitor.StartUpdating();
853 // Add the same ipv6 address as before but it has the right network type
854 // detected by the network monitor now.
855 addr_list = InstallIpv6Network(if_name, ipv6_address, ipv6_mask,
856 manager_with_monitor);
857 EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager_with_monitor));
858 ReleaseIfAddrs(addr_list);
859 }
860
861 // Test that the network type can be determined based on name matching in
862 // a few cases. Note that UNKNOWN type for non-matching strings has been tested
863 // in the above test.
TEST_F(NetworkTest,TestGetAdapterTypeFromNameMatching)864 TEST_F(NetworkTest, TestGetAdapterTypeFromNameMatching) {
865 std::string ipv4_address1 = "192.0.0.121";
866 std::string ipv4_mask = "255.255.255.0";
867 std::string ipv6_address1 = "1000:2000:3000:4000:0:0:0:1";
868 std::string ipv6_address2 = "1000:2000:3000:8000:0:0:0:1";
869 std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::";
870 BasicNetworkManager manager;
871 manager.StartUpdating();
872
873 // IPSec interface; name is in form "ipsec<index>".
874 char if_name[20] = "ipsec11";
875 ifaddrs* addr_list =
876 InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
877 EXPECT_EQ(ADAPTER_TYPE_VPN, GetAdapterType(manager));
878 ClearNetworks(manager);
879 ReleaseIfAddrs(addr_list);
880
881 strcpy(if_name, "lo0");
882 addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
883 EXPECT_EQ(ADAPTER_TYPE_LOOPBACK, GetAdapterType(manager));
884 ClearNetworks(manager);
885 ReleaseIfAddrs(addr_list);
886
887 strcpy(if_name, "eth0");
888 addr_list = InstallIpv4Network(if_name, ipv4_address1, ipv4_mask, manager);
889 EXPECT_EQ(ADAPTER_TYPE_ETHERNET, GetAdapterType(manager));
890 ClearNetworks(manager);
891 ReleaseIfAddrs(addr_list);
892
893 strcpy(if_name, "wlan0");
894 addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
895 EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager));
896 ClearNetworks(manager);
897 ReleaseIfAddrs(addr_list);
898
899 #if defined(WEBRTC_IOS)
900 strcpy(if_name, "pdp_ip0");
901 addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
902 EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
903 ClearNetworks(manager);
904 ReleaseIfAddrs(addr_list);
905
906 strcpy(if_name, "en0");
907 addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
908 EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager));
909 ClearNetworks(manager);
910 ReleaseIfAddrs(addr_list);
911
912 #elif defined(WEBRTC_ANDROID)
913 strcpy(if_name, "rmnet0");
914 addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
915 EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
916 ClearNetworks(manager);
917 ReleaseIfAddrs(addr_list);
918
919 strcpy(if_name, "v4-rmnet_data0");
920 addr_list = InstallIpv6Network(if_name, ipv6_address2, ipv6_mask, manager);
921 EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
922 ClearNetworks(manager);
923 ReleaseIfAddrs(addr_list);
924
925 strcpy(if_name, "clat4");
926 addr_list = InstallIpv4Network(if_name, ipv4_address1, ipv4_mask, manager);
927 EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
928 ClearNetworks(manager);
929 ReleaseIfAddrs(addr_list);
930 #endif
931 }
932
933 // Test that an adapter won't be included in the network list if there's a
934 // network monitor that says it's unavailable.
TEST_F(NetworkTest,TestNetworkMonitorIsAdapterAvailable)935 TEST_F(NetworkTest, TestNetworkMonitorIsAdapterAvailable) {
936 char if_name1[20] = "pdp_ip0";
937 char if_name2[20] = "pdp_ip1";
938 ifaddrs* list = nullptr;
939 list = AddIpv6Address(list, if_name1, "1000:2000:3000:4000:0:0:0:1",
940 "FFFF:FFFF:FFFF:FFFF::", 0);
941 list = AddIpv6Address(list, if_name2, "1000:2000:3000:4000:0:0:0:2",
942 "FFFF:FFFF:FFFF:FFFF::", 0);
943 NetworkManager::NetworkList result;
944
945 // Sanity check that both interfaces are included by default.
946 FakeNetworkMonitorFactory factory;
947 BasicNetworkManager manager(&factory);
948 manager.StartUpdating();
949 CallConvertIfAddrs(manager, list, /*include_ignored=*/false, &result);
950 EXPECT_EQ(2u, result.size());
951 bool changed;
952 // This ensures we release the objects created in CallConvertIfAddrs.
953 MergeNetworkList(manager, result, &changed);
954 result.clear();
955
956 // Now simulate one interface being unavailable.
957 FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager);
958 network_monitor->set_unavailable_adapters({if_name1});
959 CallConvertIfAddrs(manager, list, /*include_ignored=*/false, &result);
960 EXPECT_EQ(1u, result.size());
961 EXPECT_EQ(if_name2, result[0]->name());
962
963 MergeNetworkList(manager, result, &changed);
964 ReleaseIfAddrs(list);
965 }
966
967 #endif // defined(WEBRTC_POSIX)
968
969 // Test MergeNetworkList successfully combines all IPs for the same
970 // prefix/length into a single Network.
TEST_F(NetworkTest,TestMergeNetworkList)971 TEST_F(NetworkTest, TestMergeNetworkList) {
972 BasicNetworkManager manager;
973 NetworkManager::NetworkList list;
974
975 // Create 2 IPAddress classes with only last digit different.
976 IPAddress ip1, ip2;
977 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
978 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:2", &ip2));
979
980 // Create 2 networks with the same prefix and length.
981 Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
982 Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
983
984 // Add different IP into each.
985 net1->AddIP(ip1);
986 net2->AddIP(ip2);
987
988 list.push_back(net1);
989 list.push_back(net2);
990 bool changed;
991 MergeNetworkList(manager, list, &changed);
992 EXPECT_TRUE(changed);
993
994 NetworkManager::NetworkList list2;
995 manager.GetNetworks(&list2);
996
997 // Make sure the resulted networklist has only 1 element and 2
998 // IPAddresses.
999 EXPECT_EQ(list2.size(), 1uL);
1000 EXPECT_EQ(list2[0]->GetIPs().size(), 2uL);
1001 EXPECT_EQ(list2[0]->GetIPs()[0], InterfaceAddress(ip1));
1002 EXPECT_EQ(list2[0]->GetIPs()[1], InterfaceAddress(ip2));
1003 }
1004
1005 // Test that MergeNetworkList successfully detects the change if
1006 // a network becomes inactive and then active again.
TEST_F(NetworkTest,TestMergeNetworkListWithInactiveNetworks)1007 TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) {
1008 BasicNetworkManager manager;
1009 Network network1("test_wifi", "Test Network Adapter 1",
1010 IPAddress(0x12345600U), 24);
1011 Network network2("test_eth0", "Test Network Adapter 2",
1012 IPAddress(0x00010000U), 16);
1013 network1.AddIP(IPAddress(0x12345678));
1014 network2.AddIP(IPAddress(0x00010004));
1015 NetworkManager::NetworkList list;
1016 Network* net1 = new Network(network1);
1017 list.push_back(net1);
1018 bool changed;
1019 MergeNetworkList(manager, list, &changed);
1020 EXPECT_TRUE(changed);
1021 list.clear();
1022 manager.GetNetworks(&list);
1023 ASSERT_EQ(1U, list.size());
1024 EXPECT_EQ(net1, list[0]);
1025
1026 list.clear();
1027 Network* net2 = new Network(network2);
1028 list.push_back(net2);
1029 MergeNetworkList(manager, list, &changed);
1030 EXPECT_TRUE(changed);
1031 list.clear();
1032 manager.GetNetworks(&list);
1033 ASSERT_EQ(1U, list.size());
1034 EXPECT_EQ(net2, list[0]);
1035
1036 // Now network1 is inactive. Try to merge it again.
1037 list.clear();
1038 list.push_back(new Network(network1));
1039 MergeNetworkList(manager, list, &changed);
1040 EXPECT_TRUE(changed);
1041 list.clear();
1042 manager.GetNetworks(&list);
1043 ASSERT_EQ(1U, list.size());
1044 EXPECT_TRUE(list[0]->active());
1045 EXPECT_EQ(net1, list[0]);
1046 }
1047
1048 // Test that the filtering logic follows the defined ruleset in network.h.
TEST_F(NetworkTest,TestIPv6Selection)1049 TEST_F(NetworkTest, TestIPv6Selection) {
1050 InterfaceAddress ip;
1051 std::string ipstr;
1052
1053 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3";
1054 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
1055
1056 // Create a network with this prefix.
1057 Network ipv6_network("test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64),
1058 64);
1059
1060 // When there is no address added, it should return an unspecified
1061 // address.
1062 EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
1063 EXPECT_TRUE(IPIsUnspec(ipv6_network.GetBestIP()));
1064
1065 // Deprecated one should not be returned.
1066 ipv6_network.AddIP(ip);
1067 EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
1068
1069 // Add ULA one. ULA is unique local address which is starting either
1070 // with 0xfc or 0xfd.
1071 ipstr = "fd00:fa00:4:1000:be30:5bff:fee5:c4";
1072 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
1073 ipv6_network.AddIP(ip);
1074 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
1075
1076 // Add global one.
1077 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c5";
1078 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
1079 ipv6_network.AddIP(ip);
1080 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
1081
1082 // Add global dynamic temporary one.
1083 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6";
1084 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
1085 ipv6_network.AddIP(ip);
1086 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
1087 }
1088
TEST_F(NetworkTest,TestNetworkMonitoring)1089 TEST_F(NetworkTest, TestNetworkMonitoring) {
1090 FakeNetworkMonitorFactory factory;
1091 BasicNetworkManager manager(&factory);
1092 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
1093 &NetworkTest::OnNetworksChanged);
1094 manager.StartUpdating();
1095 FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager);
1096 EXPECT_TRUE(network_monitor && network_monitor->started());
1097 EXPECT_TRUE_WAIT(callback_called_, 1000);
1098 callback_called_ = false;
1099
1100 // Clear the networks so that there will be network changes below.
1101 ClearNetworks(manager);
1102 // Network manager is started, so the callback is called when the network
1103 // monitor fires the network-change event.
1104 network_monitor->SignalNetworksChanged();
1105 EXPECT_TRUE_WAIT(callback_called_, 1000);
1106
1107 // Network manager is stopped.
1108 manager.StopUpdating();
1109 EXPECT_FALSE(GetNetworkMonitor(manager)->started());
1110 }
1111
1112 // Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
1113 #if defined(WEBRTC_ANDROID)
1114 #define MAYBE_DefaultLocalAddress DISABLED_DefaultLocalAddress
1115 #else
1116 #define MAYBE_DefaultLocalAddress DefaultLocalAddress
1117 #endif
TEST_F(NetworkTest,MAYBE_DefaultLocalAddress)1118 TEST_F(NetworkTest, MAYBE_DefaultLocalAddress) {
1119 IPAddress ip;
1120 FakeNetworkMonitorFactory factory;
1121 TestBasicNetworkManager manager(&factory);
1122 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
1123 &NetworkTest::OnNetworksChanged);
1124 manager.StartUpdating();
1125 EXPECT_TRUE_WAIT(callback_called_, 1000);
1126
1127 // Make sure we can query default local address when an address for such
1128 // address family exists.
1129 std::vector<Network*> networks;
1130 manager.GetNetworks(&networks);
1131 EXPECT_TRUE(!networks.empty());
1132 for (const auto* network : networks) {
1133 if (network->GetBestIP().family() == AF_INET) {
1134 EXPECT_TRUE(QueryDefaultLocalAddress(manager, AF_INET) != IPAddress());
1135 } else if (network->GetBestIP().family() == AF_INET6 &&
1136 !IPIsLoopback(network->GetBestIP())) {
1137 // Existence of an IPv6 loopback address doesn't mean it has IPv6 network
1138 // enabled.
1139 EXPECT_TRUE(QueryDefaultLocalAddress(manager, AF_INET6) != IPAddress());
1140 }
1141 }
1142
1143 // GetDefaultLocalAddress should return the valid default address after set.
1144 manager.set_default_local_addresses(GetLoopbackIP(AF_INET),
1145 GetLoopbackIP(AF_INET6));
1146 EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET, &ip));
1147 EXPECT_EQ(ip, GetLoopbackIP(AF_INET));
1148 EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip));
1149 EXPECT_EQ(ip, GetLoopbackIP(AF_INET6));
1150
1151 // More tests on GetDefaultLocalAddress with ipv6 addresses where the set
1152 // default address may be different from the best IP address of any network.
1153 InterfaceAddress ip1;
1154 EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:1111",
1155 IPV6_ADDRESS_FLAG_TEMPORARY, &ip1));
1156 // Create a network with a prefix of ip1.
1157 Network ipv6_network("test_eth0", "Test NetworkAdapter", TruncateIP(ip1, 64),
1158 64);
1159 IPAddress ip2;
1160 EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:2222", &ip2));
1161 ipv6_network.AddIP(ip1);
1162 ipv6_network.AddIP(ip2);
1163 BasicNetworkManager::NetworkList list(1, new Network(ipv6_network));
1164 bool changed;
1165 MergeNetworkList(manager, list, &changed);
1166 // If the set default address is not in any network, GetDefaultLocalAddress
1167 // should return it.
1168 IPAddress ip3;
1169 EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:3333", &ip3));
1170 manager.set_default_local_addresses(GetLoopbackIP(AF_INET), ip3);
1171 EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip));
1172 EXPECT_EQ(ip3, ip);
1173 // If the set default address is in a network, GetDefaultLocalAddress will
1174 // return the best IP in that network.
1175 manager.set_default_local_addresses(GetLoopbackIP(AF_INET), ip2);
1176 EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip));
1177 EXPECT_EQ(static_cast<IPAddress>(ip1), ip);
1178
1179 manager.StopUpdating();
1180 }
1181
1182 // Test that MergeNetworkList does not set change = true
1183 // when changing from cellular_X to cellular_Y.
TEST_F(NetworkTest,TestWhenNetworkListChangeReturnsChangedFlag)1184 TEST_F(NetworkTest, TestWhenNetworkListChangeReturnsChangedFlag) {
1185 BasicNetworkManager manager;
1186
1187 IPAddress ip1;
1188 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
1189 Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
1190 net1->set_type(ADAPTER_TYPE_CELLULAR_3G);
1191 net1->AddIP(ip1);
1192 NetworkManager::NetworkList list;
1193 list.push_back(net1);
1194
1195 {
1196 bool changed;
1197 MergeNetworkList(manager, list, &changed);
1198 EXPECT_TRUE(changed);
1199 NetworkManager::NetworkList list2;
1200 manager.GetNetworks(&list2);
1201 EXPECT_EQ(list2.size(), 1uL);
1202 EXPECT_EQ(ADAPTER_TYPE_CELLULAR_3G, list2[0]->type());
1203 }
1204
1205 // Modify net1 from 3G to 4G
1206 {
1207 Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
1208 net2->set_type(ADAPTER_TYPE_CELLULAR_4G);
1209 net2->AddIP(ip1);
1210 list.clear();
1211 list.push_back(net2);
1212 bool changed;
1213 MergeNetworkList(manager, list, &changed);
1214
1215 // Change from 3G to 4G shall not trigger OnNetworksChanged,
1216 // i.e changed = false.
1217 EXPECT_FALSE(changed);
1218 NetworkManager::NetworkList list2;
1219 manager.GetNetworks(&list2);
1220 ASSERT_EQ(list2.size(), 1uL);
1221 EXPECT_EQ(ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
1222 }
1223
1224 // Don't modify.
1225 {
1226 Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
1227 net2->set_type(ADAPTER_TYPE_CELLULAR_4G);
1228 net2->AddIP(ip1);
1229 list.clear();
1230 list.push_back(net2);
1231 bool changed;
1232 MergeNetworkList(manager, list, &changed);
1233
1234 // No change.
1235 EXPECT_FALSE(changed);
1236 NetworkManager::NetworkList list2;
1237 manager.GetNetworks(&list2);
1238 ASSERT_EQ(list2.size(), 1uL);
1239 EXPECT_EQ(ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
1240 }
1241 }
1242
1243 } // namespace rtc
1244