Revert "Move webrtc/{base => rtc_base}" (https://codereview.webrtc.org/2877023002)
Will reland in two different commits to preserve git blame history.
BUG=webrtc:7634
NOTRY=True
TBR=kwiberg@webrtc.org
Change-Id: I550da8525aeb9c5b8f96338fcf1c9714f3dcdab1
Reviewed-on: https://chromium-review.googlesource.com/554610
Reviewed-by: Henrik Kjellander <kjellander@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#18820}diff --git a/webrtc/base/network.h b/webrtc/base/network.h
index 2953098..34d6538 100644
--- a/webrtc/base/network.h
+++ b/webrtc/base/network.h
@@ -11,9 +11,424 @@
#ifndef WEBRTC_BASE_NETWORK_H_
#define WEBRTC_BASE_NETWORK_H_
+#include <stdint.h>
-// This header is deprecated and is just left here temporarily during
-// refactoring. See https://bugs.webrtc.org/7634 for more details.
-#include "webrtc/rtc_base/network.h"
+#include <deque>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/ipaddress.h"
+#include "webrtc/base/networkmonitor.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/sigslot.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;
+
+static const uint16_t kNetworkCostMax = 999;
+static const uint16_t kNetworkCostHigh = 900;
+static const uint16_t kNetworkCostUnknown = 50;
+static const uint16_t kNetworkCostLow = 10;
+static const uint16_t kNetworkCostMin = 0;
+
+// By default, ignore loopback interfaces on the host.
+const int kDefaultNetworkIgnoreMask = ADAPTER_TYPE_LOOPBACK;
+
+// 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(const std::string& name, const IPAddress& prefix,
+ int prefix_length);
+
+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;
+};
+
+// 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 NetworkManager : public DefaultLocalAddressProvider {
+ public:
+ typedef std::vector<Network*> NetworkList;
+
+ // 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.
+ };
+
+ NetworkManager();
+ ~NetworkManager() override;
+
+ // 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.
+ virtual void GetNetworks(NetworkList* networks) const = 0;
+
+ // return 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.
+ //
+ // TODO(guoweis): remove this body when chromium implements this.
+ virtual void GetAnyAddressNetworks(NetworkList* networks) {}
+
+ // 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;
+ }
+ };
+};
+
+// Base class for NetworkManager implementations.
+class NetworkManagerBase : public NetworkManager {
+ public:
+ NetworkManagerBase();
+ ~NetworkManagerBase() override;
+
+ void GetNetworks(NetworkList* networks) const override;
+ void GetAnyAddressNetworks(NetworkList* networks) override;
+ // Defaults to true.
+ bool ipv6_enabled() const { return ipv6_enabled_; }
+ void set_ipv6_enabled(bool enabled) { ipv6_enabled_ = enabled; }
+
+ void set_max_ipv6_networks(int networks) { max_ipv6_networks_ = networks; }
+ int max_ipv6_networks() { return max_ipv6_networks_; }
+
+ EnumerationPermission enumeration_permission() const override;
+
+ bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const override;
+
+ protected:
+ typedef std::map<std::string, Network*> NetworkMap;
+ // Updates |networks_| with the networks listed in |list|. If
+ // |network_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(const NetworkList& list, bool* changed);
+
+ // |stats| will be populated even if |*changed| is false.
+ void MergeNetworkList(const NetworkList& 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);
+
+ private:
+ friend class NetworkTest;
+
+ Network* GetNetworkFromAddress(const rtc::IPAddress& ip) const;
+
+ EnumerationPermission enumeration_permission_;
+
+ NetworkList networks_;
+ int max_ipv6_networks_;
+
+ NetworkMap networks_map_;
+ bool ipv6_enabled_;
+
+ 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;
+};
+
+// Basic implementation of the NetworkManager interface that gets list
+// of networks using OS APIs.
+class BasicNetworkManager : public NetworkManagerBase,
+ public MessageHandler,
+ public sigslot::has_slots<> {
+ public:
+ BasicNetworkManager();
+ ~BasicNetworkManager() override;
+
+ void StartUpdating() override;
+ void StopUpdating() override;
+
+ void DumpNetworks() override;
+
+ // MessageHandler interface.
+ void OnMessage(Message* msg) 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.
+ void set_network_ignore_list(const std::vector<std::string>& list) {
+ network_ignore_list_ = list;
+ }
+
+#if defined(WEBRTC_LINUX)
+ // Sets the flag for ignoring non-default routes.
+ void set_ignore_non_default_routes(bool value) {
+ ignore_non_default_routes_ = true;
+ }
+#endif
+
+ protected:
+#if defined(WEBRTC_POSIX)
+ // Separated from CreateNetworks for tests.
+ void ConvertIfAddrs(ifaddrs* interfaces,
+ IfAddrsConverter* converter,
+ bool include_ignored,
+ NetworkList* networks) const;
+#endif // defined(WEBRTC_POSIX)
+
+ // Creates a network object for each network available on the machine.
+ bool CreateNetworks(bool include_ignored, NetworkList* networks) const;
+
+ // 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;
+
+ // 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;
+
+ private:
+ friend class NetworkTest;
+
+ // Creates a network monitor and listens for network updates.
+ void StartNetworkMonitor();
+ // Stops and removes the network monitor.
+ void StopNetworkMonitor();
+ // Called when it receives updates from the network monitor.
+ void OnNetworksChanged();
+
+ // Updates the networks and reschedules the next update.
+ void UpdateNetworksContinually();
+ // Only updates the networks; does not reschedule the next update.
+ void UpdateNetworksOnce();
+
+ AdapterType GetAdapterTypeFromName(const char* network_name) const;
+
+ Thread* thread_;
+ bool sent_first_update_;
+ int start_count_;
+ std::vector<std::string> network_ignore_list_;
+ bool ignore_non_default_routes_;
+ std::unique_ptr<NetworkMonitorInterface> network_monitor_;
+};
+
+// Represents a Unix-type network interface, with a name and single address.
+class Network {
+ public:
+ Network(const std::string& name,
+ const std::string& description,
+ const IPAddress& prefix,
+ int prefix_length);
+
+ Network(const std::string& name,
+ const std::string& description,
+ const IPAddress& prefix,
+ int prefix_length,
+ AdapterType type);
+ ~Network();
+
+ sigslot::signal1<const Network*> SignalTypeChanged;
+
+ const DefaultLocalAddressProvider* default_local_address_provider() {
+ return default_local_address_provider_;
+ }
+ void set_default_local_address_provider(
+ const DefaultLocalAddressProvider* provider) {
+ default_local_address_provider_ = provider;
+ }
+
+ // Returns the name of the interface this network is associated wtih.
+ 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_; }
+
+ // |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-deprecrated ones.
+ // 2) if #1 not available, return global ones.
+ // 3) if #2 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;
+
+ // Keep the original function here for now.
+ // TODO(guoweis): Remove this when all callers are migrated to GetBestIP().
+ IPAddress ip() const { return GetBestIP(); }
+
+ // Adds an active IP address to this network. Does not check for duplicates.
+ void AddIP(const InterfaceAddress& ip) { ips_.push_back(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 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_; }
+ void set_type(AdapterType type) {
+ if (type_ == type) {
+ return;
+ }
+ type_ = type;
+ SignalTypeChanged(this);
+ }
+
+ uint16_t GetCost() const {
+ switch (type_) {
+ case rtc::ADAPTER_TYPE_ETHERNET:
+ case rtc::ADAPTER_TYPE_LOOPBACK:
+ return kNetworkCostMin;
+ case rtc::ADAPTER_TYPE_WIFI:
+ case rtc::ADAPTER_TYPE_VPN:
+ return kNetworkCostLow;
+ case rtc::ADAPTER_TYPE_CELLULAR:
+ return kNetworkCostHigh;
+ default:
+ return kNetworkCostUnknown;
+ }
+ }
+ // 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;
+ }
+ }
+
+ // Debugging description of this network
+ std::string ToString() const;
+
+ private:
+ const DefaultLocalAddressProvider* default_local_address_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_;
+ int preference_;
+ bool active_ = true;
+ uint16_t id_ = 0;
+
+ friend class NetworkManager;
+};
+
+} // namespace rtc
#endif // WEBRTC_BASE_NETWORK_H_