1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "third_party/blink/renderer/platform/p2p/ipc_network_manager.h"
6 
7 #include <algorithm>
8 #include <memory>
9 
10 #include "net/base/ip_address.h"
11 #include "net/base/network_change_notifier.h"
12 #include "net/base/network_interfaces.h"
13 #include "testing/gtest/include/gtest/gtest.h"
14 #include "third_party/blink/renderer/platform/p2p/network_list_manager.h"
15 #include "third_party/webrtc/rtc_base/mdns_responder_interface.h"
16 
17 namespace blink {
18 
19 namespace {
20 
21 class MockP2PSocketDispatcher : public blink::NetworkListManager {
22  public:
AddNetworkListObserver(blink::NetworkListObserver * network_list_observer)23   void AddNetworkListObserver(
24       blink::NetworkListObserver* network_list_observer) override {}
25 
RemoveNetworkListObserver(blink::NetworkListObserver * network_list_observer)26   void RemoveNetworkListObserver(
27       blink::NetworkListObserver* network_list_observer) override {}
28 
~MockP2PSocketDispatcher()29   ~MockP2PSocketDispatcher() override {}
30 };
31 
32 class EmptyMdnsResponder : public webrtc::MdnsResponderInterface {
33  public:
CreateNameForAddress(const rtc::IPAddress & addr,NameCreatedCallback callback)34   void CreateNameForAddress(const rtc::IPAddress& addr,
35                             NameCreatedCallback callback) override {}
RemoveNameForAddress(const rtc::IPAddress & addr,NameRemovedCallback callback)36   void RemoveNameForAddress(const rtc::IPAddress& addr,
37                             NameRemovedCallback callback) override {}
38 };
39 
40 }  // namespace
41 
42 // 2 IPv6 addresses with only last digit different.
43 static const char kIPv6PublicAddrString1[] =
44     "2401:fa00:4:1000:be30:5b30:50e5:c3";
45 static const char kIPv6PublicAddrString2[] =
46     "2401:fa00:4:1000:be30:5b30:50e5:c4";
47 static const char kIPv4MappedAddrString[] = "::ffff:38.32.0.0";
48 
49 class IpcNetworkManagerTest : public testing::Test {
50  public:
IpcNetworkManagerTest()51   IpcNetworkManagerTest()
52       : network_list_manager_(new MockP2PSocketDispatcher()),
53         network_manager_(std::make_unique<IpcNetworkManager>(
54             network_list_manager_.get(),
55             std::make_unique<EmptyMdnsResponder>())) {}
56 
57  protected:
58   std::unique_ptr<MockP2PSocketDispatcher> network_list_manager_;
59   std::unique_ptr<IpcNetworkManager> network_manager_;
60 };
61 
62 // Test overall logic of IpcNetworkManager on OnNetworkListChanged
63 // that it should group addresses with the same network key under
64 // single Network class. This also tests the logic inside
65 // IpcNetworkManager in addition to MergeNetworkList.
66 // TODO(guoweis): disable this test case for now until fix for webrtc
67 // issue 19249005 integrated into chromium
TEST_F(IpcNetworkManagerTest,TestMergeNetworkList)68 TEST_F(IpcNetworkManagerTest, TestMergeNetworkList) {
69   net::NetworkInterfaceList list;
70   net::IPAddress ip;
71   std::vector<rtc::Network*> networks;
72   rtc::IPAddress ip_address;
73 
74   // Add 2 networks with the same prefix and prefix length.
75   EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv6PublicAddrString1));
76   list.push_back(net::NetworkInterface(
77       "em1", "em1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 64,
78       net::IP_ADDRESS_ATTRIBUTE_NONE));
79 
80   EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv6PublicAddrString2));
81   list.push_back(net::NetworkInterface(
82       "em1", "em1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 64,
83       net::IP_ADDRESS_ATTRIBUTE_NONE));
84 
85   network_manager_->OnNetworkListChanged(list, net::IPAddress(),
86                                          net::IPAddress());
87   network_manager_->GetNetworks(&networks);
88   EXPECT_EQ(1uL, networks.size());
89   EXPECT_EQ(2uL, networks[0]->GetIPs().size());
90 
91   // Add another network with different prefix length, should result in
92   // a different network.
93   networks.clear();
94   list.push_back(net::NetworkInterface(
95       "em1", "em1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 48,
96       net::IP_ADDRESS_ATTRIBUTE_NONE));
97 
98   // Push an unknown address as the default address.
99   EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv4MappedAddrString));
100   network_manager_->OnNetworkListChanged(list, net::IPAddress(), ip);
101 
102   // The unknown default address should be ignored.
103   EXPECT_FALSE(network_manager_->GetDefaultLocalAddress(AF_INET6, &ip_address));
104 
105   network_manager_->GetNetworks(&networks);
106 
107   // Verify we have 2 networks now.
108   EXPECT_EQ(2uL, networks.size());
109   // Verify the network with prefix length of 64 has 2 IP addresses.
110   auto network_with_two_ips = std::find_if(
111       networks.begin(), networks.end(),
112       [](rtc::Network* network) { return network->prefix_length() == 64; });
113   ASSERT_NE(networks.end(), network_with_two_ips);
114   EXPECT_EQ(2uL, (*network_with_two_ips)->GetIPs().size());
115   // IPs should be in the same order as the list passed into
116   // OnNetworkListChanged.
117   EXPECT_TRUE(rtc::IPFromString(kIPv6PublicAddrString1, &ip_address));
118   EXPECT_EQ((*network_with_two_ips)->GetIPs()[0],
119             rtc::InterfaceAddress(ip_address));
120   EXPECT_TRUE(rtc::IPFromString(kIPv6PublicAddrString2, &ip_address));
121   EXPECT_EQ((*network_with_two_ips)->GetIPs()[1],
122             rtc::InterfaceAddress(ip_address));
123   // Verify the network with prefix length of 48 has 1 IP address.
124   auto network_with_one_ip = std::find_if(
125       networks.begin(), networks.end(),
126       [](rtc::Network* network) { return network->prefix_length() == 48; });
127   ASSERT_NE(networks.end(), network_with_one_ip);
128   EXPECT_EQ(1uL, (*network_with_one_ip)->GetIPs().size());
129   EXPECT_TRUE(rtc::IPFromString(kIPv6PublicAddrString2, &ip_address));
130   EXPECT_EQ((*network_with_one_ip)->GetIPs()[0],
131             rtc::InterfaceAddress(ip_address));
132 }
133 
134 // Test that IpcNetworkManager will guess a network type from the interface
135 // name when not otherwise available.
TEST_F(IpcNetworkManagerTest,DeterminesNetworkTypeFromNameIfUnknown)136 TEST_F(IpcNetworkManagerTest, DeterminesNetworkTypeFromNameIfUnknown) {
137   net::NetworkInterfaceList list;
138   net::IPAddress ip;
139   std::vector<rtc::Network*> networks;
140   rtc::IPAddress ip_address;
141 
142   // Add a "tun1" entry of type "unknown" and "tun2" entry of type Wi-Fi. The
143   // "tun1" entry (and only it) should have its type determined from its name,
144   // since its type is unknown.
145   EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv6PublicAddrString1));
146   list.push_back(net::NetworkInterface(
147       "tun1", "tun1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 64,
148       net::IP_ADDRESS_ATTRIBUTE_NONE));
149 
150   EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv6PublicAddrString2));
151   list.push_back(net::NetworkInterface(
152       "tun2", "tun2", 0, net::NetworkChangeNotifier::CONNECTION_WIFI, ip, 64,
153       net::IP_ADDRESS_ATTRIBUTE_NONE));
154 
155   network_manager_->OnNetworkListChanged(list, net::IPAddress(),
156                                          net::IPAddress());
157   network_manager_->GetNetworks(&networks);
158   EXPECT_EQ(2uL, networks.size());
159 
160   auto tun1 = std::find_if(
161       networks.begin(), networks.end(),
162       [](rtc::Network* network) { return network->name() == "tun1"; });
163   ASSERT_NE(networks.end(), tun1);
164   auto tun2 = std::find_if(
165       networks.begin(), networks.end(),
166       [](rtc::Network* network) { return network->name() == "tun2"; });
167   ASSERT_NE(networks.end(), tun1);
168 
169   EXPECT_EQ(rtc::ADAPTER_TYPE_VPN, (*tun1)->type());
170   EXPECT_EQ(rtc::ADAPTER_TYPE_WIFI, (*tun2)->type());
171 }
172 
173 // Test that IpcNetworkManager will act as the mDNS responder provider for
174 // all networks that it returns.
TEST_F(IpcNetworkManagerTest,ServeAsMdnsResponderProviderForNetworksEnumerated)175 TEST_F(IpcNetworkManagerTest,
176        ServeAsMdnsResponderProviderForNetworksEnumerated) {
177   net::NetworkInterfaceList list;
178   // Add networks.
179   net::IPAddress ip;
180   EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv6PublicAddrString1));
181   list.push_back(net::NetworkInterface(
182       "em1", "em1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 64,
183       net::IP_ADDRESS_ATTRIBUTE_NONE));
184 
185   network_manager_->OnNetworkListChanged(list, net::IPAddress(),
186                                          net::IPAddress());
187   std::vector<rtc::Network*> networks;
188   network_manager_->GetNetworks(&networks);
189 
190   ASSERT_EQ(1u, networks.size());
191   webrtc::MdnsResponderInterface* const mdns_responder =
192       network_manager_->GetMdnsResponder();
193   EXPECT_EQ(mdns_responder, networks[0]->GetMdnsResponder());
194   networks.clear();
195   network_manager_->GetAnyAddressNetworks(&networks);
196   ASSERT_EQ(2u, networks.size());
197   EXPECT_EQ(mdns_responder, networks[0]->GetMdnsResponder());
198   EXPECT_EQ(mdns_responder, networks[1]->GetMdnsResponder());
199 }
200 
201 }  // namespace blink
202