/* * Copyright 2004 The WebRTC Project Authors. All rights reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "webrtc/base/network.h" #include "webrtc/base/nethelpers.h" #include "webrtc/base/networkmonitor.h" #include #include #if defined(WEBRTC_POSIX) #include #include #include "webrtc/base/ifaddrs_converter.h" #endif // defined(WEBRTC_POSIX) #include "webrtc/base/gunit.h" #if defined(WEBRTC_WIN) #include "webrtc/base/logging.h" // For LOG_GLE #endif namespace rtc { namespace { class FakeNetworkMonitor : public NetworkMonitorBase { public: void Start() override { started_ = true; } void Stop() override { started_ = false; } bool started() { return started_; } AdapterType GetAdapterType(const std::string& if_name) override { // Note that the name matching rules are different from the // GetAdapterTypeFromName in NetworkManager. if (if_name.find("wifi") == 0) { return ADAPTER_TYPE_WIFI; } if (if_name.find("cellular") == 0) { return ADAPTER_TYPE_CELLULAR; } return ADAPTER_TYPE_UNKNOWN; } private: bool started_ = false; }; class FakeNetworkMonitorFactory : public NetworkMonitorFactory { public: FakeNetworkMonitorFactory() {} NetworkMonitorInterface* CreateNetworkMonitor() override { return new FakeNetworkMonitor(); } }; } // namespace class NetworkTest : public testing::Test, public sigslot::has_slots<> { public: NetworkTest() : callback_called_(false) {} void OnNetworksChanged() { callback_called_ = true; } void listenToNetworkInactive(BasicNetworkManager& network_manager) { BasicNetworkManager::NetworkList networks; network_manager.GetNetworks(&networks); for (Network* network : networks) { network->SignalInactive.connect(this, &NetworkTest::OnNetworkInactive); } } void OnNetworkInactive(const Network* network) { num_networks_inactive_++; } NetworkManager::Stats MergeNetworkList( BasicNetworkManager& network_manager, const NetworkManager::NetworkList& list, bool* changed) { NetworkManager::Stats stats; network_manager.MergeNetworkList(list, changed, &stats); return stats; } bool IsIgnoredNetwork(BasicNetworkManager& network_manager, const Network& network) { return network_manager.IsIgnoredNetwork(network); } NetworkManager::NetworkList GetNetworks( const BasicNetworkManager& network_manager, bool include_ignored) { NetworkManager::NetworkList list; network_manager.CreateNetworks(include_ignored, &list); return list; } FakeNetworkMonitor* GetNetworkMonitor(BasicNetworkManager& network_manager) { return static_cast( network_manager.network_monitor_.get()); } void ClearNetworks(BasicNetworkManager& network_manager) { for (const auto& kv : network_manager.networks_map_) { delete kv.second; } network_manager.networks_.clear(); network_manager.networks_map_.clear(); } AdapterType GetAdapterType(BasicNetworkManager& network_manager) { BasicNetworkManager::NetworkList list; network_manager.GetNetworks(&list); ASSERT(list.size() == 1u); return list[0]->type(); } #if defined(WEBRTC_POSIX) // Separated from CreateNetworks for tests. static void CallConvertIfAddrs(const BasicNetworkManager& network_manager, struct ifaddrs* interfaces, bool include_ignored, NetworkManager::NetworkList* networks) { // Use the base IfAddrsConverter for test cases. std::unique_ptr ifaddrs_converter(new IfAddrsConverter()); network_manager.ConvertIfAddrs(interfaces, ifaddrs_converter.get(), include_ignored, networks); } struct sockaddr_in6* CreateIpv6Addr(const std::string& ip_string, uint32_t scope_id) { struct sockaddr_in6* ipv6_addr = new struct sockaddr_in6; memset(ipv6_addr, 0, sizeof(struct sockaddr_in6)); ipv6_addr->sin6_family = AF_INET6; ipv6_addr->sin6_scope_id = scope_id; IPAddress ip; IPFromString(ip_string, &ip); ipv6_addr->sin6_addr = ip.ipv6_address(); return ipv6_addr; } // Pointers created here need to be released via ReleaseIfAddrs. struct ifaddrs* AddIpv6Address(struct ifaddrs* list, char* if_name, const std::string& ipv6_address, const std::string& ipv6_netmask, uint32_t scope_id) { struct ifaddrs* if_addr = new struct ifaddrs; memset(if_addr, 0, sizeof(struct ifaddrs)); if_addr->ifa_name = if_name; if_addr->ifa_addr = reinterpret_cast( CreateIpv6Addr(ipv6_address, scope_id)); if_addr->ifa_netmask = reinterpret_cast(CreateIpv6Addr(ipv6_netmask, 0)); if_addr->ifa_next = list; if_addr->ifa_flags = IFF_RUNNING; return if_addr; } struct ifaddrs* InstallIpv6Network(char* if_name, const std::string& ipv6_address, const std::string& ipv6_mask, BasicNetworkManager& network_manager) { ifaddrs* addr_list = nullptr; addr_list = AddIpv6Address(addr_list, if_name, ipv6_address, ipv6_mask, 0); NetworkManager::NetworkList result; bool changed; NetworkManager::Stats stats; CallConvertIfAddrs(network_manager, addr_list, true, &result); network_manager.MergeNetworkList(result, &changed, &stats); return addr_list; } void ReleaseIfAddrs(struct ifaddrs* list) { struct ifaddrs* if_addr = list; while (if_addr != nullptr) { struct ifaddrs* next_addr = if_addr->ifa_next; delete if_addr->ifa_addr; delete if_addr->ifa_netmask; delete if_addr; if_addr = next_addr; } } #endif // defined(WEBRTC_POSIX) protected: bool callback_called_; // Number of networks that become inactive. int num_networks_inactive_ = 0; }; class TestBasicNetworkManager : public BasicNetworkManager { public: using BasicNetworkManager::QueryDefaultLocalAddress; using BasicNetworkManager::set_default_local_addresses; }; // Test that the Network ctor works properly. TEST_F(NetworkTest, TestNetworkConstruct) { Network ipv4_network1("test_eth0", "Test Network Adapter 1", IPAddress(0x12345600U), 24); EXPECT_EQ("test_eth0", ipv4_network1.name()); EXPECT_EQ("Test Network Adapter 1", ipv4_network1.description()); EXPECT_EQ(IPAddress(0x12345600U), ipv4_network1.prefix()); EXPECT_EQ(24, ipv4_network1.prefix_length()); EXPECT_FALSE(ipv4_network1.ignored()); } TEST_F(NetworkTest, TestIsIgnoredNetworkIgnoresIPsStartingWith0) { Network ipv4_network1("test_eth0", "Test Network Adapter 1", IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET); Network ipv4_network2("test_eth1", "Test Network Adapter 2", IPAddress(0x010000U), 24, ADAPTER_TYPE_ETHERNET); BasicNetworkManager network_manager; EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1)); EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network2)); } // TODO(phoglund): Remove when ignore list goes away. TEST_F(NetworkTest, TestIgnoreList) { Network ignore_me("ignore_me", "Ignore me please!", IPAddress(0x12345600U), 24); Network include_me("include_me", "Include me please!", IPAddress(0x12345600U), 24); BasicNetworkManager network_manager; EXPECT_FALSE(IsIgnoredNetwork(network_manager, ignore_me)); EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me)); std::vector ignore_list; ignore_list.push_back("ignore_me"); network_manager.set_network_ignore_list(ignore_list); EXPECT_TRUE(IsIgnoredNetwork(network_manager, ignore_me)); EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me)); } // Test is failing on Windows opt: b/11288214 TEST_F(NetworkTest, DISABLED_TestCreateNetworks) { BasicNetworkManager manager; NetworkManager::NetworkList result = GetNetworks(manager, true); // We should be able to bind to any addresses we find. NetworkManager::NetworkList::iterator it; for (it = result.begin(); it != result.end(); ++it) { sockaddr_storage storage; memset(&storage, 0, sizeof(storage)); IPAddress ip = (*it)->GetBestIP(); SocketAddress bindaddress(ip, 0); bindaddress.SetScopeID((*it)->scope_id()); // TODO(thaloun): Use rtc::AsyncSocket once it supports IPv6. int fd = static_cast(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP)); if (fd > 0) { size_t ipsize = bindaddress.ToSockAddrStorage(&storage); EXPECT_GE(ipsize, 0U); int success = ::bind(fd, reinterpret_cast(&storage), static_cast(ipsize)); #if defined(WEBRTC_WIN) if (success) LOG_GLE(LS_ERROR) << "Socket bind failed."; #endif EXPECT_EQ(0, success); #if defined(WEBRTC_WIN) closesocket(fd); #else close(fd); #endif } delete (*it); } } // Test StartUpdating() and StopUpdating(). network_permission_state starts with // ALLOWED. TEST_F(NetworkTest, TestUpdateNetworks) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect( static_cast(this), &NetworkTest::OnNetworksChanged); EXPECT_EQ(NetworkManager::ENUMERATION_ALLOWED, manager.enumeration_permission()); manager.StartUpdating(); Thread::Current()->ProcessMessages(0); EXPECT_TRUE(callback_called_); callback_called_ = false; // Callback should be triggered immediately when StartUpdating // is called, after network update signal is already sent. manager.StartUpdating(); EXPECT_TRUE(manager.started()); Thread::Current()->ProcessMessages(0); EXPECT_TRUE(callback_called_); manager.StopUpdating(); EXPECT_TRUE(manager.started()); manager.StopUpdating(); EXPECT_EQ(NetworkManager::ENUMERATION_ALLOWED, manager.enumeration_permission()); EXPECT_FALSE(manager.started()); manager.StopUpdating(); EXPECT_FALSE(manager.started()); callback_called_ = false; // Callback should be triggered immediately after StartUpdating is called // when start_count_ is reset to 0. manager.StartUpdating(); Thread::Current()->ProcessMessages(0); EXPECT_TRUE(callback_called_); } // Verify that MergeNetworkList() merges network lists properly. TEST_F(NetworkTest, TestBasicMergeNetworkList) { Network ipv4_network1("test_eth0", "Test Network Adapter 1", IPAddress(0x12345600U), 24); Network ipv4_network2("test_eth1", "Test Network Adapter 2", IPAddress(0x00010000U), 16); ipv4_network1.AddIP(IPAddress(0x12345678)); ipv4_network2.AddIP(IPAddress(0x00010004)); BasicNetworkManager manager; // Add ipv4_network1 to the list of networks. NetworkManager::NetworkList list; list.push_back(new Network(ipv4_network1)); bool changed; NetworkManager::Stats stats = MergeNetworkList(manager, list, &changed); EXPECT_TRUE(changed); EXPECT_EQ(stats.ipv6_network_count, 0); EXPECT_EQ(stats.ipv4_network_count, 1); listenToNetworkInactive(manager); list.clear(); manager.GetNetworks(&list); EXPECT_EQ(1U, list.size()); EXPECT_EQ(ipv4_network1.ToString(), list[0]->ToString()); Network* net1 = list[0]; uint16_t net_id1 = net1->id(); EXPECT_EQ(1, net_id1); list.clear(); // Replace ipv4_network1 with ipv4_network2. list.push_back(new Network(ipv4_network2)); stats = MergeNetworkList(manager, list, &changed); EXPECT_TRUE(changed); EXPECT_EQ(stats.ipv6_network_count, 0); EXPECT_EQ(stats.ipv4_network_count, 1); EXPECT_EQ(1, num_networks_inactive_); list.clear(); num_networks_inactive_ = 0; manager.GetNetworks(&list); EXPECT_EQ(1U, list.size()); EXPECT_EQ(ipv4_network2.ToString(), list[0]->ToString()); Network* net2 = list[0]; uint16_t net_id2 = net2->id(); // Network id will increase. EXPECT_LT(net_id1, net_id2); list.clear(); // Add Network2 back. list.push_back(new Network(ipv4_network1)); list.push_back(new Network(ipv4_network2)); stats = MergeNetworkList(manager, list, &changed); EXPECT_TRUE(changed); EXPECT_EQ(stats.ipv6_network_count, 0); EXPECT_EQ(stats.ipv4_network_count, 2); EXPECT_EQ(0, num_networks_inactive_); list.clear(); // Verify that we get previous instances of Network objects. manager.GetNetworks(&list); EXPECT_EQ(2U, list.size()); EXPECT_TRUE((net1 == list[0] && net2 == list[1]) || (net1 == list[1] && net2 == list[0])); EXPECT_TRUE((net_id1 == list[0]->id() && net_id2 == list[1]->id()) || (net_id1 == list[1]->id() && net_id2 == list[0]->id())); list.clear(); // Call MergeNetworkList() again and verify that we don't get update // notification. list.push_back(new Network(ipv4_network2)); list.push_back(new Network(ipv4_network1)); stats = MergeNetworkList(manager, list, &changed); EXPECT_FALSE(changed); EXPECT_EQ(stats.ipv6_network_count, 0); EXPECT_EQ(stats.ipv4_network_count, 2); EXPECT_EQ(0, num_networks_inactive_); list.clear(); // Verify that we get previous instances of Network objects. manager.GetNetworks(&list); EXPECT_EQ(2U, list.size()); EXPECT_TRUE((net1 == list[0] && net2 == list[1]) || (net1 == list[1] && net2 == list[0])); EXPECT_TRUE((net_id1 == list[0]->id() && net_id2 == list[1]->id()) || (net_id1 == list[1]->id() && net_id2 == list[0]->id())); list.clear(); } // Sets up some test IPv6 networks and appends them to list. // Four networks are added - public and link local, for two interfaces. void SetupNetworks(NetworkManager::NetworkList* list) { IPAddress ip; IPAddress prefix; EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:ef12", &ip)); EXPECT_TRUE(IPFromString("abcd::", &prefix)); // First, fake link-locals. Network ipv6_eth0_linklocalnetwork("test_eth0", "Test NetworkAdapter 1", prefix, 64); ipv6_eth0_linklocalnetwork.AddIP(ip); EXPECT_TRUE(IPFromString("abcd::5678:abcd:ef12:3456", &ip)); Network ipv6_eth1_linklocalnetwork("test_eth1", "Test NetworkAdapter 2", prefix, 64); ipv6_eth1_linklocalnetwork.AddIP(ip); // Public networks: EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip)); prefix = TruncateIP(ip, 64); Network ipv6_eth0_publicnetwork1_ip1("test_eth0", "Test NetworkAdapter 1", prefix, 64); ipv6_eth0_publicnetwork1_ip1.AddIP(ip); EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip)); prefix = TruncateIP(ip, 64); Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 1", prefix, 64); ipv6_eth1_publicnetwork1_ip1.AddIP(ip); list->push_back(new Network(ipv6_eth0_linklocalnetwork)); list->push_back(new Network(ipv6_eth1_linklocalnetwork)); list->push_back(new Network(ipv6_eth0_publicnetwork1_ip1)); list->push_back(new Network(ipv6_eth1_publicnetwork1_ip1)); } // Test that the basic network merging case works. TEST_F(NetworkTest, TestIPv6MergeNetworkList) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect( static_cast(this), &NetworkTest::OnNetworksChanged); NetworkManager::NetworkList original_list; SetupNetworks(&original_list); bool changed = false; NetworkManager::Stats stats = MergeNetworkList(manager, original_list, &changed); EXPECT_TRUE(changed); EXPECT_EQ(stats.ipv6_network_count, 4); EXPECT_EQ(stats.ipv4_network_count, 0); NetworkManager::NetworkList list; manager.GetNetworks(&list); EXPECT_EQ(original_list.size(), list.size()); // Verify that the original members are in the merged list. for (NetworkManager::NetworkList::iterator it = original_list.begin(); it != original_list.end(); ++it) { EXPECT_NE(list.end(), std::find(list.begin(), list.end(), *it)); } } // Test that no more than manager.max_ipv6_networks() IPv6 networks get // returned. TEST_F(NetworkTest, TestIPv6MergeNetworkListTrimExcessive) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect(static_cast(this), &NetworkTest::OnNetworksChanged); NetworkManager::NetworkList original_list; // Add twice the allowed number of IPv6 networks. for (int i = 0; i < 2 * manager.max_ipv6_networks(); i++) { // Make a network with different prefix length. IPAddress ip; EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip)); IPAddress prefix = TruncateIP(ip, 64 - i); Network* ipv6_network = new Network("test_eth0", "Test Network Adapter 1", prefix, 64 - i); ipv6_network->AddIP(ip); original_list.push_back(ipv6_network); } // Add one IPv4 network. Network* ipv4_network = new Network("test_eth0", "Test Network Adapter 1", IPAddress(0x12345600U), 24); ipv4_network->AddIP(IPAddress(0x12345600U)); original_list.push_back(ipv4_network); bool changed = false; MergeNetworkList(manager, original_list, &changed); EXPECT_TRUE(changed); NetworkManager::NetworkList list; manager.GetNetworks(&list); // List size should be the max allowed IPv6 networks plus one IPv4 network. EXPECT_EQ(manager.max_ipv6_networks() + 1, (int)list.size()); // Verify that the IPv4 network is in the list. EXPECT_NE(list.end(), std::find(list.begin(), list.end(), ipv4_network)); } // Tests that when two network lists that describe the same set of networks are // merged, that the changed callback is not called, and that the original // objects remain in the result list. TEST_F(NetworkTest, TestNoChangeMerge) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect( static_cast(this), &NetworkTest::OnNetworksChanged); NetworkManager::NetworkList original_list; SetupNetworks(&original_list); bool changed = false; MergeNetworkList(manager, original_list, &changed); EXPECT_TRUE(changed); // Second list that describes the same networks but with new objects. NetworkManager::NetworkList second_list; SetupNetworks(&second_list); changed = false; MergeNetworkList(manager, second_list, &changed); EXPECT_FALSE(changed); NetworkManager::NetworkList resulting_list; manager.GetNetworks(&resulting_list); EXPECT_EQ(original_list.size(), resulting_list.size()); // Verify that the original members are in the merged list. for (NetworkManager::NetworkList::iterator it = original_list.begin(); it != original_list.end(); ++it) { EXPECT_NE(resulting_list.end(), std::find(resulting_list.begin(), resulting_list.end(), *it)); } // Doublecheck that the new networks aren't in the list. for (NetworkManager::NetworkList::iterator it = second_list.begin(); it != second_list.end(); ++it) { EXPECT_EQ(resulting_list.end(), std::find(resulting_list.begin(), resulting_list.end(), *it)); } } // Test that we can merge a network that is the same as another network but with // a different IP. The original network should remain in the list, but have its // IP changed. TEST_F(NetworkTest, MergeWithChangedIP) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect( static_cast(this), &NetworkTest::OnNetworksChanged); NetworkManager::NetworkList original_list; SetupNetworks(&original_list); // Make a network that we're going to change. IPAddress ip; EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip)); IPAddress prefix = TruncateIP(ip, 64); Network* network_to_change = new Network("test_eth0", "Test Network Adapter 1", prefix, 64); Network* changed_network = new Network(*network_to_change); network_to_change->AddIP(ip); IPAddress changed_ip; EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip)); changed_network->AddIP(changed_ip); original_list.push_back(network_to_change); bool changed = false; MergeNetworkList(manager, original_list, &changed); NetworkManager::NetworkList second_list; SetupNetworks(&second_list); second_list.push_back(changed_network); changed = false; MergeNetworkList(manager, second_list, &changed); EXPECT_TRUE(changed); NetworkManager::NetworkList list; manager.GetNetworks(&list); EXPECT_EQ(original_list.size(), list.size()); // Make sure the original network is still in the merged list. EXPECT_NE(list.end(), std::find(list.begin(), list.end(), network_to_change)); EXPECT_EQ(changed_ip, network_to_change->GetIPs().at(0)); } // Testing a similar case to above, but checking that a network can be updated // with additional IPs (not just a replacement). TEST_F(NetworkTest, TestMultipleIPMergeNetworkList) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect( static_cast(this), &NetworkTest::OnNetworksChanged); NetworkManager::NetworkList original_list; SetupNetworks(&original_list); bool changed = false; MergeNetworkList(manager, original_list, &changed); EXPECT_TRUE(changed); IPAddress ip; IPAddress check_ip; IPAddress prefix; // Add a second IP to the public network on eth0 (2401:fa00:4:1000/64). EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip)); prefix = TruncateIP(ip, 64); Network ipv6_eth0_publicnetwork1_ip2("test_eth0", "Test NetworkAdapter 1", prefix, 64); // This is the IP that already existed in the public network on eth0. EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip)); ipv6_eth0_publicnetwork1_ip2.AddIP(ip); original_list.push_back(new Network(ipv6_eth0_publicnetwork1_ip2)); changed = false; MergeNetworkList(manager, original_list, &changed); EXPECT_TRUE(changed); // There should still be four networks. NetworkManager::NetworkList list; manager.GetNetworks(&list); EXPECT_EQ(4U, list.size()); // Check the gathered IPs. int matchcount = 0; for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { if ((*it)->ToString() == original_list[2]->ToString()) { ++matchcount; EXPECT_EQ(1, matchcount); // This should be the same network object as before. EXPECT_EQ((*it), original_list[2]); // But with two addresses now. EXPECT_EQ(2U, (*it)->GetIPs().size()); EXPECT_NE((*it)->GetIPs().end(), std::find((*it)->GetIPs().begin(), (*it)->GetIPs().end(), check_ip)); EXPECT_NE((*it)->GetIPs().end(), std::find((*it)->GetIPs().begin(), (*it)->GetIPs().end(), ip)); } else { // Check the IP didn't get added anywhere it wasn't supposed to. EXPECT_EQ((*it)->GetIPs().end(), std::find((*it)->GetIPs().begin(), (*it)->GetIPs().end(), ip)); } } } // Test that merge correctly distinguishes multiple networks on an interface. TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect( static_cast(this), &NetworkTest::OnNetworksChanged); NetworkManager::NetworkList original_list; SetupNetworks(&original_list); bool changed = false; MergeNetworkList(manager, original_list, &changed); EXPECT_TRUE(changed); IPAddress ip; IPAddress prefix; // A second network for eth0. EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip)); prefix = TruncateIP(ip, 64); Network ipv6_eth0_publicnetwork2_ip1("test_eth0", "Test NetworkAdapter 1", prefix, 64); ipv6_eth0_publicnetwork2_ip1.AddIP(ip); original_list.push_back(new Network(ipv6_eth0_publicnetwork2_ip1)); changed = false; MergeNetworkList(manager, original_list, &changed); EXPECT_TRUE(changed); // There should be five networks now. NetworkManager::NetworkList list; manager.GetNetworks(&list); EXPECT_EQ(5U, list.size()); // Check the resulting addresses. for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { if ((*it)->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() && (*it)->name() == ipv6_eth0_publicnetwork2_ip1.name()) { // Check the new network has 1 IP and that it's the correct one. EXPECT_EQ(1U, (*it)->GetIPs().size()); EXPECT_EQ(ip, (*it)->GetIPs().at(0)); } else { // Check the IP didn't get added anywhere it wasn't supposed to. EXPECT_EQ((*it)->GetIPs().end(), std::find((*it)->GetIPs().begin(), (*it)->GetIPs().end(), ip)); } } } // Test that DumpNetworks does not crash. TEST_F(NetworkTest, TestCreateAndDumpNetworks) { BasicNetworkManager manager; NetworkManager::NetworkList list = GetNetworks(manager, true); bool changed; MergeNetworkList(manager, list, &changed); manager.DumpNetworks(); } // Test that we can toggle IPv6 on and off. // Crashes on Linux. See webrtc:4923. #if defined(WEBRTC_LINUX) #define MAYBE_TestIPv6Toggle DISABLED_TestIPv6Toggle #else #define MAYBE_TestIPv6Toggle TestIPv6Toggle #endif TEST_F(NetworkTest, MAYBE_TestIPv6Toggle) { BasicNetworkManager manager; bool ipv6_found = false; NetworkManager::NetworkList list; #if !defined(WEBRTC_WIN) // There should be at least one IPv6 network (fe80::/64 should be in there). // TODO(thaloun): Disabling this test on windows for the moment as the test // machines don't seem to have IPv6 installed on them at all. manager.set_ipv6_enabled(true); list = GetNetworks(manager, true); for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { if ((*it)->prefix().family() == AF_INET6) { ipv6_found = true; break; } } EXPECT_TRUE(ipv6_found); for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { delete (*it); } #endif ipv6_found = false; manager.set_ipv6_enabled(false); list = GetNetworks(manager, true); for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { if ((*it)->prefix().family() == AF_INET6) { ipv6_found = true; break; } } EXPECT_FALSE(ipv6_found); for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { delete (*it); } } TEST_F(NetworkTest, TestNetworkListSorting) { BasicNetworkManager manager; Network ipv4_network1("test_eth0", "Test Network Adapter 1", IPAddress(0x12345600U), 24); ipv4_network1.AddIP(IPAddress(0x12345600U)); IPAddress ip; IPAddress prefix; EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip)); prefix = TruncateIP(ip, 64); Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 2", prefix, 64); ipv6_eth1_publicnetwork1_ip1.AddIP(ip); NetworkManager::NetworkList list; list.push_back(new Network(ipv4_network1)); list.push_back(new Network(ipv6_eth1_publicnetwork1_ip1)); Network* net1 = list[0]; Network* net2 = list[1]; bool changed = false; MergeNetworkList(manager, list, &changed); ASSERT_TRUE(changed); // After sorting IPv6 network should be higher order than IPv4 networks. EXPECT_TRUE(net1->preference() < net2->preference()); } TEST_F(NetworkTest, TestNetworkAdapterTypes) { Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24, ADAPTER_TYPE_WIFI); EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type()); Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET); EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type()); Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24, ADAPTER_TYPE_CELLULAR); EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type()); Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24, ADAPTER_TYPE_VPN); EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type()); Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24, ADAPTER_TYPE_UNKNOWN); EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type()); } #if defined(WEBRTC_POSIX) // Verify that we correctly handle interfaces with no address. TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) { ifaddrs list; memset(&list, 0, sizeof(list)); list.ifa_name = const_cast("test_iface"); NetworkManager::NetworkList result; BasicNetworkManager manager; CallConvertIfAddrs(manager, &list, true, &result); EXPECT_TRUE(result.empty()); } // Verify that if there are two addresses on one interface, only one network // is generated. TEST_F(NetworkTest, TestConvertIfAddrsMultiAddressesOnOneInterface) { char if_name[20] = "rmnet0"; ifaddrs* list = nullptr; list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:1", "FFFF:FFFF:FFFF:FFFF::", 0); list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:2", "FFFF:FFFF:FFFF:FFFF::", 0); NetworkManager::NetworkList result; BasicNetworkManager manager; CallConvertIfAddrs(manager, list, true, &result); EXPECT_EQ(1U, result.size()); bool changed; // This ensures we release the objects created in CallConvertIfAddrs. MergeNetworkList(manager, result, &changed); ReleaseIfAddrs(list); } TEST_F(NetworkTest, TestConvertIfAddrsNotRunning) { ifaddrs list; memset(&list, 0, sizeof(list)); list.ifa_name = const_cast("test_iface"); sockaddr ifa_addr; sockaddr ifa_netmask; list.ifa_addr = &ifa_addr; list.ifa_netmask = &ifa_netmask; NetworkManager::NetworkList result; BasicNetworkManager manager; CallConvertIfAddrs(manager, &list, true, &result); EXPECT_TRUE(result.empty()); } // Tests that the network type can be updated after the network monitor is // started. TEST_F(NetworkTest, TestGetAdapterTypeFromNetworkMonitor) { char if_name1[20] = "wifi0"; std::string ipv6_address1 = "1000:2000:3000:4000:0:0:0:1"; std::string ipv6_address2 = "1000:2000:3000:8000:0:0:0:1"; std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::"; BasicNetworkManager manager; // A network created before the network monitor is started will get // UNKNOWN type. ifaddrs* addr_list = InstallIpv6Network(if_name1, ipv6_address1, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, GetAdapterType(manager)); ReleaseIfAddrs(addr_list); // Note: Do not call ClearNetworks here in order to test that the type // of an existing network can be changed after the network monitor starts // and detects the network type correctly. // After the network monitor starts, the type will be updated. FakeNetworkMonitorFactory* factory = new FakeNetworkMonitorFactory(); NetworkMonitorFactory::SetFactory(factory); // This brings up the hook with the network monitor. manager.StartUpdating(); // Add the same ipv6 address as before but it has the right network type // detected by the network monitor now. addr_list = InstallIpv6Network(if_name1, ipv6_address1, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager)); ReleaseIfAddrs(addr_list); ClearNetworks(manager); // Add another network with the type inferred from the network monitor. char if_name2[20] = "cellular0"; addr_list = InstallIpv6Network(if_name2, ipv6_address2, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager)); ReleaseIfAddrs(addr_list); ClearNetworks(manager); } // Test that the network type can be determined based on name matching in // a few cases. Note that UNKNOWN type for non-matching strings has been tested // in the above test. TEST_F(NetworkTest, TestGetAdapterTypeFromNameMatching) { std::string ipv6_address1 = "1000:2000:3000:4000:0:0:0:1"; std::string ipv6_address2 = "1000:2000:3000:8000:0:0:0:1"; std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::"; BasicNetworkManager manager; #if defined(WEBRTC_IOS) char if_name[20] = "pdp_ip0"; ifaddrs* addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager)); ClearNetworks(manager); ReleaseIfAddrs(addr_list); strcpy(if_name, "en0"); addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager)); ClearNetworks(manager); ReleaseIfAddrs(addr_list); #elif defined(WEBRTC_ANDROID) char if_name[20] = "rmnet0"; ifaddrs* addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager)); ClearNetworks(manager); ReleaseIfAddrs(addr_list); strcpy(if_name, "wlan1"); addr_list = InstallIpv6Network(if_name, ipv6_address2, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager)); ClearNetworks(manager); ReleaseIfAddrs(addr_list); strcpy(if_name, "v4-rmnet_data0"); addr_list = InstallIpv6Network(if_name, ipv6_address2, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager)); ClearNetworks(manager); ReleaseIfAddrs(addr_list); #else char if_name[20] = "wlan0"; ifaddrs* addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager); EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, GetAdapterType(manager)); ClearNetworks(manager); ReleaseIfAddrs(addr_list); #endif } #endif // defined(WEBRTC_POSIX) #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID) // If you want to test non-default routes, you can do the following on a linux // machine: // 1) Load the dummy network driver: // sudo modprobe dummy // sudo ifconfig dummy0 127.0.0.1 // 2) Run this test and confirm the output says it found a dummy route (and // passes). // 3) When done: // sudo rmmmod dummy TEST_F(NetworkTest, TestIgnoreNonDefaultRoutes) { BasicNetworkManager manager; NetworkManager::NetworkList list; list = GetNetworks(manager, false); bool found_dummy = false; LOG(LS_INFO) << "Looking for dummy network: "; for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { LOG(LS_INFO) << " Network name: " << (*it)->name(); found_dummy |= (*it)->name().find("dummy0") != std::string::npos; } for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { delete (*it); } if (!found_dummy) { LOG(LS_INFO) << "No dummy found, quitting."; return; } LOG(LS_INFO) << "Found dummy, running again while ignoring non-default " << "routes."; manager.set_ignore_non_default_routes(true); list = GetNetworks(manager, false); for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { LOG(LS_INFO) << " Network name: " << (*it)->name(); EXPECT_TRUE((*it)->name().find("dummy0") == std::string::npos); } for (NetworkManager::NetworkList::iterator it = list.begin(); it != list.end(); ++it) { delete (*it); } } #endif // Test MergeNetworkList successfully combines all IPs for the same // prefix/length into a single Network. TEST_F(NetworkTest, TestMergeNetworkList) { BasicNetworkManager manager; NetworkManager::NetworkList list; // Create 2 IPAddress classes with only last digit different. IPAddress ip1, ip2; EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1)); EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:2", &ip2)); // Create 2 networks with the same prefix and length. Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64); Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64); // Add different IP into each. net1->AddIP(ip1); net2->AddIP(ip2); list.push_back(net1); list.push_back(net2); bool changed; MergeNetworkList(manager, list, &changed); EXPECT_TRUE(changed); NetworkManager::NetworkList list2; manager.GetNetworks(&list2); // Make sure the resulted networklist has only 1 element and 2 // IPAddresses. EXPECT_EQ(list2.size(), 1uL); EXPECT_EQ(list2[0]->GetIPs().size(), 2uL); EXPECT_EQ(list2[0]->GetIPs()[0], ip1); EXPECT_EQ(list2[0]->GetIPs()[1], ip2); } // Test that MergeNetworkList successfully detects the change if // a network becomes inactive and then active again. TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) { BasicNetworkManager manager; Network network1("test_wifi", "Test Network Adapter 1", IPAddress(0x12345600U), 24); Network network2("test_eth0", "Test Network Adapter 2", IPAddress(0x00010000U), 16); network1.AddIP(IPAddress(0x12345678)); network2.AddIP(IPAddress(0x00010004)); NetworkManager::NetworkList list; Network* net1 = new Network(network1); list.push_back(net1); bool changed; MergeNetworkList(manager, list, &changed); EXPECT_TRUE(changed); list.clear(); manager.GetNetworks(&list); ASSERT_EQ(1U, list.size()); EXPECT_EQ(net1, list[0]); list.clear(); Network* net2 = new Network(network2); list.push_back(net2); MergeNetworkList(manager, list, &changed); EXPECT_TRUE(changed); list.clear(); manager.GetNetworks(&list); ASSERT_EQ(1U, list.size()); EXPECT_EQ(net2, list[0]); // Now network1 is inactive. Try to merge it again. list.clear(); list.push_back(new Network(network1)); MergeNetworkList(manager, list, &changed); EXPECT_TRUE(changed); list.clear(); manager.GetNetworks(&list); ASSERT_EQ(1U, list.size()); EXPECT_TRUE(list[0]->active()); EXPECT_EQ(net1, list[0]); } // Test that the filtering logic follows the defined ruleset in network.h. TEST_F(NetworkTest, TestIPv6Selection) { InterfaceAddress ip; std::string ipstr; ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3"; ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip)); // Create a network with this prefix. Network ipv6_network( "test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64), 64); // When there is no address added, it should return an unspecified // address. EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress()); EXPECT_TRUE(IPIsUnspec(ipv6_network.GetBestIP())); // Deprecated one should not be returned. ipv6_network.AddIP(ip); EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress()); // Add ULA one. ULA is unique local address which is starting either // with 0xfc or 0xfd. ipstr = "fd00:fa00:4:1000:be30:5bff:fee5:c4"; ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip)); ipv6_network.AddIP(ip); EXPECT_EQ(ipv6_network.GetBestIP(), static_cast(ip)); // Add global one. ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c5"; ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip)); ipv6_network.AddIP(ip); EXPECT_EQ(ipv6_network.GetBestIP(), static_cast(ip)); // Add global dynamic temporary one. ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6"; ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip)); ipv6_network.AddIP(ip); EXPECT_EQ(ipv6_network.GetBestIP(), static_cast(ip)); } TEST_F(NetworkTest, TestNetworkMonitoring) { BasicNetworkManager manager; manager.SignalNetworksChanged.connect(static_cast(this), &NetworkTest::OnNetworksChanged); FakeNetworkMonitorFactory* factory = new FakeNetworkMonitorFactory(); NetworkMonitorFactory::SetFactory(factory); manager.StartUpdating(); FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager); EXPECT_TRUE(network_monitor && network_monitor->started()); EXPECT_TRUE_WAIT(callback_called_, 1000); callback_called_ = false; // Clear the networks so that there will be network changes below. ClearNetworks(manager); // Network manager is started, so the callback is called when the network // monitor fires the network-change event. network_monitor->OnNetworksChanged(); EXPECT_TRUE_WAIT(callback_called_, 1000); // Network manager is stopped. manager.StopUpdating(); EXPECT_FALSE(GetNetworkMonitor(manager)->started()); NetworkMonitorFactory::ReleaseFactory(factory); } TEST_F(NetworkTest, DefaultLocalAddress) { IPAddress ip; TestBasicNetworkManager manager; manager.SignalNetworksChanged.connect(static_cast(this), &NetworkTest::OnNetworksChanged); FakeNetworkMonitorFactory* factory = new FakeNetworkMonitorFactory(); NetworkMonitorFactory::SetFactory(factory); manager.StartUpdating(); EXPECT_TRUE_WAIT(callback_called_, 1000); // Make sure we can query default local address when an address for such // address family exists. std::vector networks; manager.GetNetworks(&networks); EXPECT_TRUE(!networks.empty()); for (auto& network : networks) { if (network->GetBestIP().family() == AF_INET) { EXPECT_TRUE(manager.QueryDefaultLocalAddress(AF_INET) != IPAddress()); } else if (network->GetBestIP().family() == AF_INET6 && !IPIsLoopback(network->GetBestIP())) { // Existence of an IPv6 loopback address doesn't mean it has IPv6 network // enabled. EXPECT_TRUE(manager.QueryDefaultLocalAddress(AF_INET6) != IPAddress()); } } // GetDefaultLocalAddress should return the valid default address after set. manager.set_default_local_addresses(GetLoopbackIP(AF_INET), GetLoopbackIP(AF_INET6)); EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET, &ip)); EXPECT_EQ(ip, GetLoopbackIP(AF_INET)); EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip)); EXPECT_EQ(ip, GetLoopbackIP(AF_INET6)); // More tests on GetDefaultLocalAddress with ipv6 addresses where the set // default address may be different from the best IP address of any network. InterfaceAddress ip1; EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:1111", IPV6_ADDRESS_FLAG_TEMPORARY, &ip1)); // Create a network with a prefix of ip1. Network ipv6_network("test_eth0", "Test NetworkAdapter", TruncateIP(ip1, 64), 64); IPAddress ip2; EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:2222", &ip2)); ipv6_network.AddIP(ip1); ipv6_network.AddIP(ip2); BasicNetworkManager::NetworkList list(1, new Network(ipv6_network)); bool changed; MergeNetworkList(manager, list, &changed); // If the set default address is not in any network, GetDefaultLocalAddress // should return it. IPAddress ip3; EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:3333", &ip3)); manager.set_default_local_addresses(GetLoopbackIP(AF_INET), ip3); EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip)); EXPECT_EQ(ip3, ip); // If the set default address is in a network, GetDefaultLocalAddress will // return the best IP in that network. manager.set_default_local_addresses(GetLoopbackIP(AF_INET), ip2); EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip)); EXPECT_EQ(static_cast(ip1), ip); manager.StopUpdating(); } } // namespace rtc