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 <vector>
14#if defined(WEBRTC_POSIX)
15#include <sys/types.h>
16#if !defined(WEBRTC_ANDROID)
17#include <ifaddrs.h>
18#else
19#include "webrtc/base/ifaddrs-android.h"
20#endif
21#endif
22#include "webrtc/base/gunit.h"
23#if defined(WEBRTC_WIN)
24#include "webrtc/base/logging.h"  // For LOG_GLE
25#endif
26
27namespace rtc {
28
29class NetworkTest : public testing::Test, public sigslot::has_slots<>  {
30 public:
31  NetworkTest() : callback_called_(false) {}
32
33  void OnNetworksChanged() {
34    callback_called_ = true;
35  }
36
37  void MergeNetworkList(BasicNetworkManager& network_manager,
38                        const NetworkManager::NetworkList& list,
39                        bool* changed ) {
40    network_manager.MergeNetworkList(list, changed);
41  }
42
43  bool IsIgnoredNetwork(BasicNetworkManager& network_manager,
44                        const Network& network) {
45    return network_manager.IsIgnoredNetwork(network);
46  }
47
48  NetworkManager::NetworkList GetNetworks(
49      const BasicNetworkManager& network_manager, bool include_ignored) {
50    NetworkManager::NetworkList list;
51    network_manager.CreateNetworks(include_ignored, &list);
52    return list;
53  }
54
55#if defined(WEBRTC_POSIX)
56  // Separated from CreateNetworks for tests.
57  static void CallConvertIfAddrs(const BasicNetworkManager& network_manager,
58                                 struct ifaddrs* interfaces,
59                                 bool include_ignored,
60                                 NetworkManager::NetworkList* networks) {
61    network_manager.ConvertIfAddrs(interfaces, include_ignored, networks);
62  }
63#endif  // defined(WEBRTC_POSIX)
64
65 protected:
66  bool callback_called_;
67};
68
69// Test that the Network ctor works properly.
70TEST_F(NetworkTest, TestNetworkConstruct) {
71  Network ipv4_network1("test_eth0", "Test Network Adapter 1",
72                        IPAddress(0x12345600U), 24);
73  EXPECT_EQ("test_eth0", ipv4_network1.name());
74  EXPECT_EQ("Test Network Adapter 1", ipv4_network1.description());
75  EXPECT_EQ(IPAddress(0x12345600U), ipv4_network1.prefix());
76  EXPECT_EQ(24, ipv4_network1.prefix_length());
77  EXPECT_FALSE(ipv4_network1.ignored());
78}
79
80// Tests that our ignore function works properly.
81TEST_F(NetworkTest, TestNetworkIgnore) {
82  Network ipv4_network1("test_eth0", "Test Network Adapter 1",
83                        IPAddress(0x12345600U), 24);
84  Network ipv4_network2("test_eth1", "Test Network Adapter 2",
85                        IPAddress(0x00010000U), 16);
86  BasicNetworkManager network_manager;
87  EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1));
88  EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network2));
89}
90
91TEST_F(NetworkTest, TestIgnoreList) {
92  Network ignore_me("ignore_me", "Ignore me please!",
93                    IPAddress(0x12345600U), 24);
94  Network include_me("include_me", "Include me please!",
95                     IPAddress(0x12345600U), 24);
96  BasicNetworkManager network_manager;
97  EXPECT_FALSE(IsIgnoredNetwork(network_manager, ignore_me));
98  EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me));
99  std::vector<std::string> ignore_list;
100  ignore_list.push_back("ignore_me");
101  network_manager.set_network_ignore_list(ignore_list);
102  EXPECT_TRUE(IsIgnoredNetwork(network_manager, ignore_me));
103  EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me));
104}
105
106// Test is failing on Windows opt: b/11288214
107TEST_F(NetworkTest, DISABLED_TestCreateNetworks) {
108  BasicNetworkManager manager;
109  NetworkManager::NetworkList result = GetNetworks(manager, true);
110  // We should be able to bind to any addresses we find.
111  NetworkManager::NetworkList::iterator it;
112  for (it = result.begin();
113       it != result.end();
114       ++it) {
115    sockaddr_storage storage;
116    memset(&storage, 0, sizeof(storage));
117    IPAddress ip = (*it)->GetBestIP();
118    SocketAddress bindaddress(ip, 0);
119    bindaddress.SetScopeID((*it)->scope_id());
120    // TODO(thaloun): Use rtc::AsyncSocket once it supports IPv6.
121    int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
122    if (fd > 0) {
123      size_t ipsize = bindaddress.ToSockAddrStorage(&storage);
124      EXPECT_GE(ipsize, 0U);
125      int success = ::bind(fd,
126                           reinterpret_cast<sockaddr*>(&storage),
127                           static_cast<int>(ipsize));
128#if defined(WEBRTC_WIN)
129      if (success) LOG_GLE(LS_ERROR) << "Socket bind failed.";
130#endif
131      EXPECT_EQ(0, success);
132#if defined(WEBRTC_WIN)
133      closesocket(fd);
134#else
135      close(fd);
136#endif
137    }
138    delete (*it);
139  }
140}
141
142// Test that UpdateNetworks succeeds.
143TEST_F(NetworkTest, TestUpdateNetworks) {
144  BasicNetworkManager manager;
145  manager.SignalNetworksChanged.connect(
146      static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
147  manager.StartUpdating();
148  Thread::Current()->ProcessMessages(0);
149  EXPECT_TRUE(callback_called_);
150  callback_called_ = false;
151  // Callback should be triggered immediately when StartUpdating
152  // is called, after network update signal is already sent.
153  manager.StartUpdating();
154  EXPECT_TRUE(manager.started());
155  Thread::Current()->ProcessMessages(0);
156  EXPECT_TRUE(callback_called_);
157  manager.StopUpdating();
158  EXPECT_TRUE(manager.started());
159  manager.StopUpdating();
160  EXPECT_FALSE(manager.started());
161  manager.StopUpdating();
162  EXPECT_FALSE(manager.started());
163  callback_called_ = false;
164  // Callback should be triggered immediately after StartUpdating is called
165  // when start_count_ is reset to 0.
166  manager.StartUpdating();
167  Thread::Current()->ProcessMessages(0);
168  EXPECT_TRUE(callback_called_);
169}
170
171// Verify that MergeNetworkList() merges network lists properly.
172TEST_F(NetworkTest, TestBasicMergeNetworkList) {
173  Network ipv4_network1("test_eth0", "Test Network Adapter 1",
174                        IPAddress(0x12345600U), 24);
175  Network ipv4_network2("test_eth1", "Test Network Adapter 2",
176                        IPAddress(0x00010000U), 16);
177  ipv4_network1.AddIP(IPAddress(0x12345678));
178  ipv4_network2.AddIP(IPAddress(0x00010004));
179  BasicNetworkManager manager;
180
181  // Add ipv4_network1 to the list of networks.
182  NetworkManager::NetworkList list;
183  list.push_back(new Network(ipv4_network1));
184  bool changed;
185  MergeNetworkList(manager, list, &changed);
186  EXPECT_TRUE(changed);
187  list.clear();
188
189  manager.GetNetworks(&list);
190  EXPECT_EQ(1U, list.size());
191  EXPECT_EQ(ipv4_network1.ToString(), list[0]->ToString());
192  Network* net1 = list[0];
193  list.clear();
194
195  // Replace ipv4_network1 with ipv4_network2.
196  list.push_back(new Network(ipv4_network2));
197  MergeNetworkList(manager, list, &changed);
198  EXPECT_TRUE(changed);
199  list.clear();
200
201  manager.GetNetworks(&list);
202  EXPECT_EQ(1U, list.size());
203  EXPECT_EQ(ipv4_network2.ToString(), list[0]->ToString());
204  Network* net2 = list[0];
205  list.clear();
206
207  // Add Network2 back.
208  list.push_back(new Network(ipv4_network1));
209  list.push_back(new Network(ipv4_network2));
210  MergeNetworkList(manager, list, &changed);
211  EXPECT_TRUE(changed);
212  list.clear();
213
214  // Verify that we get previous instances of Network objects.
215  manager.GetNetworks(&list);
216  EXPECT_EQ(2U, list.size());
217  EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
218              (net1 == list[1] && net2 == list[0]));
219  list.clear();
220
221  // Call MergeNetworkList() again and verify that we don't get update
222  // notification.
223  list.push_back(new Network(ipv4_network2));
224  list.push_back(new Network(ipv4_network1));
225  MergeNetworkList(manager, list, &changed);
226  EXPECT_FALSE(changed);
227  list.clear();
228
229  // Verify that we get previous instances of Network objects.
230  manager.GetNetworks(&list);
231  EXPECT_EQ(2U, list.size());
232  EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
233              (net1 == list[1] && net2 == list[0]));
234  list.clear();
235}
236
237// Sets up some test IPv6 networks and appends them to list.
238// Four networks are added - public and link local, for two interfaces.
239void SetupNetworks(NetworkManager::NetworkList* list) {
240  IPAddress ip;
241  IPAddress prefix;
242  EXPECT_TRUE(IPFromString("fe80::1234:5678:abcd:ef12", &ip));
243  EXPECT_TRUE(IPFromString("fe80::", &prefix));
244  // First, fake link-locals.
245  Network ipv6_eth0_linklocalnetwork("test_eth0", "Test NetworkAdapter 1",
246                                     prefix, 64);
247  ipv6_eth0_linklocalnetwork.AddIP(ip);
248  EXPECT_TRUE(IPFromString("fe80::5678:abcd:ef12:3456", &ip));
249  Network ipv6_eth1_linklocalnetwork("test_eth1", "Test NetworkAdapter 2",
250                                     prefix, 64);
251  ipv6_eth1_linklocalnetwork.AddIP(ip);
252  // Public networks:
253  EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip));
254  prefix = TruncateIP(ip, 64);
255  Network ipv6_eth0_publicnetwork1_ip1("test_eth0", "Test NetworkAdapter 1",
256                                       prefix, 64);
257  ipv6_eth0_publicnetwork1_ip1.AddIP(ip);
258  EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
259  prefix = TruncateIP(ip, 64);
260  Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 1",
261                                       prefix, 64);
262  ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
263  list->push_back(new Network(ipv6_eth0_linklocalnetwork));
264  list->push_back(new Network(ipv6_eth1_linklocalnetwork));
265  list->push_back(new Network(ipv6_eth0_publicnetwork1_ip1));
266  list->push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
267}
268
269// Test that the basic network merging case works.
270TEST_F(NetworkTest, TestIPv6MergeNetworkList) {
271  BasicNetworkManager manager;
272  manager.SignalNetworksChanged.connect(
273      static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
274  NetworkManager::NetworkList original_list;
275  SetupNetworks(&original_list);
276  bool changed = false;
277  MergeNetworkList(manager, original_list, &changed);
278  EXPECT_TRUE(changed);
279  NetworkManager::NetworkList list;
280  manager.GetNetworks(&list);
281  EXPECT_EQ(original_list.size(), list.size());
282  // Verify that the original members are in the merged list.
283  for (NetworkManager::NetworkList::iterator it = original_list.begin();
284       it != original_list.end(); ++it) {
285    EXPECT_NE(list.end(), std::find(list.begin(), list.end(), *it));
286  }
287}
288
289// Tests that when two network lists that describe the same set of networks are
290// merged, that the changed callback is not called, and that the original
291// objects remain in the result list.
292TEST_F(NetworkTest, TestNoChangeMerge) {
293  BasicNetworkManager manager;
294  manager.SignalNetworksChanged.connect(
295      static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
296  NetworkManager::NetworkList original_list;
297  SetupNetworks(&original_list);
298  bool changed = false;
299  MergeNetworkList(manager, original_list, &changed);
300  EXPECT_TRUE(changed);
301  // Second list that describes the same networks but with new objects.
302  NetworkManager::NetworkList second_list;
303  SetupNetworks(&second_list);
304  changed = false;
305  MergeNetworkList(manager, second_list, &changed);
306  EXPECT_FALSE(changed);
307  NetworkManager::NetworkList resulting_list;
308  manager.GetNetworks(&resulting_list);
309  EXPECT_EQ(original_list.size(), resulting_list.size());
310  // Verify that the original members are in the merged list.
311  for (NetworkManager::NetworkList::iterator it = original_list.begin();
312       it != original_list.end(); ++it) {
313    EXPECT_NE(resulting_list.end(),
314              std::find(resulting_list.begin(), resulting_list.end(), *it));
315  }
316  // Doublecheck that the new networks aren't in the list.
317  for (NetworkManager::NetworkList::iterator it = second_list.begin();
318       it != second_list.end(); ++it) {
319    EXPECT_EQ(resulting_list.end(),
320              std::find(resulting_list.begin(), resulting_list.end(), *it));
321  }
322}
323
324// Test that we can merge a network that is the same as another network but with
325// a different IP. The original network should remain in the list, but have its
326// IP changed.
327TEST_F(NetworkTest, MergeWithChangedIP) {
328  BasicNetworkManager manager;
329  manager.SignalNetworksChanged.connect(
330      static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
331  NetworkManager::NetworkList original_list;
332  SetupNetworks(&original_list);
333  // Make a network that we're going to change.
334  IPAddress ip;
335  EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip));
336  IPAddress prefix = TruncateIP(ip, 64);
337  Network* network_to_change = new Network("test_eth0",
338                                          "Test Network Adapter 1",
339                                          prefix, 64);
340  Network* changed_network = new Network(*network_to_change);
341  network_to_change->AddIP(ip);
342  IPAddress changed_ip;
343  EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip));
344  changed_network->AddIP(changed_ip);
345  original_list.push_back(network_to_change);
346  bool changed = false;
347  MergeNetworkList(manager, original_list, &changed);
348  NetworkManager::NetworkList second_list;
349  SetupNetworks(&second_list);
350  second_list.push_back(changed_network);
351  changed = false;
352  MergeNetworkList(manager, second_list, &changed);
353  EXPECT_TRUE(changed);
354  NetworkManager::NetworkList list;
355  manager.GetNetworks(&list);
356  EXPECT_EQ(original_list.size(), list.size());
357  // Make sure the original network is still in the merged list.
358  EXPECT_NE(list.end(),
359            std::find(list.begin(), list.end(), network_to_change));
360  EXPECT_EQ(changed_ip, network_to_change->GetIPs().at(0));
361}
362
363// Testing a similar case to above, but checking that a network can be updated
364// with additional IPs (not just a replacement).
365TEST_F(NetworkTest, TestMultipleIPMergeNetworkList) {
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  MergeNetworkList(manager, original_list, &changed);
373  EXPECT_TRUE(changed);
374  IPAddress ip;
375  IPAddress check_ip;
376  IPAddress prefix;
377  // Add a second IP to the public network on eth0 (2401:fa00:4:1000/64).
378  EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip));
379  prefix = TruncateIP(ip, 64);
380  Network ipv6_eth0_publicnetwork1_ip2("test_eth0", "Test NetworkAdapter 1",
381                                       prefix, 64);
382  // This is the IP that already existed in the public network on eth0.
383  EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip));
384  ipv6_eth0_publicnetwork1_ip2.AddIP(ip);
385  original_list.push_back(new Network(ipv6_eth0_publicnetwork1_ip2));
386  changed = false;
387  MergeNetworkList(manager, original_list, &changed);
388  EXPECT_TRUE(changed);
389  // There should still be four networks.
390  NetworkManager::NetworkList list;
391  manager.GetNetworks(&list);
392  EXPECT_EQ(4U, list.size());
393  // Check the gathered IPs.
394  int matchcount = 0;
395  for (NetworkManager::NetworkList::iterator it = list.begin();
396       it != list.end(); ++it) {
397    if ((*it)->ToString() == original_list[2]->ToString()) {
398      ++matchcount;
399      EXPECT_EQ(1, matchcount);
400      // This should be the same network object as before.
401      EXPECT_EQ((*it), original_list[2]);
402      // But with two addresses now.
403      EXPECT_EQ(2U, (*it)->GetIPs().size());
404      EXPECT_NE((*it)->GetIPs().end(),
405                std::find((*it)->GetIPs().begin(),
406                          (*it)->GetIPs().end(),
407                          check_ip));
408      EXPECT_NE((*it)->GetIPs().end(),
409                std::find((*it)->GetIPs().begin(),
410                          (*it)->GetIPs().end(),
411                          ip));
412    } else {
413      // Check the IP didn't get added anywhere it wasn't supposed to.
414      EXPECT_EQ((*it)->GetIPs().end(),
415                std::find((*it)->GetIPs().begin(),
416                          (*it)->GetIPs().end(),
417                          ip));
418    }
419  }
420}
421
422// Test that merge correctly distinguishes multiple networks on an interface.
423TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) {
424  BasicNetworkManager manager;
425  manager.SignalNetworksChanged.connect(
426      static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
427  NetworkManager::NetworkList original_list;
428  SetupNetworks(&original_list);
429  bool changed = false;
430  MergeNetworkList(manager, original_list, &changed);
431  EXPECT_TRUE(changed);
432  IPAddress ip;
433  IPAddress prefix;
434  // A second network for eth0.
435  EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip));
436  prefix = TruncateIP(ip, 64);
437  Network ipv6_eth0_publicnetwork2_ip1("test_eth0", "Test NetworkAdapter 1",
438                                       prefix, 64);
439  ipv6_eth0_publicnetwork2_ip1.AddIP(ip);
440  original_list.push_back(new Network(ipv6_eth0_publicnetwork2_ip1));
441  changed = false;
442  MergeNetworkList(manager, original_list, &changed);
443  EXPECT_TRUE(changed);
444  // There should be five networks now.
445  NetworkManager::NetworkList list;
446  manager.GetNetworks(&list);
447  EXPECT_EQ(5U, list.size());
448  // Check the resulting addresses.
449  for (NetworkManager::NetworkList::iterator it = list.begin();
450       it != list.end(); ++it) {
451    if ((*it)->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() &&
452        (*it)->name() == ipv6_eth0_publicnetwork2_ip1.name()) {
453      // Check the new network has 1 IP and that it's the correct one.
454      EXPECT_EQ(1U, (*it)->GetIPs().size());
455      EXPECT_EQ(ip, (*it)->GetIPs().at(0));
456    } else {
457      // Check the IP didn't get added anywhere it wasn't supposed to.
458      EXPECT_EQ((*it)->GetIPs().end(),
459                std::find((*it)->GetIPs().begin(),
460                          (*it)->GetIPs().end(),
461                          ip));
462    }
463  }
464}
465
466// Test that DumpNetworks works.
467TEST_F(NetworkTest, TestDumpNetworks) {
468  BasicNetworkManager manager;
469  manager.DumpNetworks(true);
470}
471
472// Test that we can toggle IPv6 on and off.
473TEST_F(NetworkTest, TestIPv6Toggle) {
474  BasicNetworkManager manager;
475  bool ipv6_found = false;
476  NetworkManager::NetworkList list;
477#if !defined(WEBRTC_WIN)
478  // There should be at least one IPv6 network (fe80::/64 should be in there).
479  // TODO(thaloun): Disabling this test on windows for the moment as the test
480  // machines don't seem to have IPv6 installed on them at all.
481  manager.set_ipv6_enabled(true);
482  list = GetNetworks(manager, true);
483  for (NetworkManager::NetworkList::iterator it = list.begin();
484       it != list.end(); ++it) {
485    if ((*it)->prefix().family() == AF_INET6) {
486      ipv6_found = true;
487      break;
488    }
489  }
490  EXPECT_TRUE(ipv6_found);
491  for (NetworkManager::NetworkList::iterator it = list.begin();
492       it != list.end(); ++it) {
493    delete (*it);
494  }
495#endif
496  ipv6_found = false;
497  manager.set_ipv6_enabled(false);
498  list = GetNetworks(manager, true);
499  for (NetworkManager::NetworkList::iterator it = list.begin();
500       it != list.end(); ++it) {
501    if ((*it)->prefix().family() == AF_INET6) {
502      ipv6_found = true;
503      break;
504    }
505  }
506  EXPECT_FALSE(ipv6_found);
507  for (NetworkManager::NetworkList::iterator it = list.begin();
508       it != list.end(); ++it) {
509    delete (*it);
510  }
511}
512
513TEST_F(NetworkTest, TestNetworkListSorting) {
514  BasicNetworkManager manager;
515  Network ipv4_network1("test_eth0", "Test Network Adapter 1",
516                        IPAddress(0x12345600U), 24);
517  ipv4_network1.AddIP(IPAddress(0x12345600U));
518
519  IPAddress ip;
520  IPAddress prefix;
521  EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
522  prefix = TruncateIP(ip, 64);
523  Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 2",
524                                       prefix, 64);
525  ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
526
527  NetworkManager::NetworkList list;
528  list.push_back(new Network(ipv4_network1));
529  list.push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
530  Network* net1 = list[0];
531  Network* net2 = list[1];
532
533  bool changed = false;
534  MergeNetworkList(manager, list, &changed);
535  ASSERT_TRUE(changed);
536  // After sorting IPv6 network should be higher order than IPv4 networks.
537  EXPECT_TRUE(net1->preference() < net2->preference());
538}
539
540TEST_F(NetworkTest, TestNetworkAdapterTypes) {
541  Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24,
542               ADAPTER_TYPE_WIFI);
543  EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type());
544  Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24,
545                   ADAPTER_TYPE_ETHERNET);
546  EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type());
547  Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24,
548                   ADAPTER_TYPE_CELLULAR);
549  EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type());
550  Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24,
551              ADAPTER_TYPE_VPN);
552  EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type());
553  Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24,
554                  ADAPTER_TYPE_UNKNOWN);
555  EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type());
556}
557
558#if defined(WEBRTC_POSIX)
559// Verify that we correctly handle interfaces with no address.
560TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) {
561  ifaddrs list;
562  memset(&list, 0, sizeof(list));
563  list.ifa_name = const_cast<char*>("test_iface");
564
565  NetworkManager::NetworkList result;
566  BasicNetworkManager manager;
567  CallConvertIfAddrs(manager, &list, true, &result);
568  EXPECT_TRUE(result.empty());
569}
570#endif  // defined(WEBRTC_POSIX)
571
572#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
573// If you want to test non-default routes, you can do the following on a linux
574// machine:
575// 1) Load the dummy network driver:
576// sudo modprobe dummy
577// sudo ifconfig dummy0 127.0.0.1
578// 2) Run this test and confirm the output says it found a dummy route (and
579// passes).
580// 3) When done:
581// sudo rmmmod dummy
582TEST_F(NetworkTest, TestIgnoreNonDefaultRoutes) {
583  BasicNetworkManager manager;
584  NetworkManager::NetworkList list;
585  list = GetNetworks(manager, false);
586  bool found_dummy = false;
587  LOG(LS_INFO) << "Looking for dummy network: ";
588  for (NetworkManager::NetworkList::iterator it = list.begin();
589       it != list.end(); ++it) {
590    LOG(LS_INFO) << "  Network name: " << (*it)->name();
591    found_dummy |= (*it)->name().find("dummy0") != std::string::npos;
592  }
593  for (NetworkManager::NetworkList::iterator it = list.begin();
594       it != list.end(); ++it) {
595    delete (*it);
596  }
597  if (!found_dummy) {
598    LOG(LS_INFO) << "No dummy found, quitting.";
599    return;
600  }
601  LOG(LS_INFO) << "Found dummy, running again while ignoring non-default "
602               << "routes.";
603  manager.set_ignore_non_default_routes(true);
604  list = GetNetworks(manager, false);
605  for (NetworkManager::NetworkList::iterator it = list.begin();
606       it != list.end(); ++it) {
607    LOG(LS_INFO) << "  Network name: " << (*it)->name();
608    EXPECT_TRUE((*it)->name().find("dummy0") == std::string::npos);
609  }
610  for (NetworkManager::NetworkList::iterator it = list.begin();
611       it != list.end(); ++it) {
612    delete (*it);
613  }
614}
615#endif
616
617// Test MergeNetworkList successfully combines all IPs for the same
618// prefix/length into a single Network.
619TEST_F(NetworkTest, TestMergeNetworkList) {
620  BasicNetworkManager manager;
621  NetworkManager::NetworkList list;
622
623  // Create 2 IPAddress classes with only last digit different.
624  IPAddress ip1, ip2;
625  EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
626  EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:2", &ip2));
627
628  // Create 2 networks with the same prefix and length.
629  Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
630  Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
631
632  // Add different IP into each.
633  net1->AddIP(ip1);
634  net2->AddIP(ip2);
635
636  list.push_back(net1);
637  list.push_back(net2);
638  bool changed;
639  MergeNetworkList(manager, list, &changed);
640  EXPECT_TRUE(changed);
641
642  NetworkManager::NetworkList list2;
643  manager.GetNetworks(&list2);
644
645  // Make sure the resulted networklist has only 1 element and 2
646  // IPAddresses.
647  EXPECT_EQ(list2.size(), 1uL);
648  EXPECT_EQ(list2[0]->GetIPs().size(), 2uL);
649  EXPECT_EQ(list2[0]->GetIPs()[0], ip1);
650  EXPECT_EQ(list2[0]->GetIPs()[1], ip2);
651}
652
653// Test that the filtering logic follows the defined ruleset in network.h.
654TEST_F(NetworkTest, TestIPv6Selection) {
655  InterfaceAddress ip;
656  std::string ipstr;
657
658  ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3";
659  ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
660
661  // Create a network with this prefix.
662  Network ipv6_network(
663      "test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64), 64);
664
665  // When there is no address added, it should return an unspecified
666  // address.
667  EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
668  EXPECT_TRUE(IPIsUnspec(ipv6_network.GetBestIP()));
669
670  // Deprecated one should not be returned.
671  ipv6_network.AddIP(ip);
672  EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
673
674  // Add ULA one. ULA is unique local address which is starting either
675  // with 0xfc or 0xfd.
676  ipstr = "fd00:fa00:4:1000:be30:5bff:fee5:c4";
677  ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
678  ipv6_network.AddIP(ip);
679  EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
680
681  // Add global one.
682  ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c5";
683  ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
684  ipv6_network.AddIP(ip);
685  EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
686
687  // Add global dynamic temporary one.
688  ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6";
689  ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
690  ipv6_network.AddIP(ip);
691  EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
692}
693
694}  // namespace rtc
695