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