summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/p2p/base/port.h
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/libwebrtc/p2p/base/port.h')
-rw-r--r--third_party/libwebrtc/p2p/base/port.h540
1 files changed, 540 insertions, 0 deletions
diff --git a/third_party/libwebrtc/p2p/base/port.h b/third_party/libwebrtc/p2p/base/port.h
new file mode 100644
index 0000000000..31091eb273
--- /dev/null
+++ b/third_party/libwebrtc/p2p/base/port.h
@@ -0,0 +1,540 @@
+/*
+ * 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 P2P_BASE_PORT_H_
+#define P2P_BASE_PORT_H_
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "api/candidate.h"
+#include "api/field_trials_view.h"
+#include "api/packet_socket_factory.h"
+#include "api/rtc_error.h"
+#include "api/task_queue/task_queue_base.h"
+#include "api/transport/field_trial_based_config.h"
+#include "api/transport/stun.h"
+#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h"
+#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
+#include "logging/rtc_event_log/ice_logger.h"
+#include "p2p/base/candidate_pair_interface.h"
+#include "p2p/base/connection.h"
+#include "p2p/base/connection_info.h"
+#include "p2p/base/p2p_constants.h"
+#include "p2p/base/port_interface.h"
+#include "p2p/base/stun_request.h"
+#include "rtc_base/async_packet_socket.h"
+#include "rtc_base/callback_list.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/memory/always_valid_pointer.h"
+#include "rtc_base/net_helper.h"
+#include "rtc_base/network.h"
+#include "rtc_base/proxy_info.h"
+#include "rtc_base/rate_tracker.h"
+#include "rtc_base/socket_address.h"
+#include "rtc_base/system/rtc_export.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
+#include "rtc_base/weak_ptr.h"
+
+namespace cricket {
+
+RTC_EXPORT extern const char LOCAL_PORT_TYPE[];
+RTC_EXPORT extern const char STUN_PORT_TYPE[];
+RTC_EXPORT extern const char PRFLX_PORT_TYPE[];
+RTC_EXPORT extern const char RELAY_PORT_TYPE[];
+
+// RFC 6544, TCP candidate encoding rules.
+extern const int DISCARD_PORT;
+extern const char TCPTYPE_ACTIVE_STR[];
+extern const char TCPTYPE_PASSIVE_STR[];
+extern const char TCPTYPE_SIMOPEN_STR[];
+
+// The type preference MUST be an integer from 0 to 126 inclusive.
+// https://datatracker.ietf.org/doc/html/rfc5245#section-4.1.2.1
+enum IcePriorityValue : uint8_t {
+ ICE_TYPE_PREFERENCE_RELAY_TLS = 0,
+ ICE_TYPE_PREFERENCE_RELAY_TCP = 1,
+ ICE_TYPE_PREFERENCE_RELAY_UDP = 2,
+ ICE_TYPE_PREFERENCE_PRFLX_TCP = 80,
+ ICE_TYPE_PREFERENCE_HOST_TCP = 90,
+ ICE_TYPE_PREFERENCE_SRFLX = 100,
+ ICE_TYPE_PREFERENCE_PRFLX = 110,
+ ICE_TYPE_PREFERENCE_HOST = 126
+};
+
+enum class MdnsNameRegistrationStatus {
+ // IP concealment with mDNS is not enabled or the name registration process is
+ // not started yet.
+ kNotStarted,
+ // A request to create and register an mDNS name for a local IP address of a
+ // host candidate is sent to the mDNS responder.
+ kInProgress,
+ // The name registration is complete and the created name is returned by the
+ // mDNS responder.
+ kCompleted,
+};
+
+// Stats that we can return about the port of a STUN candidate.
+class StunStats {
+ public:
+ StunStats() = default;
+ StunStats(const StunStats&) = default;
+ ~StunStats() = default;
+
+ StunStats& operator=(const StunStats& other) = default;
+
+ int stun_binding_requests_sent = 0;
+ int stun_binding_responses_received = 0;
+ double stun_binding_rtt_ms_total = 0;
+ double stun_binding_rtt_ms_squared_total = 0;
+};
+
+// Stats that we can return about a candidate.
+class CandidateStats {
+ public:
+ CandidateStats() = default;
+ CandidateStats(const CandidateStats&) = default;
+ CandidateStats(CandidateStats&&) = default;
+ CandidateStats(Candidate candidate,
+ absl::optional<StunStats> stats = absl::nullopt)
+ : candidate_(std::move(candidate)), stun_stats_(std::move(stats)) {}
+ ~CandidateStats() = default;
+
+ CandidateStats& operator=(const CandidateStats& other) = default;
+
+ const Candidate& candidate() const { return candidate_; }
+
+ const absl::optional<StunStats>& stun_stats() const { return stun_stats_; }
+
+ private:
+ Candidate candidate_;
+ // STUN port stats if this candidate is a STUN candidate.
+ absl::optional<StunStats> stun_stats_;
+};
+
+typedef std::vector<CandidateStats> CandidateStatsList;
+
+const char* ProtoToString(ProtocolType proto);
+absl::optional<ProtocolType> StringToProto(absl::string_view proto_name);
+
+struct ProtocolAddress {
+ rtc::SocketAddress address;
+ ProtocolType proto;
+
+ ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p)
+ : address(a), proto(p) {}
+
+ bool operator==(const ProtocolAddress& o) const {
+ return address == o.address && proto == o.proto;
+ }
+ bool operator!=(const ProtocolAddress& o) const { return !(*this == o); }
+};
+
+struct IceCandidateErrorEvent {
+ IceCandidateErrorEvent() = default;
+ IceCandidateErrorEvent(absl::string_view address,
+ int port,
+ absl::string_view url,
+ int error_code,
+ absl::string_view error_text)
+ : address(std::move(address)),
+ port(port),
+ url(std::move(url)),
+ error_code(error_code),
+ error_text(std::move(error_text)) {}
+
+ std::string address;
+ int port = 0;
+ std::string url;
+ int error_code = 0;
+ std::string error_text;
+};
+
+struct CandidatePairChangeEvent {
+ CandidatePair selected_candidate_pair;
+ int64_t last_data_received_ms;
+ std::string reason;
+ // How long do we estimate that we've been disconnected.
+ int64_t estimated_disconnected_time_ms;
+};
+
+typedef std::set<rtc::SocketAddress> ServerAddresses;
+
+// Represents a local communication mechanism that can be used to create
+// connections to similar mechanisms of the other client. Subclasses of this
+// one add support for specific mechanisms like local UDP ports.
+class RTC_EXPORT Port : public PortInterface, public sigslot::has_slots<> {
+ public:
+ // INIT: The state when a port is just created.
+ // KEEP_ALIVE_UNTIL_PRUNED: A port should not be destroyed even if no
+ // connection is using it.
+ // PRUNED: It will be destroyed if no connection is using it for a period of
+ // 30 seconds.
+ enum class State { INIT, KEEP_ALIVE_UNTIL_PRUNED, PRUNED };
+ Port(webrtc::TaskQueueBase* thread,
+ absl::string_view type,
+ rtc::PacketSocketFactory* factory,
+ const rtc::Network* network,
+ absl::string_view username_fragment,
+ absl::string_view password,
+ const webrtc::FieldTrialsView* field_trials = nullptr);
+ Port(webrtc::TaskQueueBase* thread,
+ absl::string_view type,
+ rtc::PacketSocketFactory* factory,
+ const rtc::Network* network,
+ uint16_t min_port,
+ uint16_t max_port,
+ absl::string_view username_fragment,
+ absl::string_view password,
+ const webrtc::FieldTrialsView* field_trials = nullptr);
+ ~Port() override;
+
+ // Note that the port type does NOT uniquely identify different subclasses of
+ // Port. Use the 2-tuple of the port type AND the protocol (GetProtocol()) to
+ // uniquely identify subclasses. Whenever a new subclass of Port introduces a
+ // conflit in the value of the 2-tuple, make sure that the implementation that
+ // relies on this 2-tuple for RTTI is properly changed.
+ const std::string& Type() const override;
+ const rtc::Network* Network() const override;
+
+ // Methods to set/get ICE role and tiebreaker values.
+ IceRole GetIceRole() const override;
+ void SetIceRole(IceRole role) override;
+
+ void SetIceTiebreaker(uint64_t tiebreaker) override;
+ uint64_t IceTiebreaker() const override;
+
+ bool SharedSocket() const override;
+ void ResetSharedSocket() { shared_socket_ = false; }
+
+ // Should not destroy the port even if no connection is using it. Called when
+ // a port is ready to use.
+ void KeepAliveUntilPruned();
+ // Allows a port to be destroyed if no connection is using it.
+ void Prune();
+
+ // Call to stop any currently pending operations from running.
+ void CancelPendingTasks();
+
+ // The thread on which this port performs its I/O.
+ webrtc::TaskQueueBase* thread() { return thread_; }
+
+ // The factory used to create the sockets of this port.
+ rtc::PacketSocketFactory* socket_factory() const { return factory_; }
+
+ // For debugging purposes.
+ const std::string& content_name() const { return content_name_; }
+ void set_content_name(absl::string_view content_name) {
+ content_name_ = std::string(content_name);
+ }
+
+ int component() const { return component_; }
+ void set_component(int component) { component_ = component; }
+
+ bool send_retransmit_count_attribute() const {
+ return send_retransmit_count_attribute_;
+ }
+ void set_send_retransmit_count_attribute(bool enable) {
+ send_retransmit_count_attribute_ = enable;
+ }
+
+ // Identifies the generation that this port was created in.
+ uint32_t generation() const { return generation_; }
+ void set_generation(uint32_t generation) { generation_ = generation; }
+
+ const std::string username_fragment() const;
+ const std::string& password() const { return password_; }
+
+ // May be called when this port was initially created by a pooled
+ // PortAllocatorSession, and is now being assigned to an ICE transport.
+ // Updates the information for candidates as well.
+ void SetIceParameters(int component,
+ absl::string_view username_fragment,
+ absl::string_view password);
+
+ // Fired when candidates are discovered by the port. When all candidates
+ // are discovered that belong to port SignalAddressReady is fired.
+ sigslot::signal2<Port*, const Candidate&> SignalCandidateReady;
+ // Provides all of the above information in one handy object.
+ const std::vector<Candidate>& Candidates() const override;
+ // Fired when candidate discovery failed using certain server.
+ sigslot::signal2<Port*, const IceCandidateErrorEvent&> SignalCandidateError;
+
+ // SignalPortComplete is sent when port completes the task of candidates
+ // allocation.
+ sigslot::signal1<Port*> SignalPortComplete;
+ // This signal sent when port fails to allocate candidates and this port
+ // can't be used in establishing the connections. When port is in shared mode
+ // and port fails to allocate one of the candidates, port shouldn't send
+ // this signal as other candidates might be usefull in establishing the
+ // connection.
+ sigslot::signal1<Port*> SignalPortError;
+
+ void SubscribePortDestroyed(
+ std::function<void(PortInterface*)> callback) override;
+ void SendPortDestroyed(Port* port);
+ // Returns a map containing all of the connections of this port, keyed by the
+ // remote address.
+ typedef std::map<rtc::SocketAddress, Connection*> AddressMap;
+ const AddressMap& connections() { return connections_; }
+
+ // Returns the connection to the given address or NULL if none exists.
+ Connection* GetConnection(const rtc::SocketAddress& remote_addr) override;
+
+ // Removes and deletes a connection object. `DestroyConnection` will
+ // delete the connection object directly whereas `DestroyConnectionAsync`
+ // defers the `delete` operation to when the call stack has been unwound.
+ // Async may be needed when deleting a connection object from within a
+ // callback.
+ void DestroyConnection(Connection* conn) {
+ DestroyConnectionInternal(conn, false);
+ }
+
+ void DestroyConnectionAsync(Connection* conn) {
+ DestroyConnectionInternal(conn, true);
+ }
+
+ // In a shared socket mode each port which shares the socket will decide
+ // to accept the packet based on the `remote_addr`. Currently only UDP
+ // port implemented this method.
+ // TODO(mallinath) - Make it pure virtual.
+ virtual bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+ const char* data,
+ size_t size,
+ const rtc::SocketAddress& remote_addr,
+ int64_t packet_time_us);
+
+ // Shall the port handle packet from this `remote_addr`.
+ // This method is overridden by TurnPort.
+ virtual bool CanHandleIncomingPacketsFrom(
+ const rtc::SocketAddress& remote_addr) const;
+
+ // Sends a response error to the given request.
+ void SendBindingErrorResponse(StunMessage* message,
+ const rtc::SocketAddress& addr,
+ int error_code,
+ absl::string_view reason) override;
+ void SendUnknownAttributesErrorResponse(
+ StunMessage* message,
+ const rtc::SocketAddress& addr,
+ const std::vector<uint16_t>& unknown_types);
+
+ void set_proxy(absl::string_view user_agent, const rtc::ProxyInfo& proxy) {
+ user_agent_ = std::string(user_agent);
+ proxy_ = proxy;
+ }
+ const std::string& user_agent() { return user_agent_; }
+ const rtc::ProxyInfo& proxy() { return proxy_; }
+
+ void EnablePortPackets() override;
+
+ // Called if the port has no connections and is no longer useful.
+ void Destroy();
+
+ // Debugging description of this port
+ std::string ToString() const override;
+ uint16_t min_port() { return min_port_; }
+ uint16_t max_port() { return max_port_; }
+
+ // Timeout shortening function to speed up unit tests.
+ void set_timeout_delay(int delay);
+
+ // This method will return local and remote username fragements from the
+ // stun username attribute if present.
+ bool ParseStunUsername(const StunMessage* stun_msg,
+ std::string* local_username,
+ std::string* remote_username) const;
+ std::string CreateStunUsername(absl::string_view remote_username) const;
+
+ bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
+ IceMessage* stun_msg,
+ absl::string_view remote_ufrag);
+
+ // Called when a packet has been sent to the socket.
+ // This is made pure virtual to notify subclasses of Port that they MUST
+ // listen to AsyncPacketSocket::SignalSentPacket and then call
+ // PortInterface::OnSentPacket.
+ virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
+ const rtc::SentPacket& sent_packet) = 0;
+
+ // Called when the socket is currently able to send.
+ void OnReadyToSend();
+
+ // Called when the Connection discovers a local peer reflexive candidate.
+ void AddPrflxCandidate(const Candidate& local);
+
+ int16_t network_cost() const { return network_cost_; }
+
+ void GetStunStats(absl::optional<StunStats>* stats) override {}
+
+ // Foundation: An arbitrary string that is the same for two candidates
+ // that have the same type, base IP address, protocol (UDP, TCP,
+ // etc.), and STUN or TURN server. If any of these are different,
+ // then the foundation will be different. Two candidate pairs with
+ // the same foundation pairs are likely to have similar network
+ // characteristics. Foundations are used in the frozen algorithm.
+ std::string ComputeFoundation(absl::string_view type,
+ absl::string_view protocol,
+ absl::string_view relay_protocol,
+ const rtc::SocketAddress& base_address);
+
+ protected:
+ virtual void UpdateNetworkCost();
+
+ void set_type(absl::string_view type) { type_ = std::string(type); }
+
+ rtc::WeakPtr<Port> NewWeakPtr() { return weak_factory_.GetWeakPtr(); }
+
+ void AddAddress(const rtc::SocketAddress& address,
+ const rtc::SocketAddress& base_address,
+ const rtc::SocketAddress& related_address,
+ absl::string_view protocol,
+ absl::string_view relay_protocol,
+ absl::string_view tcptype,
+ absl::string_view type,
+ uint32_t type_preference,
+ uint32_t relay_preference,
+ absl::string_view url,
+ bool is_final);
+
+ void FinishAddingAddress(const Candidate& c, bool is_final)
+ RTC_RUN_ON(thread_);
+
+ virtual void PostAddAddress(bool is_final);
+
+ // Adds the given connection to the map keyed by the remote candidate address.
+ // If an existing connection has the same address, the existing one will be
+ // replaced and destroyed.
+ void AddOrReplaceConnection(Connection* conn);
+
+ // Called when a packet is received from an unknown address that is not
+ // currently a connection. If this is an authenticated STUN binding request,
+ // then we will signal the client.
+ void OnReadPacket(const char* data,
+ size_t size,
+ const rtc::SocketAddress& addr,
+ ProtocolType proto);
+
+ // If the given data comprises a complete and correct STUN message then the
+ // return value is true, otherwise false. If the message username corresponds
+ // with this port's username fragment, msg will contain the parsed STUN
+ // message. Otherwise, the function may send a STUN response internally.
+ // remote_username contains the remote fragment of the STUN username.
+ bool GetStunMessage(const char* data,
+ size_t size,
+ const rtc::SocketAddress& addr,
+ std::unique_ptr<IceMessage>* out_msg,
+ std::string* out_username);
+
+ // Checks if the address in addr is compatible with the port's ip.
+ bool IsCompatibleAddress(const rtc::SocketAddress& addr);
+
+ // Returns DSCP value packets generated by the port itself should use.
+ virtual rtc::DiffServCodePoint StunDscpValue() const;
+
+ // Extra work to be done in subclasses when a connection is destroyed.
+ virtual void HandleConnectionDestroyed(Connection* conn) {}
+
+ void DestroyAllConnections();
+
+ void CopyPortInformationToPacketInfo(rtc::PacketInfo* info) const;
+
+ MdnsNameRegistrationStatus mdns_name_registration_status() const {
+ return mdns_name_registration_status_;
+ }
+ void set_mdns_name_registration_status(MdnsNameRegistrationStatus status) {
+ mdns_name_registration_status_ = status;
+ }
+
+ const webrtc::FieldTrialsView& field_trials() const { return *field_trials_; }
+
+ private:
+ void Construct();
+
+ void PostDestroyIfDead(bool delayed);
+ void DestroyIfDead();
+
+ // Called internally when deleting a connection object.
+ // Returns true if the connection object was removed from the `connections_`
+ // list and the state updated accordingly. If the connection was not found
+ // in the list, the return value is false. Note that this may indicate
+ // incorrect behavior of external code that might be attempting to delete
+ // connection objects from within a 'on destroyed' callback notification
+ // for the connection object itself.
+ bool OnConnectionDestroyed(Connection* conn);
+
+ // Private implementation of DestroyConnection to keep the async usage
+ // distinct.
+ void DestroyConnectionInternal(Connection* conn, bool async);
+
+ void OnNetworkTypeChanged(const rtc::Network* network);
+
+ webrtc::TaskQueueBase* const thread_;
+ rtc::PacketSocketFactory* const factory_;
+ std::string type_;
+ bool send_retransmit_count_attribute_;
+ const rtc::Network* network_;
+ uint16_t min_port_;
+ uint16_t max_port_;
+ std::string content_name_;
+ int component_;
+ uint32_t generation_;
+ // In order to establish a connection to this Port (so that real data can be
+ // sent through), the other side must send us a STUN binding request that is
+ // authenticated with this username_fragment and password.
+ // PortAllocatorSession will provide these username_fragment and password.
+ //
+ // Note: we should always use username_fragment() instead of using
+ // `ice_username_fragment_` directly. For the details see the comment on
+ // username_fragment().
+ std::string ice_username_fragment_;
+ std::string password_;
+ std::vector<Candidate> candidates_ RTC_GUARDED_BY(thread_);
+ AddressMap connections_;
+ int timeout_delay_;
+ bool enable_port_packets_;
+ IceRole ice_role_;
+ uint64_t tiebreaker_;
+ bool shared_socket_;
+ // Information to use when going through a proxy.
+ std::string user_agent_;
+ rtc::ProxyInfo proxy_;
+
+ // A virtual cost perceived by the user, usually based on the network type
+ // (WiFi. vs. Cellular). It takes precedence over the priority when
+ // comparing two connections.
+ int16_t network_cost_;
+ State state_ = State::INIT;
+ int64_t last_time_all_connections_removed_ = 0;
+ MdnsNameRegistrationStatus mdns_name_registration_status_ =
+ MdnsNameRegistrationStatus::kNotStarted;
+
+ rtc::WeakPtrFactory<Port> weak_factory_;
+ webrtc::AlwaysValidPointer<const webrtc::FieldTrialsView,
+ webrtc::FieldTrialBasedConfig>
+ field_trials_;
+
+ bool MaybeObfuscateAddress(Candidate* c,
+ absl::string_view type,
+ bool is_final) RTC_RUN_ON(thread_);
+
+ friend class Connection;
+ webrtc::CallbackList<PortInterface*> port_destroyed_callback_list_;
+};
+
+} // namespace cricket
+
+#endif // P2P_BASE_PORT_H_