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 "rtc_base/network.h"
12
13 #if defined(WEBRTC_POSIX)
14 // linux/if.h can't be included at the same time as the posix sys/if.h, and
15 // it's transitively required by linux/route.h, so include that version on
16 // linux instead of the standard posix one.
17 #if defined(WEBRTC_LINUX)
18 #include <linux/if.h>
19 #include <linux/route.h>
20 #elif !defined(__native_client__)
21 #include <net/if.h>
22 #endif
23 #endif // WEBRTC_POSIX
24
25 #if defined(WEBRTC_WIN)
26 #include "rtc_base/win32.h"
27 #include <Iphlpapi.h>
28 #elif !defined(__native_client__)
29 #include "rtc_base/ifaddrs_converter.h"
30 #endif
31
32 #include <stdio.h>
33
34 #include <algorithm>
35 #include <memory>
36
37 #include "rtc_base/checks.h"
38 #include "rtc_base/logging.h"
39 #include "rtc_base/networkmonitor.h"
40 #include "rtc_base/socket.h" // includes something that makes windows happy
41 #include "rtc_base/stream.h"
42 #include "rtc_base/stringencode.h"
43 #include "rtc_base/thread.h"
44
45 namespace rtc {
46 namespace {
47
48 const uint32_t kUpdateNetworksMessage = 1;
49 const uint32_t kSignalNetworksMessage = 2;
50
51 // Fetch list of networks every two seconds.
52 const int kNetworksUpdateIntervalMs = 2000;
53
54 const int kHighestNetworkPreference = 127;
55
56 typedef struct {
57 Network* net;
58 std::vector<InterfaceAddress> ips;
59 } AddressList;
60
CompareNetworks(const Network * a,const Network * b)61 bool CompareNetworks(const Network* a, const Network* b) {
62 if (a->prefix_length() == b->prefix_length()) {
63 if (a->name() == b->name()) {
64 return a->prefix() < b->prefix();
65 }
66 }
67 return a->name() < b->name();
68 }
69
SortNetworks(const Network * a,const Network * b)70 bool SortNetworks(const Network* a, const Network* b) {
71 // Network types will be preferred above everything else while sorting
72 // Networks.
73
74 // Networks are sorted first by type.
75 if (a->type() != b->type()) {
76 return a->type() < b->type();
77 }
78
79 IPAddress ip_a = a->GetBestIP();
80 IPAddress ip_b = b->GetBestIP();
81
82 // After type, networks are sorted by IP address precedence values
83 // from RFC 3484-bis
84 if (IPAddressPrecedence(ip_a) != IPAddressPrecedence(ip_b)) {
85 return IPAddressPrecedence(ip_a) > IPAddressPrecedence(ip_b);
86 }
87
88 // TODO(mallinath) - Add VPN and Link speed conditions while sorting.
89
90 // Networks are sorted last by key.
91 return a->key() < b->key();
92 }
93
AdapterTypeToString(AdapterType type)94 std::string AdapterTypeToString(AdapterType type) {
95 switch (type) {
96 case ADAPTER_TYPE_UNKNOWN:
97 return "Unknown";
98 case ADAPTER_TYPE_ETHERNET:
99 return "Ethernet";
100 case ADAPTER_TYPE_WIFI:
101 return "Wifi";
102 case ADAPTER_TYPE_CELLULAR:
103 return "Cellular";
104 case ADAPTER_TYPE_VPN:
105 return "VPN";
106 case ADAPTER_TYPE_LOOPBACK:
107 return "Loopback";
108 default:
109 RTC_NOTREACHED() << "Invalid type " << type;
110 return std::string();
111 }
112 }
113
114 #if !defined(__native_client__)
IsIgnoredIPv6(const InterfaceAddress & ip)115 bool IsIgnoredIPv6(const InterfaceAddress& ip) {
116 if (ip.family() != AF_INET6) {
117 return false;
118 }
119
120 // Link-local addresses require scope id to be bound successfully.
121 // However, our IPAddress structure doesn't carry that so the
122 // information is lost and causes binding failure.
123 if (IPIsLinkLocal(ip)) {
124 return true;
125 }
126
127 // Any MAC based IPv6 should be avoided to prevent the MAC tracking.
128 if (IPIsMacBased(ip)) {
129 return true;
130 }
131
132 // Ignore deprecated IPv6.
133 if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED) {
134 return true;
135 }
136
137 return false;
138 }
139 #endif // !defined(__native_client__)
140
141 } // namespace
142
143 // These addresses are used as the targets to find out the default local address
144 // on a multi-homed endpoint. They are actually DNS servers.
145 const char kPublicIPv4Host[] = "8.8.8.8";
146 const char kPublicIPv6Host[] = "2001:4860:4860::8888";
147 const int kPublicPort = 53; // DNS port.
148
MakeNetworkKey(const std::string & name,const IPAddress & prefix,int prefix_length)149 std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
150 int prefix_length) {
151 std::ostringstream ost;
152 ost << name << "%" << prefix.ToString() << "/" << prefix_length;
153 return ost.str();
154 }
155
NetworkManager()156 NetworkManager::NetworkManager() {
157 }
158
~NetworkManager()159 NetworkManager::~NetworkManager() {
160 }
161
enumeration_permission() const162 NetworkManager::EnumerationPermission NetworkManager::enumeration_permission()
163 const {
164 return ENUMERATION_ALLOWED;
165 }
166
GetDefaultLocalAddress(int family,IPAddress * addr) const167 bool NetworkManager::GetDefaultLocalAddress(int family, IPAddress* addr) const {
168 return false;
169 }
170
NetworkManagerBase()171 NetworkManagerBase::NetworkManagerBase()
172 : enumeration_permission_(NetworkManager::ENUMERATION_ALLOWED),
173 ipv6_enabled_(true) {
174 }
175
~NetworkManagerBase()176 NetworkManagerBase::~NetworkManagerBase() {
177 for (const auto& kv : networks_map_) {
178 delete kv.second;
179 }
180 }
181
182 NetworkManager::EnumerationPermission
enumeration_permission() const183 NetworkManagerBase::enumeration_permission() const {
184 return enumeration_permission_;
185 }
186
GetAnyAddressNetworks(NetworkList * networks)187 void NetworkManagerBase::GetAnyAddressNetworks(NetworkList* networks) {
188 if (!ipv4_any_address_network_) {
189 const rtc::IPAddress ipv4_any_address(INADDR_ANY);
190 ipv4_any_address_network_.reset(
191 new rtc::Network("any", "any", ipv4_any_address, 0));
192 ipv4_any_address_network_->set_default_local_address_provider(this);
193 ipv4_any_address_network_->AddIP(ipv4_any_address);
194 }
195 networks->push_back(ipv4_any_address_network_.get());
196
197 if (ipv6_enabled()) {
198 if (!ipv6_any_address_network_) {
199 const rtc::IPAddress ipv6_any_address(in6addr_any);
200 ipv6_any_address_network_.reset(
201 new rtc::Network("any", "any", ipv6_any_address, 0));
202 ipv6_any_address_network_->set_default_local_address_provider(this);
203 ipv6_any_address_network_->AddIP(ipv6_any_address);
204 }
205 networks->push_back(ipv6_any_address_network_.get());
206 }
207 }
208
GetNetworks(NetworkList * result) const209 void NetworkManagerBase::GetNetworks(NetworkList* result) const {
210 result->clear();
211 result->insert(result->begin(), networks_.begin(), networks_.end());
212 }
213
MergeNetworkList(const NetworkList & new_networks,bool * changed)214 void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks,
215 bool* changed) {
216 NetworkManager::Stats stats;
217 MergeNetworkList(new_networks, changed, &stats);
218 }
219
MergeNetworkList(const NetworkList & new_networks,bool * changed,NetworkManager::Stats * stats)220 void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks,
221 bool* changed,
222 NetworkManager::Stats* stats) {
223 *changed = false;
224 // AddressList in this map will track IP addresses for all Networks
225 // with the same key.
226 std::map<std::string, AddressList> consolidated_address_list;
227 NetworkList list(new_networks);
228 std::sort(list.begin(), list.end(), CompareNetworks);
229 // First, build a set of network-keys to the ipaddresses.
230 for (Network* network : list) {
231 bool might_add_to_merged_list = false;
232 std::string key = MakeNetworkKey(network->name(),
233 network->prefix(),
234 network->prefix_length());
235 if (consolidated_address_list.find(key) ==
236 consolidated_address_list.end()) {
237 AddressList addrlist;
238 addrlist.net = network;
239 consolidated_address_list[key] = addrlist;
240 might_add_to_merged_list = true;
241 }
242 const std::vector<InterfaceAddress>& addresses = network->GetIPs();
243 AddressList& current_list = consolidated_address_list[key];
244 for (const InterfaceAddress& address : addresses) {
245 current_list.ips.push_back(address);
246 }
247 if (!might_add_to_merged_list) {
248 delete network;
249 } else {
250 if (current_list.ips[0].family() == AF_INET) {
251 stats->ipv4_network_count++;
252 } else {
253 RTC_DCHECK(current_list.ips[0].family() == AF_INET6);
254 stats->ipv6_network_count++;
255 }
256 }
257 }
258
259 // Next, look for existing network objects to re-use.
260 // Result of Network merge. Element in this list should have unique key.
261 NetworkList merged_list;
262 for (const auto& kv : consolidated_address_list) {
263 const std::string& key = kv.first;
264 Network* net = kv.second.net;
265 auto existing = networks_map_.find(key);
266 if (existing == networks_map_.end()) {
267 // This network is new. Place it in the network map.
268 merged_list.push_back(net);
269 networks_map_[key] = net;
270 net->set_id(next_available_network_id_++);
271 // Also, we might have accumulated IPAddresses from the first
272 // step, set it here.
273 net->SetIPs(kv.second.ips, true);
274 *changed = true;
275 } else {
276 // This network exists in the map already. Reset its IP addresses.
277 Network* existing_net = existing->second;
278 *changed = existing_net->SetIPs(kv.second.ips, *changed);
279 merged_list.push_back(existing_net);
280 if (net->type() != ADAPTER_TYPE_UNKNOWN &&
281 net->type() != existing_net->type()) {
282 existing_net->set_type(net->type());
283 *changed = true;
284 }
285 // If the existing network was not active, networks have changed.
286 if (!existing_net->active()) {
287 *changed = true;
288 }
289 RTC_DCHECK(net->active());
290 if (existing_net != net) {
291 delete net;
292 }
293 }
294 }
295 // It may still happen that the merged list is a subset of |networks_|.
296 // To detect this change, we compare their sizes.
297 if (merged_list.size() != networks_.size()) {
298 *changed = true;
299 }
300
301 // If the network list changes, we re-assign |networks_| to the merged list
302 // and re-sort it.
303 if (*changed) {
304 networks_ = merged_list;
305 // Reset the active states of all networks.
306 for (const auto& kv : networks_map_) {
307 Network* network = kv.second;
308 // If |network| is in the newly generated |networks_|, it is active.
309 bool found = std::find(networks_.begin(), networks_.end(), network) !=
310 networks_.end();
311 network->set_active(found);
312 }
313 std::sort(networks_.begin(), networks_.end(), SortNetworks);
314 // Now network interfaces are sorted, we should set the preference value
315 // for each of the interfaces we are planning to use.
316 // Preference order of network interfaces might have changed from previous
317 // sorting due to addition of higher preference network interface.
318 // Since we have already sorted the network interfaces based on our
319 // requirements, we will just assign a preference value starting with 127,
320 // in decreasing order.
321 int pref = kHighestNetworkPreference;
322 for (Network* network : networks_) {
323 network->set_preference(pref);
324 if (pref > 0) {
325 --pref;
326 } else {
327 RTC_LOG(LS_ERROR) << "Too many network interfaces to handle!";
328 break;
329 }
330 }
331 }
332 }
333
set_default_local_addresses(const IPAddress & ipv4,const IPAddress & ipv6)334 void NetworkManagerBase::set_default_local_addresses(const IPAddress& ipv4,
335 const IPAddress& ipv6) {
336 if (ipv4.family() == AF_INET) {
337 default_local_ipv4_address_ = ipv4;
338 }
339 if (ipv6.family() == AF_INET6) {
340 default_local_ipv6_address_ = ipv6;
341 }
342 }
343
GetDefaultLocalAddress(int family,IPAddress * ipaddr) const344 bool NetworkManagerBase::GetDefaultLocalAddress(int family,
345 IPAddress* ipaddr) const {
346 if (family == AF_INET && !default_local_ipv4_address_.IsNil()) {
347 *ipaddr = default_local_ipv4_address_;
348 return true;
349 } else if (family == AF_INET6 && !default_local_ipv6_address_.IsNil()) {
350 Network* ipv6_network = GetNetworkFromAddress(default_local_ipv6_address_);
351 if (ipv6_network) {
352 // If the default ipv6 network's BestIP is different than
353 // default_local_ipv6_address_, use it instead.
354 // This is to prevent potential IP address leakage. See WebRTC bug 5376.
355 *ipaddr = ipv6_network->GetBestIP();
356 } else {
357 *ipaddr = default_local_ipv6_address_;
358 }
359 return true;
360 }
361 return false;
362 }
363
GetNetworkFromAddress(const rtc::IPAddress & ip) const364 Network* NetworkManagerBase::GetNetworkFromAddress(
365 const rtc::IPAddress& ip) const {
366 for (Network* network : networks_) {
367 const auto& ips = network->GetIPs();
368 if (std::find_if(ips.begin(), ips.end(),
369 [ip](const InterfaceAddress& existing_ip) {
370 return ip == static_cast<rtc::IPAddress>(existing_ip);
371 }) != ips.end()) {
372 return network;
373 }
374 }
375 return nullptr;
376 }
377
BasicNetworkManager()378 BasicNetworkManager::BasicNetworkManager()
379 : thread_(nullptr),
380 sent_first_update_(false),
381 start_count_(0),
382 ignore_non_default_routes_(false) {}
383
~BasicNetworkManager()384 BasicNetworkManager::~BasicNetworkManager() {
385 }
386
OnNetworksChanged()387 void BasicNetworkManager::OnNetworksChanged() {
388 RTC_LOG(LS_INFO) << "Network change was observed";
389 UpdateNetworksOnce();
390 }
391
392 #if defined(__native_client__)
393
CreateNetworks(bool include_ignored,NetworkList * networks) const394 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
395 NetworkList* networks) const {
396 RTC_NOTREACHED();
397 RTC_LOG(LS_WARNING) << "BasicNetworkManager doesn't work on NaCl yet";
398 return false;
399 }
400
401 #elif defined(WEBRTC_POSIX)
ConvertIfAddrs(struct ifaddrs * interfaces,IfAddrsConverter * ifaddrs_converter,bool include_ignored,NetworkList * networks) const402 void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces,
403 IfAddrsConverter* ifaddrs_converter,
404 bool include_ignored,
405 NetworkList* networks) const {
406 NetworkMap current_networks;
407
408 for (struct ifaddrs* cursor = interfaces; cursor != nullptr;
409 cursor = cursor->ifa_next) {
410 IPAddress prefix;
411 IPAddress mask;
412 InterfaceAddress ip;
413 int scope_id = 0;
414
415 // Some interfaces may not have address assigned.
416 if (!cursor->ifa_addr || !cursor->ifa_netmask) {
417 continue;
418 }
419 // Skip ones which are down.
420 if (!(cursor->ifa_flags & IFF_RUNNING)) {
421 continue;
422 }
423 // Skip unknown family.
424 if (cursor->ifa_addr->sa_family != AF_INET &&
425 cursor->ifa_addr->sa_family != AF_INET6) {
426 continue;
427 }
428 // Skip IPv6 if not enabled.
429 if (cursor->ifa_addr->sa_family == AF_INET6 && !ipv6_enabled()) {
430 continue;
431 }
432 // Convert to InterfaceAddress.
433 if (!ifaddrs_converter->ConvertIfAddrsToIPAddress(cursor, &ip, &mask)) {
434 continue;
435 }
436
437 // Special case for IPv6 address.
438 if (cursor->ifa_addr->sa_family == AF_INET6) {
439 if (IsIgnoredIPv6(ip)) {
440 continue;
441 }
442 scope_id =
443 reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
444 }
445
446 AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN;
447 if (cursor->ifa_flags & IFF_LOOPBACK) {
448 adapter_type = ADAPTER_TYPE_LOOPBACK;
449 } else {
450 adapter_type = GetAdapterTypeFromName(cursor->ifa_name);
451 }
452 int prefix_length = CountIPMaskBits(mask);
453 prefix = TruncateIP(ip, prefix_length);
454 std::string key = MakeNetworkKey(std::string(cursor->ifa_name),
455 prefix, prefix_length);
456 auto iter = current_networks.find(key);
457 if (iter == current_networks.end()) {
458 // TODO(phoglund): Need to recognize other types as well.
459 std::unique_ptr<Network> network(
460 new Network(cursor->ifa_name, cursor->ifa_name, prefix, prefix_length,
461 adapter_type));
462 network->set_default_local_address_provider(this);
463 network->set_scope_id(scope_id);
464 network->AddIP(ip);
465 network->set_ignored(IsIgnoredNetwork(*network));
466 if (include_ignored || !network->ignored()) {
467 current_networks[key] = network.get();
468 networks->push_back(network.release());
469 }
470 } else {
471 Network* existing_network = iter->second;
472 existing_network->AddIP(ip);
473 if (adapter_type != ADAPTER_TYPE_UNKNOWN) {
474 existing_network->set_type(adapter_type);
475 }
476 }
477 }
478 }
479
CreateNetworks(bool include_ignored,NetworkList * networks) const480 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
481 NetworkList* networks) const {
482 struct ifaddrs* interfaces;
483 int error = getifaddrs(&interfaces);
484 if (error != 0) {
485 RTC_LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: "
486 << error;
487 return false;
488 }
489
490 std::unique_ptr<IfAddrsConverter> ifaddrs_converter(CreateIfAddrsConverter());
491 ConvertIfAddrs(interfaces, ifaddrs_converter.get(), include_ignored,
492 networks);
493
494 freeifaddrs(interfaces);
495 return true;
496 }
497
498 #elif defined(WEBRTC_WIN)
499
GetPrefix(PIP_ADAPTER_PREFIX prefixlist,const IPAddress & ip,IPAddress * prefix)500 unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
501 const IPAddress& ip, IPAddress* prefix) {
502 IPAddress current_prefix;
503 IPAddress best_prefix;
504 unsigned int best_length = 0;
505 while (prefixlist) {
506 // Look for the longest matching prefix in the prefixlist.
507 if (prefixlist->Address.lpSockaddr == nullptr ||
508 prefixlist->Address.lpSockaddr->sa_family != ip.family()) {
509 prefixlist = prefixlist->Next;
510 continue;
511 }
512 switch (prefixlist->Address.lpSockaddr->sa_family) {
513 case AF_INET: {
514 sockaddr_in* v4_addr =
515 reinterpret_cast<sockaddr_in*>(prefixlist->Address.lpSockaddr);
516 current_prefix = IPAddress(v4_addr->sin_addr);
517 break;
518 }
519 case AF_INET6: {
520 sockaddr_in6* v6_addr =
521 reinterpret_cast<sockaddr_in6*>(prefixlist->Address.lpSockaddr);
522 current_prefix = IPAddress(v6_addr->sin6_addr);
523 break;
524 }
525 default: {
526 prefixlist = prefixlist->Next;
527 continue;
528 }
529 }
530 if (TruncateIP(ip, prefixlist->PrefixLength) == current_prefix &&
531 prefixlist->PrefixLength > best_length) {
532 best_prefix = current_prefix;
533 best_length = prefixlist->PrefixLength;
534 }
535 prefixlist = prefixlist->Next;
536 }
537 *prefix = best_prefix;
538 return best_length;
539 }
540
CreateNetworks(bool include_ignored,NetworkList * networks) const541 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
542 NetworkList* networks) const {
543 NetworkMap current_networks;
544 // MSDN recommends a 15KB buffer for the first try at GetAdaptersAddresses.
545 size_t buffer_size = 16384;
546 std::unique_ptr<char[]> adapter_info(new char[buffer_size]);
547 PIP_ADAPTER_ADDRESSES adapter_addrs =
548 reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
549 int adapter_flags = (GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_ANYCAST |
550 GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_INCLUDE_PREFIX);
551 int ret = 0;
552 do {
553 adapter_info.reset(new char[buffer_size]);
554 adapter_addrs = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
555 ret = GetAdaptersAddresses(AF_UNSPEC, adapter_flags,
556 0, adapter_addrs,
557 reinterpret_cast<PULONG>(&buffer_size));
558 } while (ret == ERROR_BUFFER_OVERFLOW);
559 if (ret != ERROR_SUCCESS) {
560 return false;
561 }
562 int count = 0;
563 while (adapter_addrs) {
564 if (adapter_addrs->OperStatus == IfOperStatusUp) {
565 PIP_ADAPTER_UNICAST_ADDRESS address = adapter_addrs->FirstUnicastAddress;
566 PIP_ADAPTER_PREFIX prefixlist = adapter_addrs->FirstPrefix;
567 std::string name;
568 std::string description;
569 #if !defined(NDEBUG)
570 name = ToUtf8(adapter_addrs->FriendlyName,
571 wcslen(adapter_addrs->FriendlyName));
572 #endif
573 description = ToUtf8(adapter_addrs->Description,
574 wcslen(adapter_addrs->Description));
575 for (; address; address = address->Next) {
576 #if defined(NDEBUG)
577 name = rtc::ToString(count);
578 #endif
579
580 IPAddress ip;
581 int scope_id = 0;
582 std::unique_ptr<Network> network;
583 switch (address->Address.lpSockaddr->sa_family) {
584 case AF_INET: {
585 sockaddr_in* v4_addr =
586 reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);
587 ip = IPAddress(v4_addr->sin_addr);
588 break;
589 }
590 case AF_INET6: {
591 if (ipv6_enabled()) {
592 sockaddr_in6* v6_addr =
593 reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);
594 scope_id = v6_addr->sin6_scope_id;
595 ip = IPAddress(v6_addr->sin6_addr);
596
597 if (IsIgnoredIPv6(ip)) {
598 continue;
599 }
600
601 break;
602 } else {
603 continue;
604 }
605 }
606 default: {
607 continue;
608 }
609 }
610
611 IPAddress prefix;
612 int prefix_length = GetPrefix(prefixlist, ip, &prefix);
613 std::string key = MakeNetworkKey(name, prefix, prefix_length);
614 auto existing_network = current_networks.find(key);
615 if (existing_network == current_networks.end()) {
616 AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN;
617 if (adapter_addrs->IfType == IF_TYPE_SOFTWARE_LOOPBACK) {
618 // TODO(phoglund): Need to recognize other types as well.
619 adapter_type = ADAPTER_TYPE_LOOPBACK;
620 }
621 std::unique_ptr<Network> network(new Network(
622 name, description, prefix, prefix_length, adapter_type));
623 network->set_default_local_address_provider(this);
624 network->set_scope_id(scope_id);
625 network->AddIP(ip);
626 bool ignored = IsIgnoredNetwork(*network);
627 network->set_ignored(ignored);
628 if (include_ignored || !network->ignored()) {
629 current_networks[key] = network.get();
630 networks->push_back(network.release());
631 }
632 } else {
633 (*existing_network).second->AddIP(ip);
634 }
635 }
636 // Count is per-adapter - all 'Networks' created from the same
637 // adapter need to have the same name.
638 ++count;
639 }
640 adapter_addrs = adapter_addrs->Next;
641 }
642 return true;
643 }
644 #endif // WEBRTC_WIN
645
646 #if defined(WEBRTC_LINUX)
IsDefaultRoute(const std::string & network_name)647 bool IsDefaultRoute(const std::string& network_name) {
648 FileStream fs;
649 if (!fs.Open("/proc/net/route", "r", nullptr)) {
650 RTC_LOG(LS_WARNING)
651 << "Couldn't read /proc/net/route, skipping default "
652 << "route check (assuming everything is a default route).";
653 return true;
654 } else {
655 std::string line;
656 while (fs.ReadLine(&line) == SR_SUCCESS) {
657 char iface_name[256];
658 unsigned int iface_ip, iface_gw, iface_mask, iface_flags;
659 if (sscanf(line.c_str(),
660 "%255s %8X %8X %4X %*d %*u %*d %8X",
661 iface_name, &iface_ip, &iface_gw,
662 &iface_flags, &iface_mask) == 5 &&
663 network_name == iface_name &&
664 iface_mask == 0 &&
665 (iface_flags & (RTF_UP | RTF_HOST)) == RTF_UP) {
666 return true;
667 }
668 }
669 }
670 return false;
671 }
672 #endif
673
IsIgnoredNetwork(const Network & network) const674 bool BasicNetworkManager::IsIgnoredNetwork(const Network& network) const {
675 // Ignore networks on the explicit ignore list.
676 for (const std::string& ignored_name : network_ignore_list_) {
677 if (network.name() == ignored_name) {
678 return true;
679 }
680 }
681
682 #if defined(WEBRTC_POSIX)
683 // Filter out VMware/VirtualBox interfaces, typically named vmnet1,
684 // vmnet8, or vboxnet0.
685 if (strncmp(network.name().c_str(), "vmnet", 5) == 0 ||
686 strncmp(network.name().c_str(), "vnic", 4) == 0 ||
687 strncmp(network.name().c_str(), "vboxnet", 7) == 0) {
688 return true;
689 }
690 #if defined(WEBRTC_LINUX)
691 // Make sure this is a default route, if we're ignoring non-defaults.
692 if (ignore_non_default_routes_ && !IsDefaultRoute(network.name())) {
693 return true;
694 }
695 #endif
696 #elif defined(WEBRTC_WIN)
697 // Ignore any HOST side vmware adapters with a description like:
698 // VMware Virtual Ethernet Adapter for VMnet1
699 // but don't ignore any GUEST side adapters with a description like:
700 // VMware Accelerated AMD PCNet Adapter #2
701 if (strstr(network.description().c_str(), "VMnet") != nullptr) {
702 return true;
703 }
704 #endif
705
706 // Ignore any networks with a 0.x.y.z IP
707 if (network.prefix().family() == AF_INET) {
708 return (network.prefix().v4AddressAsHostOrderInteger() < 0x01000000);
709 }
710
711 return false;
712 }
713
StartUpdating()714 void BasicNetworkManager::StartUpdating() {
715 thread_ = Thread::Current();
716 if (start_count_) {
717 // If network interfaces are already discovered and signal is sent,
718 // we should trigger network signal immediately for the new clients
719 // to start allocating ports.
720 if (sent_first_update_)
721 thread_->Post(RTC_FROM_HERE, this, kSignalNetworksMessage);
722 } else {
723 thread_->Post(RTC_FROM_HERE, this, kUpdateNetworksMessage);
724 StartNetworkMonitor();
725 }
726 ++start_count_;
727 }
728
StopUpdating()729 void BasicNetworkManager::StopUpdating() {
730 RTC_DCHECK(Thread::Current() == thread_);
731 if (!start_count_)
732 return;
733
734 --start_count_;
735 if (!start_count_) {
736 thread_->Clear(this);
737 sent_first_update_ = false;
738 StopNetworkMonitor();
739 }
740 }
741
StartNetworkMonitor()742 void BasicNetworkManager::StartNetworkMonitor() {
743 NetworkMonitorFactory* factory = NetworkMonitorFactory::GetFactory();
744 if (factory == nullptr) {
745 return;
746 }
747 if (!network_monitor_) {
748 network_monitor_.reset(factory->CreateNetworkMonitor());
749 if (!network_monitor_) {
750 return;
751 }
752 network_monitor_->SignalNetworksChanged.connect(
753 this, &BasicNetworkManager::OnNetworksChanged);
754 }
755 network_monitor_->Start();
756 }
757
StopNetworkMonitor()758 void BasicNetworkManager::StopNetworkMonitor() {
759 if (!network_monitor_) {
760 return;
761 }
762 network_monitor_->Stop();
763 }
764
OnMessage(Message * msg)765 void BasicNetworkManager::OnMessage(Message* msg) {
766 switch (msg->message_id) {
767 case kUpdateNetworksMessage: {
768 UpdateNetworksContinually();
769 break;
770 }
771 case kSignalNetworksMessage: {
772 SignalNetworksChanged();
773 break;
774 }
775 default:
776 RTC_NOTREACHED();
777 }
778 }
779
GetAdapterTypeFromName(const char * network_name) const780 AdapterType BasicNetworkManager::GetAdapterTypeFromName(
781 const char* network_name) const {
782 // If there is a network_monitor, use it to get the adapter type.
783 // Otherwise, get the adapter type based on a few name matching rules.
784 if (network_monitor_) {
785 AdapterType type = network_monitor_->GetAdapterType(network_name);
786 if (type != ADAPTER_TYPE_UNKNOWN) {
787 return type;
788 }
789 }
790 if (strncmp(network_name, "ipsec", 5) == 0) {
791 return ADAPTER_TYPE_VPN;
792 }
793 #if defined(WEBRTC_IOS)
794 // Cell networks are pdp_ipN on iOS.
795 if (strncmp(network_name, "pdp_ip", 6) == 0) {
796 return ADAPTER_TYPE_CELLULAR;
797 }
798 if (strncmp(network_name, "en", 2) == 0) {
799 // This may not be most accurate because sometimes Ethernet interface
800 // name also starts with "en" but it is better than showing it as
801 // "unknown" type.
802 // TODO(honghaiz): Write a proper IOS network manager.
803 return ADAPTER_TYPE_WIFI;
804 }
805 #elif defined(WEBRTC_ANDROID)
806 if (strncmp(network_name, "rmnet", 5) == 0 ||
807 strncmp(network_name, "v4-rmnet", 8) == 0) {
808 return ADAPTER_TYPE_CELLULAR;
809 }
810 if (strncmp(network_name, "wlan", 4) == 0) {
811 return ADAPTER_TYPE_WIFI;
812 }
813 #endif
814
815 return ADAPTER_TYPE_UNKNOWN;
816 }
817
QueryDefaultLocalAddress(int family) const818 IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const {
819 RTC_DCHECK(thread_ == Thread::Current());
820 RTC_DCHECK(thread_->socketserver() != nullptr);
821 RTC_DCHECK(family == AF_INET || family == AF_INET6);
822
823 std::unique_ptr<AsyncSocket> socket(
824 thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
825 if (!socket) {
826 RTC_LOG_ERR(LERROR) << "Socket creation failed";
827 return IPAddress();
828 }
829
830 if (socket->Connect(SocketAddress(
831 family == AF_INET ? kPublicIPv4Host : kPublicIPv6Host, kPublicPort)) <
832 0) {
833 if (socket->GetError() != ENETUNREACH
834 && socket->GetError() != EHOSTUNREACH) {
835 // Ignore the expected case of "host/net unreachable" - which happens if
836 // the network is V4- or V6-only.
837 RTC_LOG(LS_INFO) << "Connect failed with " << socket->GetError();
838 }
839 return IPAddress();
840 }
841 return socket->GetLocalAddress().ipaddr();
842 }
843
UpdateNetworksOnce()844 void BasicNetworkManager::UpdateNetworksOnce() {
845 if (!start_count_)
846 return;
847
848 RTC_DCHECK(Thread::Current() == thread_);
849
850 NetworkList list;
851 if (!CreateNetworks(false, &list)) {
852 SignalError();
853 } else {
854 bool changed;
855 NetworkManager::Stats stats;
856 MergeNetworkList(list, &changed, &stats);
857 set_default_local_addresses(QueryDefaultLocalAddress(AF_INET),
858 QueryDefaultLocalAddress(AF_INET6));
859 if (changed || !sent_first_update_) {
860 SignalNetworksChanged();
861 sent_first_update_ = true;
862 }
863 }
864 }
865
UpdateNetworksContinually()866 void BasicNetworkManager::UpdateNetworksContinually() {
867 UpdateNetworksOnce();
868 thread_->PostDelayed(RTC_FROM_HERE, kNetworksUpdateIntervalMs, this,
869 kUpdateNetworksMessage);
870 }
871
DumpNetworks()872 void BasicNetworkManager::DumpNetworks() {
873 NetworkList list;
874 GetNetworks(&list);
875 RTC_LOG(LS_INFO) << "NetworkManager detected " << list.size() << " networks:";
876 for (const Network* network : list) {
877 RTC_LOG(LS_INFO) << network->ToString() << ": " << network->description()
878 << ", active ? " << network->active()
879 << ((network->ignored()) ? ", Ignored" : "");
880 }
881 }
882
Network(const std::string & name,const std::string & desc,const IPAddress & prefix,int prefix_length)883 Network::Network(const std::string& name,
884 const std::string& desc,
885 const IPAddress& prefix,
886 int prefix_length)
887 : name_(name),
888 description_(desc),
889 prefix_(prefix),
890 prefix_length_(prefix_length),
891 key_(MakeNetworkKey(name, prefix, prefix_length)),
892 scope_id_(0),
893 ignored_(false),
894 type_(ADAPTER_TYPE_UNKNOWN),
895 preference_(0) {}
896
Network(const std::string & name,const std::string & desc,const IPAddress & prefix,int prefix_length,AdapterType type)897 Network::Network(const std::string& name,
898 const std::string& desc,
899 const IPAddress& prefix,
900 int prefix_length,
901 AdapterType type)
902 : name_(name),
903 description_(desc),
904 prefix_(prefix),
905 prefix_length_(prefix_length),
906 key_(MakeNetworkKey(name, prefix, prefix_length)),
907 scope_id_(0),
908 ignored_(false),
909 type_(type),
910 preference_(0) {}
911
912 Network::Network(const Network&) = default;
913
914 Network::~Network() = default;
915
916 // Sets the addresses of this network. Returns true if the address set changed.
917 // Change detection is short circuited if the changed argument is true.
SetIPs(const std::vector<InterfaceAddress> & ips,bool changed)918 bool Network::SetIPs(const std::vector<InterfaceAddress>& ips, bool changed) {
919 // Detect changes with a nested loop; n-squared but we expect on the order
920 // of 2-3 addresses per network.
921 changed = changed || ips.size() != ips_.size();
922 if (!changed) {
923 for (const InterfaceAddress& ip : ips) {
924 if (std::find(ips_.begin(), ips_.end(), ip) == ips_.end()) {
925 changed = true;
926 break;
927 }
928 }
929 }
930
931 ips_ = ips;
932 return changed;
933 }
934
935 // Select the best IP address to use from this Network.
GetBestIP() const936 IPAddress Network::GetBestIP() const {
937 if (ips_.size() == 0) {
938 return IPAddress();
939 }
940
941 if (prefix_.family() == AF_INET) {
942 return static_cast<IPAddress>(ips_.at(0));
943 }
944
945 InterfaceAddress selected_ip, ula_ip;
946
947 for (const InterfaceAddress& ip : ips_) {
948 // Ignore any address which has been deprecated already.
949 if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED)
950 continue;
951
952 // ULA address should only be returned when we have no other
953 // global IP.
954 if (IPIsULA(static_cast<const IPAddress&>(ip))) {
955 ula_ip = ip;
956 continue;
957 }
958 selected_ip = ip;
959
960 // Search could stop once a temporary non-deprecated one is found.
961 if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_TEMPORARY)
962 break;
963 }
964
965 // No proper global IPv6 address found, use ULA instead.
966 if (IPIsUnspec(selected_ip) && !IPIsUnspec(ula_ip)) {
967 selected_ip = ula_ip;
968 }
969
970 return static_cast<IPAddress>(selected_ip);
971 }
972
ToString() const973 std::string Network::ToString() const {
974 std::stringstream ss;
975 // Print out the first space-terminated token of the network desc, plus
976 // the IP address.
977 ss << "Net[" << description_.substr(0, description_.find(' '))
978 << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
979 << ":" << AdapterTypeToString(type_) << "]";
980 return ss.str();
981 }
982
983 } // namespace rtc
984