/* * Copyright 2004 The WebRTC Project Authors. All rights reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "webrtc/base/network.h" #if defined(WEBRTC_POSIX) // linux/if.h can't be included at the same time as the posix sys/if.h, and // it's transitively required by linux/route.h, so include that version on // linux instead of the standard posix one. #if defined(WEBRTC_LINUX) #include #include #elif !defined(__native_client__) #include #endif #endif // WEBRTC_POSIX #if defined(WEBRTC_WIN) #include "webrtc/base/win32.h" #include #elif !defined(__native_client__) #include "webrtc/base/ifaddrs_converter.h" #endif #include #include #include #include "webrtc/base/logging.h" #include "webrtc/base/networkmonitor.h" #include "webrtc/base/socket.h" // includes something that makes windows happy #include "webrtc/base/stream.h" #include "webrtc/base/stringencode.h" #include "webrtc/base/thread.h" namespace rtc { namespace { // Turning on IPv6 could make many IPv6 interfaces available for connectivity // check and delay the call setup time. kMaxIPv6Networks is the default upper // limit of IPv6 networks but could be changed by set_max_ipv6_networks(). const int kMaxIPv6Networks = 5; const uint32_t kUpdateNetworksMessage = 1; const uint32_t kSignalNetworksMessage = 2; // Fetch list of networks every two seconds. const int kNetworksUpdateIntervalMs = 2000; const int kHighestNetworkPreference = 127; typedef struct { Network* net; std::vector ips; } AddressList; bool CompareNetworks(const Network* a, const Network* b) { if (a->prefix_length() == b->prefix_length()) { if (a->name() == b->name()) { return a->prefix() < b->prefix(); } } return a->name() < b->name(); } bool SortNetworks(const Network* a, const Network* b) { // Network types will be preferred above everything else while sorting // Networks. // Networks are sorted first by type. if (a->type() != b->type()) { return a->type() < b->type(); } IPAddress ip_a = a->GetBestIP(); IPAddress ip_b = b->GetBestIP(); // After type, networks are sorted by IP address precedence values // from RFC 3484-bis if (IPAddressPrecedence(ip_a) != IPAddressPrecedence(ip_b)) { return IPAddressPrecedence(ip_a) > IPAddressPrecedence(ip_b); } // TODO(mallinath) - Add VPN and Link speed conditions while sorting. // Networks are sorted last by key. return a->key() > b->key(); } std::string AdapterTypeToString(AdapterType type) { switch (type) { case ADAPTER_TYPE_UNKNOWN: return "Unknown"; case ADAPTER_TYPE_ETHERNET: return "Ethernet"; case ADAPTER_TYPE_WIFI: return "Wifi"; case ADAPTER_TYPE_CELLULAR: return "Cellular"; case ADAPTER_TYPE_VPN: return "VPN"; case ADAPTER_TYPE_LOOPBACK: return "Loopback"; default: RTC_DCHECK(false) << "Invalid type " << type; return std::string(); } } #if !defined(__native_client__) bool IsIgnoredIPv6(const InterfaceAddress& ip) { if (ip.family() != AF_INET6) { return false; } // Link-local addresses require scope id to be bound successfully. // However, our IPAddress structure doesn't carry that so the // information is lost and causes binding failure. if (IPIsLinkLocal(ip)) { return true; } // Any MAC based IPv6 should be avoided to prevent the MAC tracking. if (IPIsMacBased(ip)) { return true; } // Ignore deprecated IPv6. if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED) { return true; } return false; } #endif // !defined(__native_client__) } // namespace // These addresses are used as the targets to find out the default local address // on a multi-homed endpoint. They are actually DNS servers. const char kPublicIPv4Host[] = "8.8.8.8"; const char kPublicIPv6Host[] = "2001:4860:4860::8888"; const int kPublicPort = 53; // DNS port. std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix, int prefix_length) { std::ostringstream ost; ost << name << "%" << prefix.ToString() << "/" << prefix_length; return ost.str(); } NetworkManager::NetworkManager() { } NetworkManager::~NetworkManager() { } NetworkManager::EnumerationPermission NetworkManager::enumeration_permission() const { return ENUMERATION_ALLOWED; } bool NetworkManager::GetDefaultLocalAddress(int family, IPAddress* addr) const { return false; } NetworkManagerBase::NetworkManagerBase() : enumeration_permission_(NetworkManager::ENUMERATION_ALLOWED), max_ipv6_networks_(kMaxIPv6Networks), ipv6_enabled_(true) { } NetworkManagerBase::~NetworkManagerBase() { for (const auto& kv : networks_map_) { delete kv.second; } } NetworkManager::EnumerationPermission NetworkManagerBase::enumeration_permission() const { return enumeration_permission_; } void NetworkManagerBase::GetAnyAddressNetworks(NetworkList* networks) { if (!ipv4_any_address_network_) { const rtc::IPAddress ipv4_any_address(INADDR_ANY); ipv4_any_address_network_.reset( new rtc::Network("any", "any", ipv4_any_address, 0)); ipv4_any_address_network_->set_default_local_address_provider(this); ipv4_any_address_network_->AddIP(ipv4_any_address); } networks->push_back(ipv4_any_address_network_.get()); if (ipv6_enabled()) { if (!ipv6_any_address_network_) { const rtc::IPAddress ipv6_any_address(in6addr_any); ipv6_any_address_network_.reset( new rtc::Network("any", "any", ipv6_any_address, 0)); ipv6_any_address_network_->set_default_local_address_provider(this); ipv6_any_address_network_->AddIP(ipv6_any_address); } networks->push_back(ipv6_any_address_network_.get()); } } void NetworkManagerBase::GetNetworks(NetworkList* result) const { int ipv6_networks = 0; result->clear(); for (Network* network : networks_) { // Keep the number of IPv6 networks under |max_ipv6_networks_|. if (network->prefix().family() == AF_INET6) { if (ipv6_networks >= max_ipv6_networks_) { continue; } ++ipv6_networks; } result->push_back(network); } } void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks, bool* changed) { NetworkManager::Stats stats; MergeNetworkList(new_networks, changed, &stats); } void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks, bool* changed, NetworkManager::Stats* stats) { *changed = false; // AddressList in this map will track IP addresses for all Networks // with the same key. std::map consolidated_address_list; NetworkList list(new_networks); std::sort(list.begin(), list.end(), CompareNetworks); // First, build a set of network-keys to the ipaddresses. for (Network* network : list) { bool might_add_to_merged_list = false; std::string key = MakeNetworkKey(network->name(), network->prefix(), network->prefix_length()); if (consolidated_address_list.find(key) == consolidated_address_list.end()) { AddressList addrlist; addrlist.net = network; consolidated_address_list[key] = addrlist; might_add_to_merged_list = true; } const std::vector& addresses = network->GetIPs(); AddressList& current_list = consolidated_address_list[key]; for (const InterfaceAddress& address : addresses) { current_list.ips.push_back(address); } if (!might_add_to_merged_list) { delete network; } else { if (current_list.ips[0].family() == AF_INET) { stats->ipv4_network_count++; } else { ASSERT(current_list.ips[0].family() == AF_INET6); stats->ipv6_network_count++; } } } // Next, look for existing network objects to re-use. // Result of Network merge. Element in this list should have unique key. NetworkList merged_list; for (const auto& kv : consolidated_address_list) { const std::string& key = kv.first; Network* net = kv.second.net; auto existing = networks_map_.find(key); if (existing == networks_map_.end()) { // This network is new. Place it in the network map. merged_list.push_back(net); networks_map_[key] = net; net->set_id(next_available_network_id_++); // Also, we might have accumulated IPAddresses from the first // step, set it here. net->SetIPs(kv.second.ips, true); *changed = true; } else { // This network exists in the map already. Reset its IP addresses. Network* existing_net = existing->second; *changed = existing_net->SetIPs(kv.second.ips, *changed); merged_list.push_back(existing_net); if (net->type() != ADAPTER_TYPE_UNKNOWN && net->type() != existing_net->type()) { existing_net->set_type(net->type()); *changed = true; } // If the existing network was not active, networks have changed. if (!existing_net->active()) { *changed = true; } ASSERT(net->active()); if (existing_net != net) { delete net; } } } // It may still happen that the merged list is a subset of |networks_|. // To detect this change, we compare their sizes. if (merged_list.size() != networks_.size()) { *changed = true; } // If the network list changes, we re-assign |networks_| to the merged list // and re-sort it. if (*changed) { networks_ = merged_list; // Reset the active states of all networks. for (const auto& kv : networks_map_) { Network* network = kv.second; // If |network| is in the newly generated |networks_|, it is active. bool found = std::find(networks_.begin(), networks_.end(), network) != networks_.end(); network->set_active(found); } std::sort(networks_.begin(), networks_.end(), SortNetworks); // Now network interfaces are sorted, we should set the preference value // for each of the interfaces we are planning to use. // Preference order of network interfaces might have changed from previous // sorting due to addition of higher preference network interface. // Since we have already sorted the network interfaces based on our // requirements, we will just assign a preference value starting with 127, // in decreasing order. int pref = kHighestNetworkPreference; for (Network* network : networks_) { network->set_preference(pref); if (pref > 0) { --pref; } else { LOG(LS_ERROR) << "Too many network interfaces to handle!"; break; } } } } void NetworkManagerBase::set_default_local_addresses(const IPAddress& ipv4, const IPAddress& ipv6) { if (ipv4.family() == AF_INET) { default_local_ipv4_address_ = ipv4; } if (ipv6.family() == AF_INET6) { default_local_ipv6_address_ = ipv6; } } bool NetworkManagerBase::GetDefaultLocalAddress(int family, IPAddress* ipaddr) const { if (family == AF_INET && !default_local_ipv4_address_.IsNil()) { *ipaddr = default_local_ipv4_address_; return true; } else if (family == AF_INET6 && !default_local_ipv6_address_.IsNil()) { Network* ipv6_network = GetNetworkFromAddress(default_local_ipv6_address_); if (ipv6_network) { // If the default ipv6 network's BestIP is different than // default_local_ipv6_address_, use it instead. // This is to prevent potential IP address leakage. See WebRTC bug 5376. *ipaddr = ipv6_network->GetBestIP(); } else { *ipaddr = default_local_ipv6_address_; } return true; } return false; } Network* NetworkManagerBase::GetNetworkFromAddress( const rtc::IPAddress& ip) const { for (Network* network : networks_) { const auto& ips = network->GetIPs(); if (std::find_if(ips.begin(), ips.end(), [ip](const InterfaceAddress& existing_ip) { return ip == static_cast(existing_ip); }) != ips.end()) { return network; } } return nullptr; } BasicNetworkManager::BasicNetworkManager() : thread_(NULL), sent_first_update_(false), start_count_(0), ignore_non_default_routes_(false) { } BasicNetworkManager::~BasicNetworkManager() { } void BasicNetworkManager::OnNetworksChanged() { LOG(LS_INFO) << "Network change was observed"; UpdateNetworksOnce(); } #if defined(__native_client__) bool BasicNetworkManager::CreateNetworks(bool include_ignored, NetworkList* networks) const { ASSERT(false); LOG(LS_WARNING) << "BasicNetworkManager doesn't work on NaCl yet"; return false; } #elif defined(WEBRTC_POSIX) void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces, IfAddrsConverter* ifaddrs_converter, bool include_ignored, NetworkList* networks) const { NetworkMap current_networks; for (struct ifaddrs* cursor = interfaces; cursor != NULL; cursor = cursor->ifa_next) { IPAddress prefix; IPAddress mask; InterfaceAddress ip; int scope_id = 0; // Some interfaces may not have address assigned. if (!cursor->ifa_addr || !cursor->ifa_netmask) { continue; } // Skip ones which are down. if (!(cursor->ifa_flags & IFF_RUNNING)) { continue; } // Skip unknown family. if (cursor->ifa_addr->sa_family != AF_INET && cursor->ifa_addr->sa_family != AF_INET6) { continue; } // Skip IPv6 if not enabled. if (cursor->ifa_addr->sa_family == AF_INET6 && !ipv6_enabled()) { continue; } // Convert to InterfaceAddress. if (!ifaddrs_converter->ConvertIfAddrsToIPAddress(cursor, &ip, &mask)) { continue; } // Special case for IPv6 address. if (cursor->ifa_addr->sa_family == AF_INET6) { if (IsIgnoredIPv6(ip)) { continue; } scope_id = reinterpret_cast(cursor->ifa_addr)->sin6_scope_id; } AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN; if (cursor->ifa_flags & IFF_LOOPBACK) { adapter_type = ADAPTER_TYPE_LOOPBACK; } else { adapter_type = GetAdapterTypeFromName(cursor->ifa_name); } int prefix_length = CountIPMaskBits(mask); prefix = TruncateIP(ip, prefix_length); std::string key = MakeNetworkKey(std::string(cursor->ifa_name), prefix, prefix_length); auto iter = current_networks.find(key); if (iter == current_networks.end()) { // TODO(phoglund): Need to recognize other types as well. std::unique_ptr network( new Network(cursor->ifa_name, cursor->ifa_name, prefix, prefix_length, adapter_type)); network->set_default_local_address_provider(this); network->set_scope_id(scope_id); network->AddIP(ip); network->set_ignored(IsIgnoredNetwork(*network)); if (include_ignored || !network->ignored()) { current_networks[key] = network.get(); networks->push_back(network.release()); } } else { Network* existing_network = iter->second; existing_network->AddIP(ip); if (adapter_type != ADAPTER_TYPE_UNKNOWN) { existing_network->set_type(adapter_type); } } } } bool BasicNetworkManager::CreateNetworks(bool include_ignored, NetworkList* networks) const { struct ifaddrs* interfaces; int error = getifaddrs(&interfaces); if (error != 0) { LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: " << error; return false; } std::unique_ptr ifaddrs_converter(CreateIfAddrsConverter()); ConvertIfAddrs(interfaces, ifaddrs_converter.get(), include_ignored, networks); freeifaddrs(interfaces); return true; } #elif defined(WEBRTC_WIN) unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist, const IPAddress& ip, IPAddress* prefix) { IPAddress current_prefix; IPAddress best_prefix; unsigned int best_length = 0; while (prefixlist) { // Look for the longest matching prefix in the prefixlist. if (prefixlist->Address.lpSockaddr == NULL || prefixlist->Address.lpSockaddr->sa_family != ip.family()) { prefixlist = prefixlist->Next; continue; } switch (prefixlist->Address.lpSockaddr->sa_family) { case AF_INET: { sockaddr_in* v4_addr = reinterpret_cast(prefixlist->Address.lpSockaddr); current_prefix = IPAddress(v4_addr->sin_addr); break; } case AF_INET6: { sockaddr_in6* v6_addr = reinterpret_cast(prefixlist->Address.lpSockaddr); current_prefix = IPAddress(v6_addr->sin6_addr); break; } default: { prefixlist = prefixlist->Next; continue; } } if (TruncateIP(ip, prefixlist->PrefixLength) == current_prefix && prefixlist->PrefixLength > best_length) { best_prefix = current_prefix; best_length = prefixlist->PrefixLength; } prefixlist = prefixlist->Next; } *prefix = best_prefix; return best_length; } bool BasicNetworkManager::CreateNetworks(bool include_ignored, NetworkList* networks) const { NetworkMap current_networks; // MSDN recommends a 15KB buffer for the first try at GetAdaptersAddresses. size_t buffer_size = 16384; std::unique_ptr adapter_info(new char[buffer_size]); PIP_ADAPTER_ADDRESSES adapter_addrs = reinterpret_cast(adapter_info.get()); int adapter_flags = (GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_INCLUDE_PREFIX); int ret = 0; do { adapter_info.reset(new char[buffer_size]); adapter_addrs = reinterpret_cast(adapter_info.get()); ret = GetAdaptersAddresses(AF_UNSPEC, adapter_flags, 0, adapter_addrs, reinterpret_cast(&buffer_size)); } while (ret == ERROR_BUFFER_OVERFLOW); if (ret != ERROR_SUCCESS) { return false; } int count = 0; while (adapter_addrs) { if (adapter_addrs->OperStatus == IfOperStatusUp) { PIP_ADAPTER_UNICAST_ADDRESS address = adapter_addrs->FirstUnicastAddress; PIP_ADAPTER_PREFIX prefixlist = adapter_addrs->FirstPrefix; std::string name; std::string description; #if !defined(NDEBUG) name = ToUtf8(adapter_addrs->FriendlyName, wcslen(adapter_addrs->FriendlyName)); #endif description = ToUtf8(adapter_addrs->Description, wcslen(adapter_addrs->Description)); for (; address; address = address->Next) { #if defined(NDEBUG) name = rtc::ToString(count); #endif IPAddress ip; int scope_id = 0; std::unique_ptr network; switch (address->Address.lpSockaddr->sa_family) { case AF_INET: { sockaddr_in* v4_addr = reinterpret_cast(address->Address.lpSockaddr); ip = IPAddress(v4_addr->sin_addr); break; } case AF_INET6: { if (ipv6_enabled()) { sockaddr_in6* v6_addr = reinterpret_cast(address->Address.lpSockaddr); scope_id = v6_addr->sin6_scope_id; ip = IPAddress(v6_addr->sin6_addr); if (IsIgnoredIPv6(ip)) { continue; } break; } else { continue; } } default: { continue; } } IPAddress prefix; int prefix_length = GetPrefix(prefixlist, ip, &prefix); std::string key = MakeNetworkKey(name, prefix, prefix_length); auto existing_network = current_networks.find(key); if (existing_network == current_networks.end()) { AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN; if (adapter_addrs->IfType == IF_TYPE_SOFTWARE_LOOPBACK) { // TODO(phoglund): Need to recognize other types as well. adapter_type = ADAPTER_TYPE_LOOPBACK; } std::unique_ptr network(new Network( name, description, prefix, prefix_length, adapter_type)); network->set_default_local_address_provider(this); network->set_scope_id(scope_id); network->AddIP(ip); bool ignored = IsIgnoredNetwork(*network); network->set_ignored(ignored); if (include_ignored || !network->ignored()) { current_networks[key] = network.get(); networks->push_back(network.release()); } } else { (*existing_network).second->AddIP(ip); } } // Count is per-adapter - all 'Networks' created from the same // adapter need to have the same name. ++count; } adapter_addrs = adapter_addrs->Next; } return true; } #endif // WEBRTC_WIN #if defined(WEBRTC_LINUX) bool IsDefaultRoute(const std::string& network_name) { FileStream fs; if (!fs.Open("/proc/net/route", "r", NULL)) { LOG(LS_WARNING) << "Couldn't read /proc/net/route, skipping default " << "route check (assuming everything is a default route)."; return true; } else { std::string line; while (fs.ReadLine(&line) == SR_SUCCESS) { char iface_name[256]; unsigned int iface_ip, iface_gw, iface_mask, iface_flags; if (sscanf(line.c_str(), "%255s %8X %8X %4X %*d %*u %*d %8X", iface_name, &iface_ip, &iface_gw, &iface_flags, &iface_mask) == 5 && network_name == iface_name && iface_mask == 0 && (iface_flags & (RTF_UP | RTF_HOST)) == RTF_UP) { return true; } } } return false; } #endif bool BasicNetworkManager::IsIgnoredNetwork(const Network& network) const { // Ignore networks on the explicit ignore list. for (const std::string& ignored_name : network_ignore_list_) { if (network.name() == ignored_name) { return true; } } #if defined(WEBRTC_POSIX) // Filter out VMware/VirtualBox interfaces, typically named vmnet1, // vmnet8, or vboxnet0. if (strncmp(network.name().c_str(), "vmnet", 5) == 0 || strncmp(network.name().c_str(), "vnic", 4) == 0 || strncmp(network.name().c_str(), "vboxnet", 7) == 0) { return true; } #if defined(WEBRTC_LINUX) // Make sure this is a default route, if we're ignoring non-defaults. if (ignore_non_default_routes_ && !IsDefaultRoute(network.name())) { return true; } #endif #elif defined(WEBRTC_WIN) // Ignore any HOST side vmware adapters with a description like: // VMware Virtual Ethernet Adapter for VMnet1 // but don't ignore any GUEST side adapters with a description like: // VMware Accelerated AMD PCNet Adapter #2 if (strstr(network.description().c_str(), "VMnet") != NULL) { return true; } #endif // Ignore any networks with a 0.x.y.z IP if (network.prefix().family() == AF_INET) { return (network.prefix().v4AddressAsHostOrderInteger() < 0x01000000); } return false; } void BasicNetworkManager::StartUpdating() { thread_ = Thread::Current(); if (start_count_) { // If network interfaces are already discovered and signal is sent, // we should trigger network signal immediately for the new clients // to start allocating ports. if (sent_first_update_) thread_->Post(RTC_FROM_HERE, this, kSignalNetworksMessage); } else { thread_->Post(RTC_FROM_HERE, this, kUpdateNetworksMessage); StartNetworkMonitor(); } ++start_count_; } void BasicNetworkManager::StopUpdating() { ASSERT(Thread::Current() == thread_); if (!start_count_) return; --start_count_; if (!start_count_) { thread_->Clear(this); sent_first_update_ = false; StopNetworkMonitor(); } } void BasicNetworkManager::StartNetworkMonitor() { NetworkMonitorFactory* factory = NetworkMonitorFactory::GetFactory(); if (factory == nullptr) { return; } if (!network_monitor_) { network_monitor_.reset(factory->CreateNetworkMonitor()); if (!network_monitor_) { return; } network_monitor_->SignalNetworksChanged.connect( this, &BasicNetworkManager::OnNetworksChanged); } network_monitor_->Start(); } void BasicNetworkManager::StopNetworkMonitor() { if (!network_monitor_) { return; } network_monitor_->Stop(); } void BasicNetworkManager::OnMessage(Message* msg) { switch (msg->message_id) { case kUpdateNetworksMessage: { UpdateNetworksContinually(); break; } case kSignalNetworksMessage: { SignalNetworksChanged(); break; } default: ASSERT(false); } } AdapterType BasicNetworkManager::GetAdapterTypeFromName( const char* network_name) const { // If there is a network_monitor, use it to get the adapter type. // Otherwise, get the adapter type based on a few name matching rules. if (network_monitor_) { AdapterType type = network_monitor_->GetAdapterType(network_name); if (type != ADAPTER_TYPE_UNKNOWN) { return type; } } #if defined(WEBRTC_IOS) // Cell networks are pdp_ipN on iOS. if (strncmp(network_name, "pdp_ip", 6) == 0) { return ADAPTER_TYPE_CELLULAR; } if (strncmp(network_name, "en", 2) == 0) { // This may not be most accurate because sometimes Ethernet interface // name also starts with "en" but it is better than showing it as // "unknown" type. // TODO(honghaiz): Write a proper IOS network manager. return ADAPTER_TYPE_WIFI; } #elif defined(WEBRTC_ANDROID) if (strncmp(network_name, "rmnet", 5) == 0 || strncmp(network_name, "v4-rmnet", 8) == 0) { return ADAPTER_TYPE_CELLULAR; } if (strncmp(network_name, "wlan", 4) == 0) { return ADAPTER_TYPE_WIFI; } #endif return ADAPTER_TYPE_UNKNOWN; } IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const { ASSERT(thread_ == Thread::Current()); ASSERT(thread_->socketserver() != nullptr); ASSERT(family == AF_INET || family == AF_INET6); std::unique_ptr socket( thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM)); if (!socket) { LOG_ERR(LERROR) << "Socket creation failed"; return IPAddress(); } if (socket->Connect(SocketAddress( family == AF_INET ? kPublicIPv4Host : kPublicIPv6Host, kPublicPort)) < 0) { LOG(LS_INFO) << "Connect failed with " << socket->GetError(); return IPAddress(); } return socket->GetLocalAddress().ipaddr(); } void BasicNetworkManager::UpdateNetworksOnce() { if (!start_count_) return; ASSERT(Thread::Current() == thread_); NetworkList list; if (!CreateNetworks(false, &list)) { SignalError(); } else { bool changed; NetworkManager::Stats stats; MergeNetworkList(list, &changed, &stats); set_default_local_addresses(QueryDefaultLocalAddress(AF_INET), QueryDefaultLocalAddress(AF_INET6)); if (changed || !sent_first_update_) { SignalNetworksChanged(); sent_first_update_ = true; } } } void BasicNetworkManager::UpdateNetworksContinually() { UpdateNetworksOnce(); thread_->PostDelayed(RTC_FROM_HERE, kNetworksUpdateIntervalMs, this, kUpdateNetworksMessage); } void BasicNetworkManager::DumpNetworks() { NetworkList list; GetNetworks(&list); LOG(LS_INFO) << "NetworkManager detected " << list.size() << " networks:"; for (const Network* network : list) { LOG(LS_INFO) << network->ToString() << ": " << network->description() << ", active ? " << network->active() << ((network->ignored()) ? ", Ignored" : ""); } } Network::Network(const std::string& name, const std::string& desc, const IPAddress& prefix, int prefix_length) : name_(name), description_(desc), prefix_(prefix), prefix_length_(prefix_length), key_(MakeNetworkKey(name, prefix, prefix_length)), scope_id_(0), ignored_(false), type_(ADAPTER_TYPE_UNKNOWN), preference_(0) {} Network::Network(const std::string& name, const std::string& desc, const IPAddress& prefix, int prefix_length, AdapterType type) : name_(name), description_(desc), prefix_(prefix), prefix_length_(prefix_length), key_(MakeNetworkKey(name, prefix, prefix_length)), scope_id_(0), ignored_(false), type_(type), preference_(0) {} Network::~Network() = default; // Sets the addresses of this network. Returns true if the address set changed. // Change detection is short circuited if the changed argument is true. bool Network::SetIPs(const std::vector& ips, bool changed) { // Detect changes with a nested loop; n-squared but we expect on the order // of 2-3 addresses per network. changed = changed || ips.size() != ips_.size(); if (!changed) { for (const InterfaceAddress& ip : ips) { if (std::find(ips_.begin(), ips_.end(), ip) == ips_.end()) { changed = true; break; } } } ips_ = ips; return changed; } // Select the best IP address to use from this Network. IPAddress Network::GetBestIP() const { if (ips_.size() == 0) { return IPAddress(); } if (prefix_.family() == AF_INET) { return static_cast(ips_.at(0)); } InterfaceAddress selected_ip, ula_ip; for (const InterfaceAddress& ip : ips_) { // Ignore any address which has been deprecated already. if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED) continue; // ULA address should only be returned when we have no other // global IP. if (IPIsULA(static_cast(ip))) { ula_ip = ip; continue; } selected_ip = ip; // Search could stop once a temporary non-deprecated one is found. if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_TEMPORARY) break; } // No proper global IPv6 address found, use ULA instead. if (IPIsUnspec(selected_ip) && !IPIsUnspec(ula_ip)) { selected_ip = ula_ip; } return static_cast(selected_ip); } std::string Network::ToString() const { std::stringstream ss; // Print out the first space-terminated token of the network desc, plus // the IP address. ss << "Net[" << description_.substr(0, description_.find(' ')) << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_ << ":" << AdapterTypeToString(type_) << "]"; return ss.str(); } } // namespace rtc