1 /* 2 * Copyright 2004 The WebRTC Project Authors. All rights reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "webrtc/base/network.h" 12 13 #include "webrtc/base/nethelpers.h" 14 #include "webrtc/base/networkmonitor.h" 15 #include <vector> 16 #if defined(WEBRTC_POSIX) 17 #include <sys/types.h> 18 #include <net/if.h> 19 #include "webrtc/base/ifaddrs_converter.h" 20 #endif // defined(WEBRTC_POSIX) 21 #include "webrtc/base/gunit.h" 22 #if defined(WEBRTC_WIN) 23 #include "webrtc/base/logging.h" // For LOG_GLE 24 #endif 25 26 namespace rtc { 27 28 namespace { 29 30 class FakeNetworkMonitor : public NetworkMonitorBase { 31 public: 32 void Start() override {} 33 void Stop() override {} 34 }; 35 36 class FakeNetworkMonitorFactory : public NetworkMonitorFactory { 37 public: 38 FakeNetworkMonitorFactory() {} 39 NetworkMonitorInterface* CreateNetworkMonitor() { 40 return new FakeNetworkMonitor(); 41 } 42 }; 43 44 } // namespace 45 46 class NetworkTest : public testing::Test, public sigslot::has_slots<> { 47 public: 48 NetworkTest() : callback_called_(false) {} 49 50 void OnNetworksChanged() { 51 callback_called_ = true; 52 } 53 54 NetworkManager::Stats MergeNetworkList( 55 BasicNetworkManager& network_manager, 56 const NetworkManager::NetworkList& list, 57 bool* changed) { 58 NetworkManager::Stats stats; 59 network_manager.MergeNetworkList(list, changed, &stats); 60 return stats; 61 } 62 63 bool IsIgnoredNetwork(BasicNetworkManager& network_manager, 64 const Network& network) { 65 return network_manager.IsIgnoredNetwork(network); 66 } 67 68 NetworkManager::NetworkList GetNetworks( 69 const BasicNetworkManager& network_manager, bool include_ignored) { 70 NetworkManager::NetworkList list; 71 network_manager.CreateNetworks(include_ignored, &list); 72 return list; 73 } 74 75 NetworkMonitorInterface* GetNetworkMonitor( 76 BasicNetworkManager& network_manager) { 77 return network_manager.network_monitor_.get(); 78 } 79 void ClearNetworks(BasicNetworkManager& network_manager) { 80 for (const auto& kv : network_manager.networks_map_) { 81 delete kv.second; 82 } 83 network_manager.networks_.clear(); 84 network_manager.networks_map_.clear(); 85 } 86 87 #if defined(WEBRTC_POSIX) 88 // Separated from CreateNetworks for tests. 89 static void CallConvertIfAddrs(const BasicNetworkManager& network_manager, 90 struct ifaddrs* interfaces, 91 bool include_ignored, 92 NetworkManager::NetworkList* networks) { 93 // Use the base IfAddrsConverter for test cases. 94 rtc::scoped_ptr<IfAddrsConverter> ifaddrs_converter(new IfAddrsConverter()); 95 network_manager.ConvertIfAddrs(interfaces, ifaddrs_converter.get(), 96 include_ignored, networks); 97 } 98 99 struct sockaddr_in6* CreateIpv6Addr(const std::string& ip_string, 100 uint32_t scope_id) { 101 struct sockaddr_in6* ipv6_addr = new struct sockaddr_in6; 102 memset(ipv6_addr, 0, sizeof(struct sockaddr_in6)); 103 ipv6_addr->sin6_family = AF_INET6; 104 ipv6_addr->sin6_scope_id = scope_id; 105 IPAddress ip; 106 IPFromString(ip_string, &ip); 107 ipv6_addr->sin6_addr = ip.ipv6_address(); 108 return ipv6_addr; 109 } 110 111 // Pointers created here need to be released via ReleaseIfAddrs. 112 struct ifaddrs* AddIpv6Address(struct ifaddrs* list, 113 char* if_name, 114 const std::string& ipv6_address, 115 const std::string& ipv6_netmask, 116 uint32_t scope_id) { 117 struct ifaddrs* if_addr = new struct ifaddrs; 118 memset(if_addr, 0, sizeof(struct ifaddrs)); 119 if_addr->ifa_name = if_name; 120 if_addr->ifa_addr = reinterpret_cast<struct sockaddr*>( 121 CreateIpv6Addr(ipv6_address, scope_id)); 122 if_addr->ifa_netmask = 123 reinterpret_cast<struct sockaddr*>(CreateIpv6Addr(ipv6_netmask, 0)); 124 if_addr->ifa_next = list; 125 if_addr->ifa_flags = IFF_RUNNING; 126 return if_addr; 127 } 128 129 void ReleaseIfAddrs(struct ifaddrs* list) { 130 struct ifaddrs* if_addr = list; 131 while (if_addr != nullptr) { 132 struct ifaddrs* next_addr = if_addr->ifa_next; 133 delete if_addr->ifa_addr; 134 delete if_addr->ifa_netmask; 135 delete if_addr; 136 if_addr = next_addr; 137 } 138 } 139 #endif // defined(WEBRTC_POSIX) 140 141 protected: 142 bool callback_called_; 143 }; 144 145 class TestBasicNetworkManager : public BasicNetworkManager { 146 public: 147 using BasicNetworkManager::QueryDefaultLocalAddress; 148 using BasicNetworkManager::set_default_local_addresses; 149 }; 150 151 // Test that the Network ctor works properly. 152 TEST_F(NetworkTest, TestNetworkConstruct) { 153 Network ipv4_network1("test_eth0", "Test Network Adapter 1", 154 IPAddress(0x12345600U), 24); 155 EXPECT_EQ("test_eth0", ipv4_network1.name()); 156 EXPECT_EQ("Test Network Adapter 1", ipv4_network1.description()); 157 EXPECT_EQ(IPAddress(0x12345600U), ipv4_network1.prefix()); 158 EXPECT_EQ(24, ipv4_network1.prefix_length()); 159 EXPECT_FALSE(ipv4_network1.ignored()); 160 } 161 162 TEST_F(NetworkTest, TestIsIgnoredNetworkIgnoresIPsStartingWith0) { 163 Network ipv4_network1("test_eth0", "Test Network Adapter 1", 164 IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET); 165 Network ipv4_network2("test_eth1", "Test Network Adapter 2", 166 IPAddress(0x010000U), 24, ADAPTER_TYPE_ETHERNET); 167 BasicNetworkManager network_manager; 168 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1)); 169 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network2)); 170 } 171 172 // TODO(phoglund): Remove when ignore list goes away. 173 TEST_F(NetworkTest, TestIgnoreList) { 174 Network ignore_me("ignore_me", "Ignore me please!", 175 IPAddress(0x12345600U), 24); 176 Network include_me("include_me", "Include me please!", 177 IPAddress(0x12345600U), 24); 178 BasicNetworkManager network_manager; 179 EXPECT_FALSE(IsIgnoredNetwork(network_manager, ignore_me)); 180 EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me)); 181 std::vector<std::string> ignore_list; 182 ignore_list.push_back("ignore_me"); 183 network_manager.set_network_ignore_list(ignore_list); 184 EXPECT_TRUE(IsIgnoredNetwork(network_manager, ignore_me)); 185 EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me)); 186 } 187 188 // Test is failing on Windows opt: b/11288214 189 TEST_F(NetworkTest, DISABLED_TestCreateNetworks) { 190 BasicNetworkManager manager; 191 NetworkManager::NetworkList result = GetNetworks(manager, true); 192 // We should be able to bind to any addresses we find. 193 NetworkManager::NetworkList::iterator it; 194 for (it = result.begin(); 195 it != result.end(); 196 ++it) { 197 sockaddr_storage storage; 198 memset(&storage, 0, sizeof(storage)); 199 IPAddress ip = (*it)->GetBestIP(); 200 SocketAddress bindaddress(ip, 0); 201 bindaddress.SetScopeID((*it)->scope_id()); 202 // TODO(thaloun): Use rtc::AsyncSocket once it supports IPv6. 203 int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP)); 204 if (fd > 0) { 205 size_t ipsize = bindaddress.ToSockAddrStorage(&storage); 206 EXPECT_GE(ipsize, 0U); 207 int success = ::bind(fd, 208 reinterpret_cast<sockaddr*>(&storage), 209 static_cast<int>(ipsize)); 210 #if defined(WEBRTC_WIN) 211 if (success) LOG_GLE(LS_ERROR) << "Socket bind failed."; 212 #endif 213 EXPECT_EQ(0, success); 214 #if defined(WEBRTC_WIN) 215 closesocket(fd); 216 #else 217 close(fd); 218 #endif 219 } 220 delete (*it); 221 } 222 } 223 224 // Test StartUpdating() and StopUpdating(). network_permission_state starts with 225 // ALLOWED. 226 TEST_F(NetworkTest, TestUpdateNetworks) { 227 BasicNetworkManager manager; 228 manager.SignalNetworksChanged.connect( 229 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged); 230 EXPECT_EQ(NetworkManager::ENUMERATION_ALLOWED, 231 manager.enumeration_permission()); 232 manager.StartUpdating(); 233 Thread::Current()->ProcessMessages(0); 234 EXPECT_TRUE(callback_called_); 235 callback_called_ = false; 236 // Callback should be triggered immediately when StartUpdating 237 // is called, after network update signal is already sent. 238 manager.StartUpdating(); 239 EXPECT_TRUE(manager.started()); 240 Thread::Current()->ProcessMessages(0); 241 EXPECT_TRUE(callback_called_); 242 manager.StopUpdating(); 243 EXPECT_TRUE(manager.started()); 244 manager.StopUpdating(); 245 EXPECT_EQ(NetworkManager::ENUMERATION_ALLOWED, 246 manager.enumeration_permission()); 247 EXPECT_FALSE(manager.started()); 248 manager.StopUpdating(); 249 EXPECT_FALSE(manager.started()); 250 callback_called_ = false; 251 // Callback should be triggered immediately after StartUpdating is called 252 // when start_count_ is reset to 0. 253 manager.StartUpdating(); 254 Thread::Current()->ProcessMessages(0); 255 EXPECT_TRUE(callback_called_); 256 } 257 258 // Verify that MergeNetworkList() merges network lists properly. 259 TEST_F(NetworkTest, TestBasicMergeNetworkList) { 260 Network ipv4_network1("test_eth0", "Test Network Adapter 1", 261 IPAddress(0x12345600U), 24); 262 Network ipv4_network2("test_eth1", "Test Network Adapter 2", 263 IPAddress(0x00010000U), 16); 264 ipv4_network1.AddIP(IPAddress(0x12345678)); 265 ipv4_network2.AddIP(IPAddress(0x00010004)); 266 BasicNetworkManager manager; 267 268 // Add ipv4_network1 to the list of networks. 269 NetworkManager::NetworkList list; 270 list.push_back(new Network(ipv4_network1)); 271 bool changed; 272 NetworkManager::Stats stats = MergeNetworkList(manager, list, &changed); 273 EXPECT_TRUE(changed); 274 EXPECT_EQ(stats.ipv6_network_count, 0); 275 EXPECT_EQ(stats.ipv4_network_count, 1); 276 list.clear(); 277 278 manager.GetNetworks(&list); 279 EXPECT_EQ(1U, list.size()); 280 EXPECT_EQ(ipv4_network1.ToString(), list[0]->ToString()); 281 Network* net1 = list[0]; 282 list.clear(); 283 284 // Replace ipv4_network1 with ipv4_network2. 285 list.push_back(new Network(ipv4_network2)); 286 stats = MergeNetworkList(manager, list, &changed); 287 EXPECT_TRUE(changed); 288 EXPECT_EQ(stats.ipv6_network_count, 0); 289 EXPECT_EQ(stats.ipv4_network_count, 1); 290 list.clear(); 291 292 manager.GetNetworks(&list); 293 EXPECT_EQ(1U, list.size()); 294 EXPECT_EQ(ipv4_network2.ToString(), list[0]->ToString()); 295 Network* net2 = list[0]; 296 list.clear(); 297 298 // Add Network2 back. 299 list.push_back(new Network(ipv4_network1)); 300 list.push_back(new Network(ipv4_network2)); 301 stats = MergeNetworkList(manager, list, &changed); 302 EXPECT_TRUE(changed); 303 EXPECT_EQ(stats.ipv6_network_count, 0); 304 EXPECT_EQ(stats.ipv4_network_count, 2); 305 list.clear(); 306 307 // Verify that we get previous instances of Network objects. 308 manager.GetNetworks(&list); 309 EXPECT_EQ(2U, list.size()); 310 EXPECT_TRUE((net1 == list[0] && net2 == list[1]) || 311 (net1 == list[1] && net2 == list[0])); 312 list.clear(); 313 314 // Call MergeNetworkList() again and verify that we don't get update 315 // notification. 316 list.push_back(new Network(ipv4_network2)); 317 list.push_back(new Network(ipv4_network1)); 318 stats = MergeNetworkList(manager, list, &changed); 319 EXPECT_FALSE(changed); 320 EXPECT_EQ(stats.ipv6_network_count, 0); 321 EXPECT_EQ(stats.ipv4_network_count, 2); 322 list.clear(); 323 324 // Verify that we get previous instances of Network objects. 325 manager.GetNetworks(&list); 326 EXPECT_EQ(2U, list.size()); 327 EXPECT_TRUE((net1 == list[0] && net2 == list[1]) || 328 (net1 == list[1] && net2 == list[0])); 329 list.clear(); 330 } 331 332 // Sets up some test IPv6 networks and appends them to list. 333 // Four networks are added - public and link local, for two interfaces. 334 void SetupNetworks(NetworkManager::NetworkList* list) { 335 IPAddress ip; 336 IPAddress prefix; 337 EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:ef12", &ip)); 338 EXPECT_TRUE(IPFromString("abcd::", &prefix)); 339 // First, fake link-locals. 340 Network ipv6_eth0_linklocalnetwork("test_eth0", "Test NetworkAdapter 1", 341 prefix, 64); 342 ipv6_eth0_linklocalnetwork.AddIP(ip); 343 EXPECT_TRUE(IPFromString("abcd::5678:abcd:ef12:3456", &ip)); 344 Network ipv6_eth1_linklocalnetwork("test_eth1", "Test NetworkAdapter 2", 345 prefix, 64); 346 ipv6_eth1_linklocalnetwork.AddIP(ip); 347 // Public networks: 348 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip)); 349 prefix = TruncateIP(ip, 64); 350 Network ipv6_eth0_publicnetwork1_ip1("test_eth0", "Test NetworkAdapter 1", 351 prefix, 64); 352 ipv6_eth0_publicnetwork1_ip1.AddIP(ip); 353 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip)); 354 prefix = TruncateIP(ip, 64); 355 Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 1", 356 prefix, 64); 357 ipv6_eth1_publicnetwork1_ip1.AddIP(ip); 358 list->push_back(new Network(ipv6_eth0_linklocalnetwork)); 359 list->push_back(new Network(ipv6_eth1_linklocalnetwork)); 360 list->push_back(new Network(ipv6_eth0_publicnetwork1_ip1)); 361 list->push_back(new Network(ipv6_eth1_publicnetwork1_ip1)); 362 } 363 364 // Test that the basic network merging case works. 365 TEST_F(NetworkTest, TestIPv6MergeNetworkList) { 366 BasicNetworkManager manager; 367 manager.SignalNetworksChanged.connect( 368 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged); 369 NetworkManager::NetworkList original_list; 370 SetupNetworks(&original_list); 371 bool changed = false; 372 NetworkManager::Stats stats = 373 MergeNetworkList(manager, original_list, &changed); 374 EXPECT_TRUE(changed); 375 EXPECT_EQ(stats.ipv6_network_count, 4); 376 EXPECT_EQ(stats.ipv4_network_count, 0); 377 NetworkManager::NetworkList list; 378 manager.GetNetworks(&list); 379 EXPECT_EQ(original_list.size(), list.size()); 380 // Verify that the original members are in the merged list. 381 for (NetworkManager::NetworkList::iterator it = original_list.begin(); 382 it != original_list.end(); ++it) { 383 EXPECT_NE(list.end(), std::find(list.begin(), list.end(), *it)); 384 } 385 } 386 387 // Test that no more than manager.max_ipv6_networks() IPv6 networks get 388 // returned. 389 TEST_F(NetworkTest, TestIPv6MergeNetworkListTrimExcessive) { 390 BasicNetworkManager manager; 391 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this), 392 &NetworkTest::OnNetworksChanged); 393 NetworkManager::NetworkList original_list; 394 395 // Add twice the allowed number of IPv6 networks. 396 for (int i = 0; i < 2 * manager.max_ipv6_networks(); i++) { 397 // Make a network with different prefix length. 398 IPAddress ip; 399 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip)); 400 IPAddress prefix = TruncateIP(ip, 64 - i); 401 Network* ipv6_network = 402 new Network("test_eth0", "Test Network Adapter 1", prefix, 64 - i); 403 ipv6_network->AddIP(ip); 404 original_list.push_back(ipv6_network); 405 } 406 407 // Add one IPv4 network. 408 Network* ipv4_network = new Network("test_eth0", "Test Network Adapter 1", 409 IPAddress(0x12345600U), 24); 410 ipv4_network->AddIP(IPAddress(0x12345600U)); 411 original_list.push_back(ipv4_network); 412 413 bool changed = false; 414 MergeNetworkList(manager, original_list, &changed); 415 EXPECT_TRUE(changed); 416 NetworkManager::NetworkList list; 417 manager.GetNetworks(&list); 418 419 // List size should be the max allowed IPv6 networks plus one IPv4 network. 420 EXPECT_EQ(manager.max_ipv6_networks() + 1, (int)list.size()); 421 422 // Verify that the IPv4 network is in the list. 423 EXPECT_NE(list.end(), std::find(list.begin(), list.end(), ipv4_network)); 424 } 425 426 // Tests that when two network lists that describe the same set of networks are 427 // merged, that the changed callback is not called, and that the original 428 // objects remain in the result list. 429 TEST_F(NetworkTest, TestNoChangeMerge) { 430 BasicNetworkManager manager; 431 manager.SignalNetworksChanged.connect( 432 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged); 433 NetworkManager::NetworkList original_list; 434 SetupNetworks(&original_list); 435 bool changed = false; 436 MergeNetworkList(manager, original_list, &changed); 437 EXPECT_TRUE(changed); 438 // Second list that describes the same networks but with new objects. 439 NetworkManager::NetworkList second_list; 440 SetupNetworks(&second_list); 441 changed = false; 442 MergeNetworkList(manager, second_list, &changed); 443 EXPECT_FALSE(changed); 444 NetworkManager::NetworkList resulting_list; 445 manager.GetNetworks(&resulting_list); 446 EXPECT_EQ(original_list.size(), resulting_list.size()); 447 // Verify that the original members are in the merged list. 448 for (NetworkManager::NetworkList::iterator it = original_list.begin(); 449 it != original_list.end(); ++it) { 450 EXPECT_NE(resulting_list.end(), 451 std::find(resulting_list.begin(), resulting_list.end(), *it)); 452 } 453 // Doublecheck that the new networks aren't in the list. 454 for (NetworkManager::NetworkList::iterator it = second_list.begin(); 455 it != second_list.end(); ++it) { 456 EXPECT_EQ(resulting_list.end(), 457 std::find(resulting_list.begin(), resulting_list.end(), *it)); 458 } 459 } 460 461 // Test that we can merge a network that is the same as another network but with 462 // a different IP. The original network should remain in the list, but have its 463 // IP changed. 464 TEST_F(NetworkTest, MergeWithChangedIP) { 465 BasicNetworkManager manager; 466 manager.SignalNetworksChanged.connect( 467 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged); 468 NetworkManager::NetworkList original_list; 469 SetupNetworks(&original_list); 470 // Make a network that we're going to change. 471 IPAddress ip; 472 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip)); 473 IPAddress prefix = TruncateIP(ip, 64); 474 Network* network_to_change = new Network("test_eth0", 475 "Test Network Adapter 1", 476 prefix, 64); 477 Network* changed_network = new Network(*network_to_change); 478 network_to_change->AddIP(ip); 479 IPAddress changed_ip; 480 EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip)); 481 changed_network->AddIP(changed_ip); 482 original_list.push_back(network_to_change); 483 bool changed = false; 484 MergeNetworkList(manager, original_list, &changed); 485 NetworkManager::NetworkList second_list; 486 SetupNetworks(&second_list); 487 second_list.push_back(changed_network); 488 changed = false; 489 MergeNetworkList(manager, second_list, &changed); 490 EXPECT_TRUE(changed); 491 NetworkManager::NetworkList list; 492 manager.GetNetworks(&list); 493 EXPECT_EQ(original_list.size(), list.size()); 494 // Make sure the original network is still in the merged list. 495 EXPECT_NE(list.end(), 496 std::find(list.begin(), list.end(), network_to_change)); 497 EXPECT_EQ(changed_ip, network_to_change->GetIPs().at(0)); 498 } 499 500 // Testing a similar case to above, but checking that a network can be updated 501 // with additional IPs (not just a replacement). 502 TEST_F(NetworkTest, TestMultipleIPMergeNetworkList) { 503 BasicNetworkManager manager; 504 manager.SignalNetworksChanged.connect( 505 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged); 506 NetworkManager::NetworkList original_list; 507 SetupNetworks(&original_list); 508 bool changed = false; 509 MergeNetworkList(manager, original_list, &changed); 510 EXPECT_TRUE(changed); 511 IPAddress ip; 512 IPAddress check_ip; 513 IPAddress prefix; 514 // Add a second IP to the public network on eth0 (2401:fa00:4:1000/64). 515 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip)); 516 prefix = TruncateIP(ip, 64); 517 Network ipv6_eth0_publicnetwork1_ip2("test_eth0", "Test NetworkAdapter 1", 518 prefix, 64); 519 // This is the IP that already existed in the public network on eth0. 520 EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip)); 521 ipv6_eth0_publicnetwork1_ip2.AddIP(ip); 522 original_list.push_back(new Network(ipv6_eth0_publicnetwork1_ip2)); 523 changed = false; 524 MergeNetworkList(manager, original_list, &changed); 525 EXPECT_TRUE(changed); 526 // There should still be four networks. 527 NetworkManager::NetworkList list; 528 manager.GetNetworks(&list); 529 EXPECT_EQ(4U, list.size()); 530 // Check the gathered IPs. 531 int matchcount = 0; 532 for (NetworkManager::NetworkList::iterator it = list.begin(); 533 it != list.end(); ++it) { 534 if ((*it)->ToString() == original_list[2]->ToString()) { 535 ++matchcount; 536 EXPECT_EQ(1, matchcount); 537 // This should be the same network object as before. 538 EXPECT_EQ((*it), original_list[2]); 539 // But with two addresses now. 540 EXPECT_EQ(2U, (*it)->GetIPs().size()); 541 EXPECT_NE((*it)->GetIPs().end(), 542 std::find((*it)->GetIPs().begin(), 543 (*it)->GetIPs().end(), 544 check_ip)); 545 EXPECT_NE((*it)->GetIPs().end(), 546 std::find((*it)->GetIPs().begin(), 547 (*it)->GetIPs().end(), 548 ip)); 549 } else { 550 // Check the IP didn't get added anywhere it wasn't supposed to. 551 EXPECT_EQ((*it)->GetIPs().end(), 552 std::find((*it)->GetIPs().begin(), 553 (*it)->GetIPs().end(), 554 ip)); 555 } 556 } 557 } 558 559 // Test that merge correctly distinguishes multiple networks on an interface. 560 TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) { 561 BasicNetworkManager manager; 562 manager.SignalNetworksChanged.connect( 563 static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged); 564 NetworkManager::NetworkList original_list; 565 SetupNetworks(&original_list); 566 bool changed = false; 567 MergeNetworkList(manager, original_list, &changed); 568 EXPECT_TRUE(changed); 569 IPAddress ip; 570 IPAddress prefix; 571 // A second network for eth0. 572 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip)); 573 prefix = TruncateIP(ip, 64); 574 Network ipv6_eth0_publicnetwork2_ip1("test_eth0", "Test NetworkAdapter 1", 575 prefix, 64); 576 ipv6_eth0_publicnetwork2_ip1.AddIP(ip); 577 original_list.push_back(new Network(ipv6_eth0_publicnetwork2_ip1)); 578 changed = false; 579 MergeNetworkList(manager, original_list, &changed); 580 EXPECT_TRUE(changed); 581 // There should be five networks now. 582 NetworkManager::NetworkList list; 583 manager.GetNetworks(&list); 584 EXPECT_EQ(5U, list.size()); 585 // Check the resulting addresses. 586 for (NetworkManager::NetworkList::iterator it = list.begin(); 587 it != list.end(); ++it) { 588 if ((*it)->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() && 589 (*it)->name() == ipv6_eth0_publicnetwork2_ip1.name()) { 590 // Check the new network has 1 IP and that it's the correct one. 591 EXPECT_EQ(1U, (*it)->GetIPs().size()); 592 EXPECT_EQ(ip, (*it)->GetIPs().at(0)); 593 } else { 594 // Check the IP didn't get added anywhere it wasn't supposed to. 595 EXPECT_EQ((*it)->GetIPs().end(), 596 std::find((*it)->GetIPs().begin(), 597 (*it)->GetIPs().end(), 598 ip)); 599 } 600 } 601 } 602 603 // Test that DumpNetworks does not crash. 604 TEST_F(NetworkTest, TestCreateAndDumpNetworks) { 605 BasicNetworkManager manager; 606 NetworkManager::NetworkList list = GetNetworks(manager, true); 607 bool changed; 608 MergeNetworkList(manager, list, &changed); 609 manager.DumpNetworks(); 610 } 611 612 // Test that we can toggle IPv6 on and off. 613 // Crashes on Linux. See webrtc:4923. 614 #if defined(WEBRTC_LINUX) 615 #define MAYBE_TestIPv6Toggle DISABLED_TestIPv6Toggle 616 #else 617 #define MAYBE_TestIPv6Toggle TestIPv6Toggle 618 #endif 619 TEST_F(NetworkTest, MAYBE_TestIPv6Toggle) { 620 BasicNetworkManager manager; 621 bool ipv6_found = false; 622 NetworkManager::NetworkList list; 623 #if !defined(WEBRTC_WIN) 624 // There should be at least one IPv6 network (fe80::/64 should be in there). 625 // TODO(thaloun): Disabling this test on windows for the moment as the test 626 // machines don't seem to have IPv6 installed on them at all. 627 manager.set_ipv6_enabled(true); 628 list = GetNetworks(manager, true); 629 for (NetworkManager::NetworkList::iterator it = list.begin(); 630 it != list.end(); ++it) { 631 if ((*it)->prefix().family() == AF_INET6) { 632 ipv6_found = true; 633 break; 634 } 635 } 636 EXPECT_TRUE(ipv6_found); 637 for (NetworkManager::NetworkList::iterator it = list.begin(); 638 it != list.end(); ++it) { 639 delete (*it); 640 } 641 #endif 642 ipv6_found = false; 643 manager.set_ipv6_enabled(false); 644 list = GetNetworks(manager, true); 645 for (NetworkManager::NetworkList::iterator it = list.begin(); 646 it != list.end(); ++it) { 647 if ((*it)->prefix().family() == AF_INET6) { 648 ipv6_found = true; 649 break; 650 } 651 } 652 EXPECT_FALSE(ipv6_found); 653 for (NetworkManager::NetworkList::iterator it = list.begin(); 654 it != list.end(); ++it) { 655 delete (*it); 656 } 657 } 658 659 TEST_F(NetworkTest, TestNetworkListSorting) { 660 BasicNetworkManager manager; 661 Network ipv4_network1("test_eth0", "Test Network Adapter 1", 662 IPAddress(0x12345600U), 24); 663 ipv4_network1.AddIP(IPAddress(0x12345600U)); 664 665 IPAddress ip; 666 IPAddress prefix; 667 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip)); 668 prefix = TruncateIP(ip, 64); 669 Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 2", 670 prefix, 64); 671 ipv6_eth1_publicnetwork1_ip1.AddIP(ip); 672 673 NetworkManager::NetworkList list; 674 list.push_back(new Network(ipv4_network1)); 675 list.push_back(new Network(ipv6_eth1_publicnetwork1_ip1)); 676 Network* net1 = list[0]; 677 Network* net2 = list[1]; 678 679 bool changed = false; 680 MergeNetworkList(manager, list, &changed); 681 ASSERT_TRUE(changed); 682 // After sorting IPv6 network should be higher order than IPv4 networks. 683 EXPECT_TRUE(net1->preference() < net2->preference()); 684 } 685 686 TEST_F(NetworkTest, TestNetworkAdapterTypes) { 687 Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24, 688 ADAPTER_TYPE_WIFI); 689 EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type()); 690 Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24, 691 ADAPTER_TYPE_ETHERNET); 692 EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type()); 693 Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24, 694 ADAPTER_TYPE_CELLULAR); 695 EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type()); 696 Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24, 697 ADAPTER_TYPE_VPN); 698 EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type()); 699 Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24, 700 ADAPTER_TYPE_UNKNOWN); 701 EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type()); 702 } 703 704 #if defined(WEBRTC_POSIX) 705 // Verify that we correctly handle interfaces with no address. 706 TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) { 707 ifaddrs list; 708 memset(&list, 0, sizeof(list)); 709 list.ifa_name = const_cast<char*>("test_iface"); 710 711 NetworkManager::NetworkList result; 712 BasicNetworkManager manager; 713 CallConvertIfAddrs(manager, &list, true, &result); 714 EXPECT_TRUE(result.empty()); 715 } 716 717 // Verify that if there are two addresses on one interface, only one network 718 // is generated. 719 TEST_F(NetworkTest, TestConvertIfAddrsMultiAddressesOnOneInterface) { 720 char if_name[20] = "rmnet0"; 721 ifaddrs* list = nullptr; 722 list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:1", 723 "FFFF:FFFF:FFFF:FFFF::", 0); 724 list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:2", 725 "FFFF:FFFF:FFFF:FFFF::", 0); 726 NetworkManager::NetworkList result; 727 BasicNetworkManager manager; 728 CallConvertIfAddrs(manager, list, true, &result); 729 EXPECT_EQ(1U, result.size()); 730 bool changed; 731 // This ensures we release the objects created in CallConvertIfAddrs. 732 MergeNetworkList(manager, result, &changed); 733 ReleaseIfAddrs(list); 734 } 735 736 TEST_F(NetworkTest, TestConvertIfAddrsNotRunning) { 737 ifaddrs list; 738 memset(&list, 0, sizeof(list)); 739 list.ifa_name = const_cast<char*>("test_iface"); 740 sockaddr ifa_addr; 741 sockaddr ifa_netmask; 742 list.ifa_addr = &ifa_addr; 743 list.ifa_netmask = &ifa_netmask; 744 745 NetworkManager::NetworkList result; 746 BasicNetworkManager manager; 747 CallConvertIfAddrs(manager, &list, true, &result); 748 EXPECT_TRUE(result.empty()); 749 } 750 #endif // defined(WEBRTC_POSIX) 751 752 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID) 753 // If you want to test non-default routes, you can do the following on a linux 754 // machine: 755 // 1) Load the dummy network driver: 756 // sudo modprobe dummy 757 // sudo ifconfig dummy0 127.0.0.1 758 // 2) Run this test and confirm the output says it found a dummy route (and 759 // passes). 760 // 3) When done: 761 // sudo rmmmod dummy 762 TEST_F(NetworkTest, TestIgnoreNonDefaultRoutes) { 763 BasicNetworkManager manager; 764 NetworkManager::NetworkList list; 765 list = GetNetworks(manager, false); 766 bool found_dummy = false; 767 LOG(LS_INFO) << "Looking for dummy network: "; 768 for (NetworkManager::NetworkList::iterator it = list.begin(); 769 it != list.end(); ++it) { 770 LOG(LS_INFO) << " Network name: " << (*it)->name(); 771 found_dummy |= (*it)->name().find("dummy0") != std::string::npos; 772 } 773 for (NetworkManager::NetworkList::iterator it = list.begin(); 774 it != list.end(); ++it) { 775 delete (*it); 776 } 777 if (!found_dummy) { 778 LOG(LS_INFO) << "No dummy found, quitting."; 779 return; 780 } 781 LOG(LS_INFO) << "Found dummy, running again while ignoring non-default " 782 << "routes."; 783 manager.set_ignore_non_default_routes(true); 784 list = GetNetworks(manager, false); 785 for (NetworkManager::NetworkList::iterator it = list.begin(); 786 it != list.end(); ++it) { 787 LOG(LS_INFO) << " Network name: " << (*it)->name(); 788 EXPECT_TRUE((*it)->name().find("dummy0") == std::string::npos); 789 } 790 for (NetworkManager::NetworkList::iterator it = list.begin(); 791 it != list.end(); ++it) { 792 delete (*it); 793 } 794 } 795 #endif 796 797 // Test MergeNetworkList successfully combines all IPs for the same 798 // prefix/length into a single Network. 799 TEST_F(NetworkTest, TestMergeNetworkList) { 800 BasicNetworkManager manager; 801 NetworkManager::NetworkList list; 802 803 // Create 2 IPAddress classes with only last digit different. 804 IPAddress ip1, ip2; 805 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1)); 806 EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:2", &ip2)); 807 808 // Create 2 networks with the same prefix and length. 809 Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64); 810 Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64); 811 812 // Add different IP into each. 813 net1->AddIP(ip1); 814 net2->AddIP(ip2); 815 816 list.push_back(net1); 817 list.push_back(net2); 818 bool changed; 819 MergeNetworkList(manager, list, &changed); 820 EXPECT_TRUE(changed); 821 822 NetworkManager::NetworkList list2; 823 manager.GetNetworks(&list2); 824 825 // Make sure the resulted networklist has only 1 element and 2 826 // IPAddresses. 827 EXPECT_EQ(list2.size(), 1uL); 828 EXPECT_EQ(list2[0]->GetIPs().size(), 2uL); 829 EXPECT_EQ(list2[0]->GetIPs()[0], ip1); 830 EXPECT_EQ(list2[0]->GetIPs()[1], ip2); 831 } 832 833 // Test that MergeNetworkList successfully detects the change if 834 // a network becomes inactive and then active again. 835 TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) { 836 BasicNetworkManager manager; 837 Network network1("test_wifi", "Test Network Adapter 1", 838 IPAddress(0x12345600U), 24); 839 Network network2("test_eth0", "Test Network Adapter 2", 840 IPAddress(0x00010000U), 16); 841 network1.AddIP(IPAddress(0x12345678)); 842 network2.AddIP(IPAddress(0x00010004)); 843 NetworkManager::NetworkList list; 844 Network* net1 = new Network(network1); 845 list.push_back(net1); 846 bool changed; 847 MergeNetworkList(manager, list, &changed); 848 EXPECT_TRUE(changed); 849 list.clear(); 850 manager.GetNetworks(&list); 851 ASSERT_EQ(1U, list.size()); 852 EXPECT_EQ(net1, list[0]); 853 854 list.clear(); 855 Network* net2 = new Network(network2); 856 list.push_back(net2); 857 MergeNetworkList(manager, list, &changed); 858 EXPECT_TRUE(changed); 859 list.clear(); 860 manager.GetNetworks(&list); 861 ASSERT_EQ(1U, list.size()); 862 EXPECT_EQ(net2, list[0]); 863 864 // Now network1 is inactive. Try to merge it again. 865 list.clear(); 866 list.push_back(new Network(network1)); 867 MergeNetworkList(manager, list, &changed); 868 EXPECT_TRUE(changed); 869 list.clear(); 870 manager.GetNetworks(&list); 871 ASSERT_EQ(1U, list.size()); 872 EXPECT_TRUE(list[0]->active()); 873 EXPECT_EQ(net1, list[0]); 874 } 875 876 // Test that the filtering logic follows the defined ruleset in network.h. 877 TEST_F(NetworkTest, TestIPv6Selection) { 878 InterfaceAddress ip; 879 std::string ipstr; 880 881 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3"; 882 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip)); 883 884 // Create a network with this prefix. 885 Network ipv6_network( 886 "test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64), 64); 887 888 // When there is no address added, it should return an unspecified 889 // address. 890 EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress()); 891 EXPECT_TRUE(IPIsUnspec(ipv6_network.GetBestIP())); 892 893 // Deprecated one should not be returned. 894 ipv6_network.AddIP(ip); 895 EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress()); 896 897 // Add ULA one. ULA is unique local address which is starting either 898 // with 0xfc or 0xfd. 899 ipstr = "fd00:fa00:4:1000:be30:5bff:fee5:c4"; 900 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip)); 901 ipv6_network.AddIP(ip); 902 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip)); 903 904 // Add global one. 905 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c5"; 906 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip)); 907 ipv6_network.AddIP(ip); 908 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip)); 909 910 // Add global dynamic temporary one. 911 ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6"; 912 ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip)); 913 ipv6_network.AddIP(ip); 914 EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip)); 915 } 916 917 TEST_F(NetworkTest, TestNetworkMonitoring) { 918 BasicNetworkManager manager; 919 manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this), 920 &NetworkTest::OnNetworksChanged); 921 FakeNetworkMonitorFactory* factory = new FakeNetworkMonitorFactory(); 922 NetworkMonitorFactory::SetFactory(factory); 923 manager.StartUpdating(); 924 NetworkMonitorInterface* network_monitor = GetNetworkMonitor(manager); 925 EXPECT_TRUE_WAIT(callback_called_, 1000); 926 callback_called_ = false; 927 928 // Clear the networks so that there will be network changes below. 929 ClearNetworks(manager); 930 // Network manager is started, so the callback is called when the network 931 // monitor fires the network-change event. 932 network_monitor->OnNetworksChanged(); 933 EXPECT_TRUE_WAIT(callback_called_, 1000); 934 935 // Network manager is stopped; the network monitor is removed. 936 manager.StopUpdating(); 937 EXPECT_TRUE(GetNetworkMonitor(manager) == nullptr); 938 939 NetworkMonitorFactory::ReleaseFactory(factory); 940 } 941 942 TEST_F(NetworkTest, DefaultLocalAddress) { 943 TestBasicNetworkManager manager; 944 manager.StartUpdating(); 945 IPAddress ip; 946 947 // GetDefaultLocalAddress should return false when not set. 948 EXPECT_FALSE(manager.GetDefaultLocalAddress(AF_INET, &ip)); 949 EXPECT_FALSE(manager.GetDefaultLocalAddress(AF_INET6, &ip)); 950 951 // Make sure we can query default local address when an address for such 952 // address family exists. 953 std::vector<Network*> networks; 954 manager.GetNetworks(&networks); 955 for (auto& network : networks) { 956 if (network->GetBestIP().family() == AF_INET) { 957 EXPECT_TRUE(manager.QueryDefaultLocalAddress(AF_INET) != IPAddress()); 958 } else if (network->GetBestIP().family() == AF_INET6) { 959 EXPECT_TRUE(manager.QueryDefaultLocalAddress(AF_INET6) != IPAddress()); 960 } 961 } 962 963 // GetDefaultLocalAddress should return the valid default address after set. 964 manager.set_default_local_addresses(GetLoopbackIP(AF_INET), 965 GetLoopbackIP(AF_INET6)); 966 EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET, &ip)); 967 EXPECT_EQ(ip, GetLoopbackIP(AF_INET)); 968 EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip)); 969 EXPECT_EQ(ip, GetLoopbackIP(AF_INET6)); 970 manager.StopUpdating(); 971 } 972 973 } // namespace rtc 974
