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