diff options
Diffstat (limited to 'third_party/libwebrtc/rtc_base/network.h')
| -rw-r--r-- | third_party/libwebrtc/rtc_base/network.h | 601 |
1 files changed, 601 insertions, 0 deletions
diff --git a/third_party/libwebrtc/rtc_base/network.h b/third_party/libwebrtc/rtc_base/network.h new file mode 100644 index 0000000000..4a97a45d4d --- /dev/null +++ b/third_party/libwebrtc/rtc_base/network.h @@ -0,0 +1,601 @@ +/* + * 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. + */ + +#ifndef RTC_BASE_NETWORK_H_ +#define RTC_BASE_NETWORK_H_ + +#include <stdint.h> + +#include <deque> +#include <map> +#include <memory> +#include <string> +#include <vector> + +#include "absl/base/attributes.h" +#include "absl/strings/string_view.h" +#include "api/array_view.h" +#include "api/field_trials_view.h" +#include "api/sequence_checker.h" +#include "api/task_queue/pending_task_safety_flag.h" +#include "api/transport/field_trial_based_config.h" +#include "rtc_base/ip_address.h" +#include "rtc_base/mdns_responder_interface.h" +#include "rtc_base/memory/always_valid_pointer.h" +#include "rtc_base/network_monitor.h" +#include "rtc_base/network_monitor_factory.h" +#include "rtc_base/socket_factory.h" +#include "rtc_base/system/rtc_export.h" +#include "rtc_base/third_party/sigslot/sigslot.h" +#include "rtc_base/thread_annotations.h" + +#if defined(WEBRTC_POSIX) +struct ifaddrs; +#endif // defined(WEBRTC_POSIX) + +namespace rtc { + +extern const char kPublicIPv4Host[]; +extern const char kPublicIPv6Host[]; + +class IfAddrsConverter; +class Network; +class NetworkMonitorInterface; +class Thread; + +// By default, ignore loopback interfaces on the host. +const int kDefaultNetworkIgnoreMask = ADAPTER_TYPE_LOOPBACK; + +namespace webrtc_network_internal { +bool CompareNetworks(const std::unique_ptr<Network>& a, + const std::unique_ptr<Network>& b); +} // namespace webrtc_network_internal + +// Makes a string key for this network. Used in the network manager's maps. +// Network objects are keyed on interface name, network prefix and the +// length of that prefix. +std::string MakeNetworkKey(absl::string_view name, + const IPAddress& prefix, + int prefix_length); + +// Utility function that attempts to determine an adapter type by an interface +// name (e.g., "wlan0"). Can be used by NetworkManager subclasses when other +// mechanisms fail to determine the type. +RTC_EXPORT AdapterType GetAdapterTypeFromName(absl::string_view network_name); + +class DefaultLocalAddressProvider { + public: + virtual ~DefaultLocalAddressProvider() = default; + + // The default local address is the local address used in multi-homed endpoint + // when the any address (0.0.0.0 or ::) is used as the local address. It's + // important to check the return value as a IP family may not be enabled. + virtual bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const = 0; +}; + +class MdnsResponderProvider { + public: + virtual ~MdnsResponderProvider() = default; + + // Returns the mDNS responder that can be used to obfuscate the local IP + // addresses of ICE host candidates by mDNS hostnames. + // + // The provider MUST outlive the mDNS responder. + virtual webrtc::MdnsResponderInterface* GetMdnsResponder() const = 0; +}; + +// Network/mask in CIDR representation. +class NetworkMask { + public: + NetworkMask(const IPAddress& addr, int prefix_length) + : address_(addr), prefix_length_(prefix_length) {} + + const IPAddress& address() const { return address_; } + int prefix_length() const { return prefix_length_; } + + bool operator==(const NetworkMask& o) const { + return address_ == o.address_ && prefix_length_ == o.prefix_length_; + } + + private: + IPAddress address_; + // Length of valid bits in address_ (for ipv4 valid range is 0-32) + int prefix_length_; +}; + +// Generic network manager interface. It provides list of local +// networks. +// +// Every method of NetworkManager (including the destructor) must be called on +// the same thread, except for the constructor which may be called on any +// thread. +// +// This allows constructing a NetworkManager subclass on one thread and +// passing it into an object that uses it on a different thread. +class RTC_EXPORT NetworkManager : public DefaultLocalAddressProvider, + public MdnsResponderProvider { + public: + // This enum indicates whether adapter enumeration is allowed. + enum EnumerationPermission { + ENUMERATION_ALLOWED, // Adapter enumeration is allowed. Getting 0 network + // from GetNetworks means that there is no network + // available. + ENUMERATION_BLOCKED, // Adapter enumeration is disabled. + // GetAnyAddressNetworks() should be used instead. + }; + + // Called when network list is updated. + sigslot::signal0<> SignalNetworksChanged; + + // Indicates a failure when getting list of network interfaces. + sigslot::signal0<> SignalError; + + // This should be called on the NetworkManager's thread before the + // NetworkManager is used. Subclasses may override this if necessary. + virtual void Initialize() {} + + // Start/Stop monitoring of network interfaces + // list. SignalNetworksChanged or SignalError is emitted immediately + // after StartUpdating() is called. After that SignalNetworksChanged + // is emitted whenever list of networks changes. + virtual void StartUpdating() = 0; + virtual void StopUpdating() = 0; + + // Returns the current list of networks available on this machine. + // StartUpdating() must be called before this method is called. + // It makes sure that repeated calls return the same object for a + // given network, so that quality is tracked appropriately. Does not + // include ignored networks. + // The returned vector of Network* is valid as long as the NetworkManager is + // alive. + virtual std::vector<const Network*> GetNetworks() const = 0; + + // Returns the current permission state of GetNetworks(). + virtual EnumerationPermission enumeration_permission() const; + + // "AnyAddressNetwork" is a network which only contains single "any address" + // IP address. (i.e. INADDR_ANY for IPv4 or in6addr_any for IPv6). This is + // useful as binding to such interfaces allow default routing behavior like + // http traffic. + // + // This method appends the "any address" networks to the list, such that this + // can optionally be called after GetNetworks. + virtual std::vector<const Network*> GetAnyAddressNetworks() = 0; + + // Dumps the current list of networks in the network manager. + virtual void DumpNetworks() {} + bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const override; + + struct Stats { + int ipv4_network_count; + int ipv6_network_count; + Stats() { + ipv4_network_count = 0; + ipv6_network_count = 0; + } + }; + + // MdnsResponderProvider interface. + webrtc::MdnsResponderInterface* GetMdnsResponder() const override; + + virtual void set_vpn_list(const std::vector<NetworkMask>& vpn) {} +}; + +// Base class for NetworkManager implementations. +class RTC_EXPORT NetworkManagerBase : public NetworkManager { + public: + NetworkManagerBase(const webrtc::FieldTrialsView* field_trials = nullptr); + + std::vector<const Network*> GetNetworks() const override; + std::vector<const Network*> GetAnyAddressNetworks() override; + + EnumerationPermission enumeration_permission() const override; + + bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const override; + + // Check if MAC address in |bytes| is one of the pre-defined + // MAC addresses for know VPNs. + static bool IsVpnMacAddress(rtc::ArrayView<const uint8_t> address); + + protected: + // Updates `networks_` with the networks listed in `list`. If + // `networks_map_` already has a Network object for a network listed + // in the `list` then it is reused. Accept ownership of the Network + // objects in the `list`. `changed` will be set to true if there is + // any change in the network list. + void MergeNetworkList(std::vector<std::unique_ptr<Network>> list, + bool* changed); + + // `stats` will be populated even if |*changed| is false. + void MergeNetworkList(std::vector<std::unique_ptr<Network>> list, + bool* changed, + NetworkManager::Stats* stats); + + void set_enumeration_permission(EnumerationPermission state) { + enumeration_permission_ = state; + } + + void set_default_local_addresses(const IPAddress& ipv4, + const IPAddress& ipv6); + + Network* GetNetworkFromAddress(const rtc::IPAddress& ip) const; + + // To enable subclasses to get the networks list, without interfering with + // refactoring of the interface GetNetworks method. + const std::vector<Network*>& GetNetworksInternal() const { return networks_; } + + std::unique_ptr<Network> CreateNetwork(absl::string_view name, + absl::string_view description, + const IPAddress& prefix, + int prefix_length, + AdapterType type) const; + + const webrtc::FieldTrialsView* field_trials() const { + return field_trials_.get(); + } + + private: + friend class NetworkTest; + webrtc::AlwaysValidPointer<const webrtc::FieldTrialsView, + webrtc::FieldTrialBasedConfig> + field_trials_; + EnumerationPermission enumeration_permission_; + + std::vector<Network*> networks_; + + std::map<std::string, std::unique_ptr<Network>> networks_map_; + + std::unique_ptr<rtc::Network> ipv4_any_address_network_; + std::unique_ptr<rtc::Network> ipv6_any_address_network_; + + IPAddress default_local_ipv4_address_; + IPAddress default_local_ipv6_address_; + // We use 16 bits to save the bandwidth consumption when sending the network + // id over the Internet. It is OK that the 16-bit integer overflows to get a + // network id 0 because we only compare the network ids in the old and the new + // best connections in the transport channel. + uint16_t next_available_network_id_ = 1; + + // True if calling network_preference() with a changed value + // should result in firing the SignalNetworkChanged signal. + bool signal_network_preference_change_ = false; +}; + +// Basic implementation of the NetworkManager interface that gets list +// of networks using OS APIs. +class RTC_EXPORT BasicNetworkManager : public NetworkManagerBase, + public NetworkBinderInterface, + public sigslot::has_slots<> { + public: + // This is used by lots of downstream code. + BasicNetworkManager(SocketFactory* socket_factory, + const webrtc::FieldTrialsView* field_trials = nullptr) + : BasicNetworkManager(/* network_monitor_factory= */ nullptr, + socket_factory, + field_trials) {} + + BasicNetworkManager(NetworkMonitorFactory* network_monitor_factory, + SocketFactory* socket_factory, + const webrtc::FieldTrialsView* field_trials = nullptr); + ~BasicNetworkManager() override; + + void StartUpdating() override; + void StopUpdating() override; + + void DumpNetworks() override; + + bool started() { return start_count_ > 0; } + + // Sets the network ignore list, which is empty by default. Any network on the + // ignore list will be filtered from network enumeration results. + // Should be called only before initialization. + void set_network_ignore_list(const std::vector<std::string>& list) { + RTC_DCHECK(thread_ == nullptr); + network_ignore_list_ = list; + } + + // Set a list of manually configured VPN's. + void set_vpn_list(const std::vector<NetworkMask>& vpn) override; + + // Check if |prefix| is configured as VPN. + bool IsConfiguredVpn(IPAddress prefix, int prefix_length) const; + + // Bind a socket to interface that ip address belong to. + // Implementation look up interface name and calls + // BindSocketToNetwork on NetworkMonitor. + // The interface name is needed as e.g ipv4 over ipv6 addresses + // are not exposed using Android functions, but it is possible + // bind an ipv4 address to the interface. + NetworkBindingResult BindSocketToNetwork(int socket_fd, + const IPAddress& address) override; + + protected: +#if defined(WEBRTC_POSIX) + // Separated from CreateNetworks for tests. + void ConvertIfAddrs(ifaddrs* interfaces, + IfAddrsConverter* converter, + bool include_ignored, + std::vector<std::unique_ptr<Network>>* networks) const + RTC_RUN_ON(thread_); + NetworkMonitorInterface::InterfaceInfo GetInterfaceInfo( + struct ifaddrs* cursor) const RTC_RUN_ON(thread_); +#endif // defined(WEBRTC_POSIX) + + // Creates a network object for each network available on the machine. + bool CreateNetworks(bool include_ignored, + std::vector<std::unique_ptr<Network>>* networks) const + RTC_RUN_ON(thread_); + + // Determines if a network should be ignored. This should only be determined + // based on the network's property instead of any individual IP. + bool IsIgnoredNetwork(const Network& network) const RTC_RUN_ON(thread_); + + // This function connects a UDP socket to a public address and returns the + // local address associated it. Since it binds to the "any" address + // internally, it returns the default local address on a multi-homed endpoint. + IPAddress QueryDefaultLocalAddress(int family) const RTC_RUN_ON(thread_); + + private: + friend class NetworkTest; + + // Creates a network monitor and listens for network updates. + void StartNetworkMonitor() RTC_RUN_ON(thread_); + // Stops and removes the network monitor. + void StopNetworkMonitor() RTC_RUN_ON(thread_); + // Called when it receives updates from the network monitor. + void OnNetworksChanged(); + + // Updates the networks and reschedules the next update. + void UpdateNetworksContinually() RTC_RUN_ON(thread_); + // Only updates the networks; does not reschedule the next update. + void UpdateNetworksOnce() RTC_RUN_ON(thread_); + + Thread* thread_ = nullptr; + bool sent_first_update_ = true; + int start_count_ = 0; + + webrtc::AlwaysValidPointer<const webrtc::FieldTrialsView, + webrtc::FieldTrialBasedConfig> + field_trials_; + std::vector<std::string> network_ignore_list_; + NetworkMonitorFactory* const network_monitor_factory_; + SocketFactory* const socket_factory_; + std::unique_ptr<NetworkMonitorInterface> network_monitor_ + RTC_GUARDED_BY(thread_); + bool allow_mac_based_ipv6_ RTC_GUARDED_BY(thread_) = false; + bool bind_using_ifname_ RTC_GUARDED_BY(thread_) = false; + + std::vector<NetworkMask> vpn_; + rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> task_safety_flag_; +}; + +// Represents a Unix-type network interface, with a name and single address. +class RTC_EXPORT Network { + public: + Network(absl::string_view name, + absl::string_view description, + const IPAddress& prefix, + int prefix_length) + : Network(name, + description, + prefix, + prefix_length, + rtc::ADAPTER_TYPE_UNKNOWN) {} + + Network(absl::string_view name, + absl::string_view description, + const IPAddress& prefix, + int prefix_length, + AdapterType type); + + Network(const Network&); + ~Network(); + + // This signal is fired whenever type() or underlying_type_for_vpn() changes. + // Mutable, to support connecting on the const Network passed to cricket::Port + // constructor. + mutable sigslot::signal1<const Network*> SignalTypeChanged; + + // This signal is fired whenever network preference changes. + sigslot::signal1<const Network*> SignalNetworkPreferenceChanged; + + const DefaultLocalAddressProvider* default_local_address_provider() const { + return default_local_address_provider_; + } + void set_default_local_address_provider( + const DefaultLocalAddressProvider* provider) { + default_local_address_provider_ = provider; + } + + void set_mdns_responder_provider(const MdnsResponderProvider* provider) { + mdns_responder_provider_ = provider; + } + + // Returns the name of the interface this network is associated with. + const std::string& name() const { return name_; } + + // Returns the OS-assigned name for this network. This is useful for + // debugging but should not be sent over the wire (for privacy reasons). + const std::string& description() const { return description_; } + + // Returns the prefix for this network. + const IPAddress& prefix() const { return prefix_; } + // Returns the length, in bits, of this network's prefix. + int prefix_length() const { return prefix_length_; } + + // Returns the family for the network prefix. + int family() const { return prefix_.family(); } + + // `key_` has unique value per network interface. Used in sorting network + // interfaces. Key is derived from interface name and it's prefix. + std::string key() const { return key_; } + + // Returns the Network's current idea of the 'best' IP it has. + // Or return an unset IP if this network has no active addresses. + // Here is the rule on how we mark the IPv6 address as ignorable for WebRTC. + // 1) return all global temporary dynamic and non-deprecated ones. + // 2) if #1 not available, return global ones. + // 3) if #2 not available, return local link ones. + // 4) if #3 not available, use ULA ipv6 as last resort. (ULA stands for + // unique local address, which is not route-able in open internet but might + // be useful for a close WebRTC deployment. + + // TODO(guoweis): rule #3 actually won't happen at current + // implementation. The reason being that ULA address starting with + // 0xfc 0r 0xfd will be grouped into its own Network. The result of + // that is WebRTC will have one extra Network to generate candidates + // but the lack of rule #3 shouldn't prevent turning on IPv6 since + // ULA should only be tried in a close deployment anyway. + + // Note that when not specifying any flag, it's treated as case global + // IPv6 address + IPAddress GetBestIP() const; + + // Adds an active IP address to this network. Does not check for duplicates. + void AddIP(const InterfaceAddress& ip) { ips_.push_back(ip); } + void AddIP(const IPAddress& ip) { ips_.push_back(rtc::InterfaceAddress(ip)); } + + // Sets the network's IP address list. Returns true if new IP addresses were + // detected. Passing true to already_changed skips this check. + bool SetIPs(const std::vector<InterfaceAddress>& ips, bool already_changed); + // Get the list of IP Addresses associated with this network. + const std::vector<InterfaceAddress>& GetIPs() const { return ips_; } + // Clear the network's list of addresses. + void ClearIPs() { ips_.clear(); } + // Returns the mDNS responder that can be used to obfuscate the local IP + // addresses of host candidates by mDNS names in ICE gathering. After a + // name-address mapping is created by the mDNS responder, queries for the + // created name will be resolved by the responder. + webrtc::MdnsResponderInterface* GetMdnsResponder() const; + + // Returns the scope-id of the network's address. + // Should only be relevant for link-local IPv6 addresses. + int scope_id() const { return scope_id_; } + void set_scope_id(int id) { scope_id_ = id; } + + // Indicates whether this network should be ignored, perhaps because + // the IP is 0, or the interface is one we know is invalid. + bool ignored() const { return ignored_; } + void set_ignored(bool ignored) { ignored_ = ignored; } + + AdapterType type() const { return type_; } + // When type() is ADAPTER_TYPE_VPN, this returns the type of the underlying + // network interface used by the VPN, typically the preferred network type + // (see for example, the method setUnderlyingNetworks(android.net.Network[]) + // on https://developer.android.com/reference/android/net/VpnService.html). + // When this information is unavailable from the OS, ADAPTER_TYPE_UNKNOWN is + // returned. + AdapterType underlying_type_for_vpn() const { + return underlying_type_for_vpn_; + } + void set_type(AdapterType type) { + if (type_ == type) { + return; + } + type_ = type; + if (type != ADAPTER_TYPE_VPN) { + underlying_type_for_vpn_ = ADAPTER_TYPE_UNKNOWN; + } + SignalTypeChanged(this); + } + + void set_underlying_type_for_vpn(AdapterType type) { + if (underlying_type_for_vpn_ == type) { + return; + } + underlying_type_for_vpn_ = type; + SignalTypeChanged(this); + } + + bool IsVpn() const { return type_ == ADAPTER_TYPE_VPN; } + + bool IsCellular() const { return IsCellular(type_); } + + static bool IsCellular(AdapterType type) { + switch (type) { + case ADAPTER_TYPE_CELLULAR: + case ADAPTER_TYPE_CELLULAR_2G: + case ADAPTER_TYPE_CELLULAR_3G: + case ADAPTER_TYPE_CELLULAR_4G: + case ADAPTER_TYPE_CELLULAR_5G: + return true; + default: + return false; + } + } + + // Note: This function is called "rarely". + // Twice per Network in BasicPortAllocator if + // PORTALLOCATOR_DISABLE_COSTLY_NETWORKS. Once in Port::Construct() (and when + // Port::OnNetworkTypeChanged is called). + ABSL_DEPRECATED( + "Use the version with field trials, see bugs.webrtc.org/webrtc:10335") + uint16_t GetCost(const webrtc::FieldTrialsView* field_trials = nullptr) const; + uint16_t GetCost(const webrtc::FieldTrialsView& field_trials) const; + + // A unique id assigned by the network manager, which may be signaled + // to the remote side in the candidate. + uint16_t id() const { return id_; } + void set_id(uint16_t id) { id_ = id; } + + int preference() const { return preference_; } + void set_preference(int preference) { preference_ = preference; } + + // When we enumerate networks and find a previously-seen network is missing, + // we do not remove it (because it may be used elsewhere). Instead, we mark + // it inactive, so that we can detect network changes properly. + bool active() const { return active_; } + void set_active(bool active) { + if (active_ != active) { + active_ = active; + } + } + + // Property set by operating system/firmware that has information + // about connection strength to e.g WIFI router or CELL base towers. + NetworkPreference network_preference() const { return network_preference_; } + void set_network_preference(NetworkPreference val) { + if (network_preference_ == val) { + return; + } + network_preference_ = val; + SignalNetworkPreferenceChanged(this); + } + + static std::pair<rtc::AdapterType, bool /* vpn */> + GuessAdapterFromNetworkCost(int network_cost); + + // Debugging description of this network + std::string ToString() const; + + private: + const DefaultLocalAddressProvider* default_local_address_provider_ = nullptr; + const MdnsResponderProvider* mdns_responder_provider_ = nullptr; + std::string name_; + std::string description_; + IPAddress prefix_; + int prefix_length_; + std::string key_; + std::vector<InterfaceAddress> ips_; + int scope_id_; + bool ignored_; + AdapterType type_; + AdapterType underlying_type_for_vpn_ = ADAPTER_TYPE_UNKNOWN; + int preference_; + bool active_ = true; + uint16_t id_ = 0; + NetworkPreference network_preference_ = NetworkPreference::NEUTRAL; + + friend class NetworkManager; +}; + +} // namespace rtc + +#endif // RTC_BASE_NETWORK_H_ |