blob: 782c97cf659cb06cb93344f114929260ae6a82c3 [file] [log] [blame]
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001/*
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
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#ifndef RTC_BASE_NETWORK_H_
12#define RTC_BASE_NETWORK_H_
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000013
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +020014#include <stdint.h>
pbosc7c26a02017-01-02 08:42:32 -080015
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +020016#include <deque>
17#include <map>
18#include <memory>
19#include <string>
20#include <vector>
21
Niels Möller22211442022-04-07 11:43:28 +020022#include "absl/base/attributes.h"
Ali Tofigh7fa90572022-03-17 15:47:49 +010023#include "absl/strings/string_view.h"
Jonas Orelandac554eb2021-08-27 09:43:38 +020024#include "api/array_view.h"
Jonas Orelande62c2f22022-03-29 11:04:48 +020025#include "api/field_trials_view.h"
Artem Titovd15a5752021-02-10 14:31:24 +010026#include "api/sequence_checker.h"
Jonas Orelandc06fe8b2022-03-28 14:58:26 +020027#include "api/transport/field_trial_based_config.h"
Steve Anton10542f22019-01-11 09:11:00 -080028#include "rtc_base/ip_address.h"
Qingsi Wang09619332018-09-12 22:51:55 -070029#include "rtc_base/mdns_responder_interface.h"
Jonas Orelandc06fe8b2022-03-28 14:58:26 +020030#include "rtc_base/memory/always_valid_pointer.h"
Steve Anton10542f22019-01-11 09:11:00 -080031#include "rtc_base/network_monitor.h"
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -070032#include "rtc_base/network_monitor_factory.h"
Niels Mölleraa373162021-09-28 16:09:07 +020033#include "rtc_base/socket_factory.h"
Mirko Bonadei35214fc2019-09-23 14:54:28 +020034#include "rtc_base/system/rtc_export.h"
Niels Möller27c14522022-02-07 16:44:21 +010035#include "rtc_base/task_utils/pending_task_safety_flag.h"
Artem Titove41c4332018-07-25 15:04:28 +020036#include "rtc_base/third_party/sigslot/sigslot.h"
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -070037#include "rtc_base/thread_annotations.h"
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +020038
39#if defined(WEBRTC_POSIX)
40struct ifaddrs;
41#endif // defined(WEBRTC_POSIX)
42
43namespace rtc {
44
45extern const char kPublicIPv4Host[];
46extern const char kPublicIPv6Host[];
47
48class IfAddrsConverter;
49class Network;
50class NetworkMonitorInterface;
51class Thread;
52
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +020053// By default, ignore loopback interfaces on the host.
54const int kDefaultNetworkIgnoreMask = ADAPTER_TYPE_LOOPBACK;
55
56// Makes a string key for this network. Used in the network manager's maps.
57// Network objects are keyed on interface name, network prefix and the
58// length of that prefix.
Ali Tofigh7fa90572022-03-17 15:47:49 +010059std::string MakeNetworkKey(absl::string_view name,
Yves Gerey665174f2018-06-19 15:03:05 +020060 const IPAddress& prefix,
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +020061 int prefix_length);
62
Taylor Brandstetter8bac1d92018-01-24 17:38:00 -080063// Utility function that attempts to determine an adapter type by an interface
64// name (e.g., "wlan0"). Can be used by NetworkManager subclasses when other
65// mechanisms fail to determine the type.
Mirko Bonadei35214fc2019-09-23 14:54:28 +020066RTC_EXPORT AdapterType GetAdapterTypeFromName(const char* network_name);
Taylor Brandstetter8bac1d92018-01-24 17:38:00 -080067
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +020068class DefaultLocalAddressProvider {
69 public:
70 virtual ~DefaultLocalAddressProvider() = default;
Qingsi Wang5ae259e2019-02-13 15:46:07 -080071
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +020072 // The default local address is the local address used in multi-homed endpoint
73 // when the any address (0.0.0.0 or ::) is used as the local address. It's
74 // important to check the return value as a IP family may not be enabled.
75 virtual bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const = 0;
76};
77
Qingsi Wang5ae259e2019-02-13 15:46:07 -080078class MdnsResponderProvider {
79 public:
80 virtual ~MdnsResponderProvider() = default;
81
82 // Returns the mDNS responder that can be used to obfuscate the local IP
83 // addresses of ICE host candidates by mDNS hostnames.
84 //
85 // The provider MUST outlive the mDNS responder.
86 virtual webrtc::MdnsResponderInterface* GetMdnsResponder() const = 0;
87};
88
Jonas Oreland2ee0e642021-08-25 15:43:02 +020089// Network/mask in CIDR representation.
90class NetworkMask {
91 public:
92 NetworkMask(const IPAddress& addr, int prefix_length)
93 : address_(addr), prefix_length_(prefix_length) {}
94
95 const IPAddress& address() const { return address_; }
96 int prefix_length() const { return prefix_length_; }
97
98 bool operator==(const NetworkMask& o) const {
99 return address_ == o.address_ && prefix_length_ == o.prefix_length_;
100 }
101
102 private:
103 IPAddress address_;
104 // Length of valid bits in address_ (for ipv4 valid range is 0-32)
105 int prefix_length_;
106};
107
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200108// Generic network manager interface. It provides list of local
109// networks.
110//
111// Every method of NetworkManager (including the destructor) must be called on
112// the same thread, except for the constructor which may be called on any
113// thread.
114//
115// This allows constructing a NetworkManager subclass on one thread and
116// passing it into an object that uses it on a different thread.
Mirko Bonadei35214fc2019-09-23 14:54:28 +0200117class RTC_EXPORT NetworkManager : public DefaultLocalAddressProvider,
118 public MdnsResponderProvider {
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200119 public:
120 typedef std::vector<Network*> NetworkList;
121
122 // This enum indicates whether adapter enumeration is allowed.
123 enum EnumerationPermission {
124 ENUMERATION_ALLOWED, // Adapter enumeration is allowed. Getting 0 network
125 // from GetNetworks means that there is no network
126 // available.
127 ENUMERATION_BLOCKED, // Adapter enumeration is disabled.
128 // GetAnyAddressNetworks() should be used instead.
129 };
130
131 NetworkManager();
132 ~NetworkManager() override;
133
134 // Called when network list is updated.
135 sigslot::signal0<> SignalNetworksChanged;
136
137 // Indicates a failure when getting list of network interfaces.
138 sigslot::signal0<> SignalError;
139
140 // This should be called on the NetworkManager's thread before the
141 // NetworkManager is used. Subclasses may override this if necessary.
142 virtual void Initialize() {}
143
144 // Start/Stop monitoring of network interfaces
145 // list. SignalNetworksChanged or SignalError is emitted immediately
146 // after StartUpdating() is called. After that SignalNetworksChanged
147 // is emitted whenever list of networks changes.
148 virtual void StartUpdating() = 0;
149 virtual void StopUpdating() = 0;
150
Niels Möller22211442022-04-07 11:43:28 +0200151 // TODO(bugs.webrtc.org/13869): Delete after override in downstream subclasses
152 // is deleted.
153 ABSL_DEPRECATED("bugs.webrtc.org/13869")
154 virtual void GetNetworks(NetworkList* networks) const {}
155
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200156 // Returns the current list of networks available on this machine.
157 // StartUpdating() must be called before this method is called.
158 // It makes sure that repeated calls return the same object for a
159 // given network, so that quality is tracked appropriately. Does not
160 // include ignored networks.
Niels Möller22211442022-04-07 11:43:28 +0200161 virtual std::vector<const Network*> GetNetworks() const = 0;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200162
Qingsi Wang09619332018-09-12 22:51:55 -0700163 // Returns the current permission state of GetNetworks().
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200164 virtual EnumerationPermission enumeration_permission() const;
165
166 // "AnyAddressNetwork" is a network which only contains single "any address"
167 // IP address. (i.e. INADDR_ANY for IPv4 or in6addr_any for IPv6). This is
168 // useful as binding to such interfaces allow default routing behavior like
169 // http traffic.
170 //
171 // This method appends the "any address" networks to the list, such that this
172 // can optionally be called after GetNetworks.
Niels Möller22211442022-04-07 11:43:28 +0200173 virtual std::vector<const Network*> GetAnyAddressNetworks() = 0;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200174
175 // Dumps the current list of networks in the network manager.
176 virtual void DumpNetworks() {}
177 bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const override;
178
179 struct Stats {
180 int ipv4_network_count;
181 int ipv6_network_count;
182 Stats() {
183 ipv4_network_count = 0;
184 ipv6_network_count = 0;
185 }
186 };
Qingsi Wang09619332018-09-12 22:51:55 -0700187
Qingsi Wang5ae259e2019-02-13 15:46:07 -0800188 // MdnsResponderProvider interface.
189 webrtc::MdnsResponderInterface* GetMdnsResponder() const override;
Jonas Oreland2ee0e642021-08-25 15:43:02 +0200190
191 virtual void set_vpn_list(const std::vector<NetworkMask>& vpn) {}
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200192};
193
194// Base class for NetworkManager implementations.
Mirko Bonadei35214fc2019-09-23 14:54:28 +0200195class RTC_EXPORT NetworkManagerBase : public NetworkManager {
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200196 public:
Jonas Orelande62c2f22022-03-29 11:04:48 +0200197 NetworkManagerBase(const webrtc::FieldTrialsView* field_trials = nullptr);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200198 ~NetworkManagerBase() override;
199
Niels Möller22211442022-04-07 11:43:28 +0200200 std::vector<const Network*> GetNetworks() const override;
201 std::vector<const Network*> GetAnyAddressNetworks() override;
deadbeef3427f532017-07-26 16:09:33 -0700202
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200203 EnumerationPermission enumeration_permission() const override;
204
205 bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const override;
206
Jonas Orelandac554eb2021-08-27 09:43:38 +0200207 // Check if MAC address in |bytes| is one of the pre-defined
208 // MAC addresses for know VPNs.
209 static bool IsVpnMacAddress(rtc::ArrayView<const uint8_t> address);
210
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200211 protected:
212 typedef std::map<std::string, Network*> NetworkMap;
Artem Titov96e3b992021-07-26 16:03:14 +0200213 // Updates `networks_` with the networks listed in `list`. If
Niels Möller22211442022-04-07 11:43:28 +0200214 // `networks_map_` already has a Network object for a network listed
Artem Titov96e3b992021-07-26 16:03:14 +0200215 // in the `list` then it is reused. Accept ownership of the Network
216 // objects in the `list`. `changed` will be set to true if there is
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200217 // any change in the network list.
218 void MergeNetworkList(const NetworkList& list, bool* changed);
219
Artem Titov96e3b992021-07-26 16:03:14 +0200220 // `stats` will be populated even if |*changed| is false.
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200221 void MergeNetworkList(const NetworkList& list,
222 bool* changed,
223 NetworkManager::Stats* stats);
224
225 void set_enumeration_permission(EnumerationPermission state) {
226 enumeration_permission_ = state;
227 }
228
229 void set_default_local_addresses(const IPAddress& ipv4,
230 const IPAddress& ipv6);
231
Jonas Oreland6ca955a2021-03-15 08:27:43 +0000232 Network* GetNetworkFromAddress(const rtc::IPAddress& ip) const;
233
Niels Möllerbf4988a2022-04-01 16:38:27 +0200234 // To enable subclasses to get the networks list, without interfering with
235 // refactoring of the interface GetNetworks method.
236 const NetworkList& GetNetworksInternal() const { return networks_; }
237
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200238 private:
239 friend class NetworkTest;
240
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200241 EnumerationPermission enumeration_permission_;
242
243 NetworkList networks_;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200244
245 NetworkMap networks_map_;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200246
247 std::unique_ptr<rtc::Network> ipv4_any_address_network_;
248 std::unique_ptr<rtc::Network> ipv6_any_address_network_;
249
250 IPAddress default_local_ipv4_address_;
251 IPAddress default_local_ipv6_address_;
252 // We use 16 bits to save the bandwidth consumption when sending the network
253 // id over the Internet. It is OK that the 16-bit integer overflows to get a
254 // network id 0 because we only compare the network ids in the old and the new
255 // best connections in the transport channel.
256 uint16_t next_available_network_id_ = 1;
Jonas Orelandf7721fb2020-08-07 11:08:34 +0200257
258 // True if calling network_preference() with a changed value
259 // should result in firing the SignalNetworkChanged signal.
260 bool signal_network_preference_change_ = false;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200261};
262
263// Basic implementation of the NetworkManager interface that gets list
264// of networks using OS APIs.
Mirko Bonadei35214fc2019-09-23 14:54:28 +0200265class RTC_EXPORT BasicNetworkManager : public NetworkManagerBase,
Jonas Oreland6ca955a2021-03-15 08:27:43 +0000266 public NetworkBinderInterface,
Mirko Bonadei35214fc2019-09-23 14:54:28 +0200267 public sigslot::has_slots<> {
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200268 public:
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200269 // This version is used by chromium.
Niels Möller539f3e12021-11-26 16:33:19 +0100270 ABSL_DEPRECATED(
271 "Use the version with socket_factory, see bugs.webrtc.org/13145")
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200272 explicit BasicNetworkManager(
Jonas Orelande62c2f22022-03-29 11:04:48 +0200273 const webrtc::FieldTrialsView* field_trials = nullptr)
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200274 : BasicNetworkManager(
275 /* network_monitor_factory= */ nullptr,
276 /* socket_factory= */ nullptr,
277 field_trials) {}
278
279 // This is used by lots of downstream code.
Jonas Orelande62c2f22022-03-29 11:04:48 +0200280 BasicNetworkManager(SocketFactory* socket_factory,
281 const webrtc::FieldTrialsView* field_trials = nullptr)
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200282 : BasicNetworkManager(/* network_monitor_factory= */ nullptr,
283 socket_factory,
284 field_trials) {}
285
Jonas Orelande62c2f22022-03-29 11:04:48 +0200286 BasicNetworkManager(NetworkMonitorFactory* network_monitor_factory,
287 SocketFactory* socket_factory,
288 const webrtc::FieldTrialsView* field_trials = nullptr);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200289 ~BasicNetworkManager() override;
290
291 void StartUpdating() override;
292 void StopUpdating() override;
293
294 void DumpNetworks() override;
295
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200296 bool started() { return start_count_ > 0; }
297
298 // Sets the network ignore list, which is empty by default. Any network on the
299 // ignore list will be filtered from network enumeration results.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700300 // Should be called only before initialization.
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200301 void set_network_ignore_list(const std::vector<std::string>& list) {
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700302 RTC_DCHECK(thread_ == nullptr);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200303 network_ignore_list_ = list;
304 }
305
Jonas Oreland2ee0e642021-08-25 15:43:02 +0200306 // Set a list of manually configured VPN's.
307 void set_vpn_list(const std::vector<NetworkMask>& vpn) override;
308
309 // Check if |prefix| is configured as VPN.
310 bool IsConfiguredVpn(IPAddress prefix, int prefix_length) const;
311
Jonas Oreland6ca955a2021-03-15 08:27:43 +0000312 // Bind a socket to interface that ip address belong to.
313 // Implementation look up interface name and calls
314 // BindSocketToNetwork on NetworkMonitor.
315 // The interface name is needed as e.g ipv4 over ipv6 addresses
316 // are not exposed using Android functions, but it is possible
317 // bind an ipv4 address to the interface.
318 NetworkBindingResult BindSocketToNetwork(int socket_fd,
319 const IPAddress& address) override;
320
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200321 protected:
322#if defined(WEBRTC_POSIX)
323 // Separated from CreateNetworks for tests.
324 void ConvertIfAddrs(ifaddrs* interfaces,
325 IfAddrsConverter* converter,
326 bool include_ignored,
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700327 NetworkList* networks) const RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200328#endif // defined(WEBRTC_POSIX)
329
330 // Creates a network object for each network available on the machine.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700331 bool CreateNetworks(bool include_ignored, NetworkList* networks) const
332 RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200333
334 // Determines if a network should be ignored. This should only be determined
335 // based on the network's property instead of any individual IP.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700336 bool IsIgnoredNetwork(const Network& network) const RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200337
338 // This function connects a UDP socket to a public address and returns the
339 // local address associated it. Since it binds to the "any" address
340 // internally, it returns the default local address on a multi-homed endpoint.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700341 IPAddress QueryDefaultLocalAddress(int family) const RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200342
343 private:
344 friend class NetworkTest;
345
346 // Creates a network monitor and listens for network updates.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700347 void StartNetworkMonitor() RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200348 // Stops and removes the network monitor.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700349 void StopNetworkMonitor() RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200350 // Called when it receives updates from the network monitor.
351 void OnNetworksChanged();
352
353 // Updates the networks and reschedules the next update.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700354 void UpdateNetworksContinually() RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200355 // Only updates the networks; does not reschedule the next update.
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700356 void UpdateNetworksOnce() RTC_RUN_ON(thread_);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200357
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700358 Thread* thread_ = nullptr;
359 bool sent_first_update_ = true;
360 int start_count_ = 0;
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200361 // Chromium create BasicNetworkManager() w/o field trials.
Jonas Orelande62c2f22022-03-29 11:04:48 +0200362 webrtc::AlwaysValidPointer<const webrtc::FieldTrialsView,
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200363 webrtc::FieldTrialBasedConfig>
364 field_trials_;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200365 std::vector<std::string> network_ignore_list_;
Niels Mölleraa373162021-09-28 16:09:07 +0200366 NetworkMonitorFactory* const network_monitor_factory_;
367 SocketFactory* const socket_factory_;
Taylor Brandstetter239ac8a2020-07-31 16:07:52 -0700368 std::unique_ptr<NetworkMonitorInterface> network_monitor_
369 RTC_GUARDED_BY(thread_);
Jonas Oreland6ca955a2021-03-15 08:27:43 +0000370 bool allow_mac_based_ipv6_ RTC_GUARDED_BY(thread_) = false;
371 bool bind_using_ifname_ RTC_GUARDED_BY(thread_) = false;
Jonas Oreland2ee0e642021-08-25 15:43:02 +0200372
373 std::vector<NetworkMask> vpn_;
Niels Möller27c14522022-02-07 16:44:21 +0100374 rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> task_safety_flag_;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200375};
376
377// Represents a Unix-type network interface, with a name and single address.
Mirko Bonadei35214fc2019-09-23 14:54:28 +0200378class RTC_EXPORT Network {
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200379 public:
Ali Tofigh7fa90572022-03-17 15:47:49 +0100380 Network(absl::string_view name,
381 absl::string_view description,
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200382 const IPAddress& prefix,
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200383 int prefix_length)
384 : Network(name,
385 description,
386 prefix,
387 prefix_length,
388 rtc::ADAPTER_TYPE_UNKNOWN) {}
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200389
Ali Tofigh7fa90572022-03-17 15:47:49 +0100390 Network(absl::string_view name,
391 absl::string_view description,
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200392 const IPAddress& prefix,
393 int prefix_length,
394 AdapterType type);
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200395
Steve Anton9de3aac2017-10-24 10:08:26 -0700396 Network(const Network&);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200397 ~Network();
Jonas Orelandf7721fb2020-08-07 11:08:34 +0200398
Qingsi Wangde2ed7d2018-04-27 14:25:37 -0700399 // This signal is fired whenever type() or underlying_type_for_vpn() changes.
Niels Möllere0c6bdf2022-03-24 15:18:02 +0100400 // Mutable, to support connecting on the const Network passed to cricket::Port
401 // constructor.
402 mutable sigslot::signal1<const Network*> SignalTypeChanged;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200403
Jonas Orelandf7721fb2020-08-07 11:08:34 +0200404 // This signal is fired whenever network preference changes.
405 sigslot::signal1<const Network*> SignalNetworkPreferenceChanged;
406
Niels Möllere0c6bdf2022-03-24 15:18:02 +0100407 const DefaultLocalAddressProvider* default_local_address_provider() const {
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200408 return default_local_address_provider_;
409 }
410 void set_default_local_address_provider(
411 const DefaultLocalAddressProvider* provider) {
412 default_local_address_provider_ = provider;
413 }
414
Qingsi Wang5ae259e2019-02-13 15:46:07 -0800415 void set_mdns_responder_provider(const MdnsResponderProvider* provider) {
416 mdns_responder_provider_ = provider;
417 }
418
419 // Returns the name of the interface this network is associated with.
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200420 const std::string& name() const { return name_; }
421
422 // Returns the OS-assigned name for this network. This is useful for
423 // debugging but should not be sent over the wire (for privacy reasons).
424 const std::string& description() const { return description_; }
425
426 // Returns the prefix for this network.
427 const IPAddress& prefix() const { return prefix_; }
428 // Returns the length, in bits, of this network's prefix.
429 int prefix_length() const { return prefix_length_; }
430
Artem Titov96e3b992021-07-26 16:03:14 +0200431 // `key_` has unique value per network interface. Used in sorting network
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200432 // interfaces. Key is derived from interface name and it's prefix.
433 std::string key() const { return key_; }
434
435 // Returns the Network's current idea of the 'best' IP it has.
436 // Or return an unset IP if this network has no active addresses.
437 // Here is the rule on how we mark the IPv6 address as ignorable for WebRTC.
Qingsi Wang5ae259e2019-02-13 15:46:07 -0800438 // 1) return all global temporary dynamic and non-deprecated ones.
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200439 // 2) if #1 not available, return global ones.
440 // 3) if #2 not available, use ULA ipv6 as last resort. (ULA stands
441 // for unique local address, which is not route-able in open
442 // internet but might be useful for a close WebRTC deployment.
443
444 // TODO(guoweis): rule #3 actually won't happen at current
445 // implementation. The reason being that ULA address starting with
446 // 0xfc 0r 0xfd will be grouped into its own Network. The result of
447 // that is WebRTC will have one extra Network to generate candidates
448 // but the lack of rule #3 shouldn't prevent turning on IPv6 since
449 // ULA should only be tried in a close deployment anyway.
450
451 // Note that when not specifying any flag, it's treated as case global
452 // IPv6 address
453 IPAddress GetBestIP() const;
454
455 // Keep the original function here for now.
456 // TODO(guoweis): Remove this when all callers are migrated to GetBestIP().
457 IPAddress ip() const { return GetBestIP(); }
458
459 // Adds an active IP address to this network. Does not check for duplicates.
460 void AddIP(const InterfaceAddress& ip) { ips_.push_back(ip); }
Taylor Brandstetter01cb5f22018-03-07 15:49:32 -0800461 void AddIP(const IPAddress& ip) { ips_.push_back(rtc::InterfaceAddress(ip)); }
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200462
463 // Sets the network's IP address list. Returns true if new IP addresses were
464 // detected. Passing true to already_changed skips this check.
465 bool SetIPs(const std::vector<InterfaceAddress>& ips, bool already_changed);
466 // Get the list of IP Addresses associated with this network.
Yves Gerey665174f2018-06-19 15:03:05 +0200467 const std::vector<InterfaceAddress>& GetIPs() const { return ips_; }
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200468 // Clear the network's list of addresses.
469 void ClearIPs() { ips_.clear(); }
Qingsi Wang5ae259e2019-02-13 15:46:07 -0800470 // Returns the mDNS responder that can be used to obfuscate the local IP
Qingsi Wang09619332018-09-12 22:51:55 -0700471 // addresses of host candidates by mDNS names in ICE gathering. After a
472 // name-address mapping is created by the mDNS responder, queries for the
473 // created name will be resolved by the responder.
Qingsi Wang5ae259e2019-02-13 15:46:07 -0800474 webrtc::MdnsResponderInterface* GetMdnsResponder() const;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200475
476 // Returns the scope-id of the network's address.
477 // Should only be relevant for link-local IPv6 addresses.
478 int scope_id() const { return scope_id_; }
479 void set_scope_id(int id) { scope_id_ = id; }
480
481 // Indicates whether this network should be ignored, perhaps because
482 // the IP is 0, or the interface is one we know is invalid.
483 bool ignored() const { return ignored_; }
484 void set_ignored(bool ignored) { ignored_ = ignored; }
485
486 AdapterType type() const { return type_; }
Qingsi Wangde2ed7d2018-04-27 14:25:37 -0700487 // When type() is ADAPTER_TYPE_VPN, this returns the type of the underlying
488 // network interface used by the VPN, typically the preferred network type
489 // (see for example, the method setUnderlyingNetworks(android.net.Network[])
490 // on https://developer.android.com/reference/android/net/VpnService.html).
491 // When this information is unavailable from the OS, ADAPTER_TYPE_UNKNOWN is
492 // returned.
493 AdapterType underlying_type_for_vpn() const {
494 return underlying_type_for_vpn_;
495 }
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200496 void set_type(AdapterType type) {
497 if (type_ == type) {
498 return;
499 }
500 type_ = type;
Qingsi Wangde2ed7d2018-04-27 14:25:37 -0700501 if (type != ADAPTER_TYPE_VPN) {
502 underlying_type_for_vpn_ = ADAPTER_TYPE_UNKNOWN;
503 }
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200504 SignalTypeChanged(this);
505 }
506
Qingsi Wangde2ed7d2018-04-27 14:25:37 -0700507 void set_underlying_type_for_vpn(AdapterType type) {
508 if (underlying_type_for_vpn_ == type) {
509 return;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200510 }
Qingsi Wangde2ed7d2018-04-27 14:25:37 -0700511 underlying_type_for_vpn_ = type;
512 SignalTypeChanged(this);
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200513 }
Qingsi Wangde2ed7d2018-04-27 14:25:37 -0700514
515 bool IsVpn() const { return type_ == ADAPTER_TYPE_VPN; }
516
Jonas Orelandc7ea04a2020-04-03 10:12:28 +0200517 bool IsCellular() const { return IsCellular(type_); }
518
519 static bool IsCellular(AdapterType type) {
520 switch (type) {
Jonas Oreland08d18062020-04-02 07:19:12 +0200521 case ADAPTER_TYPE_CELLULAR:
522 case ADAPTER_TYPE_CELLULAR_2G:
523 case ADAPTER_TYPE_CELLULAR_3G:
524 case ADAPTER_TYPE_CELLULAR_4G:
525 case ADAPTER_TYPE_CELLULAR_5G:
526 return true;
527 default:
528 return false;
529 }
530 }
531
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200532 // Note: This function is called "rarely".
533 // Twice per Network in BasicPortAllocator if
534 // PORTALLOCATOR_DISABLE_COSTLY_NETWORKS. Once in Port::Construct() (and when
535 // Port::OnNetworkTypeChanged is called).
536 ABSL_DEPRECATED(
537 "Use the version with field trials, see bugs.webrtc.org/webrtc:10335")
Jonas Orelande62c2f22022-03-29 11:04:48 +0200538 uint16_t GetCost(const webrtc::FieldTrialsView* field_trials = nullptr) const;
539 uint16_t GetCost(const webrtc::FieldTrialsView& field_trials) const;
Jonas Orelandc06fe8b2022-03-28 14:58:26 +0200540
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200541 // A unique id assigned by the network manager, which may be signaled
542 // to the remote side in the candidate.
543 uint16_t id() const { return id_; }
544 void set_id(uint16_t id) { id_ = id; }
545
546 int preference() const { return preference_; }
547 void set_preference(int preference) { preference_ = preference; }
548
549 // When we enumerate networks and find a previously-seen network is missing,
550 // we do not remove it (because it may be used elsewhere). Instead, we mark
551 // it inactive, so that we can detect network changes properly.
552 bool active() const { return active_; }
553 void set_active(bool active) {
554 if (active_ != active) {
555 active_ = active;
556 }
557 }
558
Jonas Orelandf7721fb2020-08-07 11:08:34 +0200559 // Property set by operating system/firmware that has information
560 // about connection strength to e.g WIFI router or CELL base towers.
561 NetworkPreference network_preference() const { return network_preference_; }
562 void set_network_preference(NetworkPreference val) {
563 if (network_preference_ == val) {
564 return;
565 }
566 network_preference_ = val;
567 SignalNetworkPreferenceChanged(this);
568 }
569
Jonas Oreland30019052022-01-28 14:11:44 +0100570 static std::pair<rtc::AdapterType, bool /* vpn */>
571 GuessAdapterFromNetworkCost(int network_cost);
572
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200573 // Debugging description of this network
574 std::string ToString() const;
575
576 private:
577 const DefaultLocalAddressProvider* default_local_address_provider_ = nullptr;
Qingsi Wang5ae259e2019-02-13 15:46:07 -0800578 const MdnsResponderProvider* mdns_responder_provider_ = nullptr;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200579 std::string name_;
580 std::string description_;
581 IPAddress prefix_;
582 int prefix_length_;
583 std::string key_;
584 std::vector<InterfaceAddress> ips_;
585 int scope_id_;
586 bool ignored_;
587 AdapterType type_;
Qingsi Wangde2ed7d2018-04-27 14:25:37 -0700588 AdapterType underlying_type_for_vpn_ = ADAPTER_TYPE_UNKNOWN;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200589 int preference_;
590 bool active_ = true;
591 uint16_t id_ = 0;
Jonas Orelandf7721fb2020-08-07 11:08:34 +0200592 NetworkPreference network_preference_ = NetworkPreference::NEUTRAL;
Henrik Kjellanderec78f1c2017-06-29 07:52:50 +0200593
594 friend class NetworkManager;
595};
596
597} // namespace rtc
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000598
Mirko Bonadei92ea95e2017-09-15 06:47:31 +0200599#endif // RTC_BASE_NETWORK_H_