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