Repo created

TMessagesProj/jni/voip/webrtc/p2p/client/basic_port_allocator.h

@@ -0,0 +1,415 @@
+/*
+ *  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_CLIENT_BASIC_PORT_ALLOCATOR_H_
+#define P2P_CLIENT_BASIC_PORT_ALLOCATOR_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "api/field_trials_view.h"
+#include "api/task_queue/pending_task_safety_flag.h"
+#include "api/turn_customizer.h"
+#include "p2p/base/port_allocator.h"
+#include "p2p/client/relay_port_factory_interface.h"
+#include "p2p/client/turn_port_factory.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/memory/always_valid_pointer.h"
+#include "rtc_base/network.h"
+#include "rtc_base/network/received_packet.h"
+#include "rtc_base/system/rtc_export.h"
+#include "rtc_base/thread.h"
+#include "rtc_base/thread_annotations.h"
+
+namespace cricket {
+
+class RTC_EXPORT BasicPortAllocator : public PortAllocator {
+ public:
+  // The NetworkManager is a mandatory argument. The other arguments are
+  // optional. All pointers are owned by caller and must have a life time
+  // that exceeds that of BasicPortAllocator.
+  BasicPortAllocator(rtc::NetworkManager* network_manager,
+                     rtc::PacketSocketFactory* socket_factory,
+                     webrtc::TurnCustomizer* customizer = nullptr,
+                     RelayPortFactoryInterface* relay_port_factory = nullptr,
+                     const webrtc::FieldTrialsView* field_trials = nullptr);
+  BasicPortAllocator(rtc::NetworkManager* network_manager,
+                     rtc::PacketSocketFactory* socket_factory,
+                     const ServerAddresses& stun_servers,
+                     const webrtc::FieldTrialsView* field_trials = nullptr);
+  ~BasicPortAllocator() override;
+
+  // Set to kDefaultNetworkIgnoreMask by default.
+  void SetNetworkIgnoreMask(int network_ignore_mask) override;
+  int GetNetworkIgnoreMask() const;
+
+  rtc::NetworkManager* network_manager() const {
+    CheckRunOnValidThreadIfInitialized();
+    return network_manager_;
+  }
+
+  // If socket_factory() is set to NULL each PortAllocatorSession
+  // creates its own socket factory.
+  rtc::PacketSocketFactory* socket_factory() {
+    CheckRunOnValidThreadIfInitialized();
+    return socket_factory_;
+  }
+
+  PortAllocatorSession* CreateSessionInternal(
+      absl::string_view content_name,
+      int component,
+      absl::string_view ice_ufrag,
+      absl::string_view ice_pwd) override;
+
+  // Convenience method that adds a TURN server to the configuration.
+  void AddTurnServerForTesting(const RelayServerConfig& turn_server);
+
+  RelayPortFactoryInterface* relay_port_factory() {
+    CheckRunOnValidThreadIfInitialized();
+    return relay_port_factory_;
+  }
+
+  void SetVpnList(const std::vector<rtc::NetworkMask>& vpn_list) override;
+
+  const webrtc::FieldTrialsView* field_trials() const {
+    return field_trials_.get();
+  }
+
+ private:
+  bool MdnsObfuscationEnabled() const override;
+
+  webrtc::AlwaysValidPointer<const webrtc::FieldTrialsView,
+                             webrtc::FieldTrialBasedConfig>
+      field_trials_;
+  rtc::NetworkManager* network_manager_;
+  // Always externally-owned pointer to a socket factory.
+  rtc::PacketSocketFactory* const socket_factory_;
+  int network_ignore_mask_ = rtc::kDefaultNetworkIgnoreMask;
+
+  // This instance is created if caller does pass a factory.
+  const std::unique_ptr<RelayPortFactoryInterface> default_relay_port_factory_;
+  // This is the factory being used.
+  RelayPortFactoryInterface* const relay_port_factory_;
+};
+
+struct PortConfiguration;
+class AllocationSequence;
+
+enum class SessionState {
+  GATHERING,  // Actively allocating ports and gathering candidates.
+  CLEARED,    // Current allocation process has been stopped but may start
+              // new ones.
+  STOPPED     // This session has completely stopped, no new allocation
+              // process will be started.
+};
+
+// This class is thread-compatible and assumes it's created, operated upon and
+// destroyed on the network thread.
+class RTC_EXPORT BasicPortAllocatorSession : public PortAllocatorSession {
+ public:
+  BasicPortAllocatorSession(BasicPortAllocator* allocator,
+                            absl::string_view content_name,
+                            int component,
+                            absl::string_view ice_ufrag,
+                            absl::string_view ice_pwd);
+  ~BasicPortAllocatorSession() override;
+
+  virtual BasicPortAllocator* allocator();
+  rtc::Thread* network_thread() { return network_thread_; }
+  rtc::PacketSocketFactory* socket_factory() { return socket_factory_; }
+
+  // If the new filter allows new types of candidates compared to the previous
+  // filter, gathered candidates that were discarded because of not matching the
+  // previous filter will be signaled if they match the new one.
+  //
+  // We do not perform any regathering since the port allocator flags decide
+  // the type of candidates to gather and the candidate filter only controls the
+  // signaling of candidates. As a result, with the candidate filter changed
+  // alone, all newly allowed candidates for signaling should already be
+  // gathered by the respective cricket::Port.
+  void SetCandidateFilter(uint32_t filter) override;
+  void StartGettingPorts() override;
+  void StopGettingPorts() override;
+  void ClearGettingPorts() override;
+  bool IsGettingPorts() override;
+  bool IsCleared() const override;
+  bool IsStopped() const override;
+  // These will all be cricket::Ports.
+  std::vector<PortInterface*> ReadyPorts() const override;
+  std::vector<Candidate> ReadyCandidates() const override;
+  bool CandidatesAllocationDone() const override;
+  void RegatherOnFailedNetworks() override;
+  void GetCandidateStatsFromReadyPorts(
+      CandidateStatsList* candidate_stats_list) const override;
+  void SetStunKeepaliveIntervalForReadyPorts(
+      const absl::optional<int>& stun_keepalive_interval) override;
+  void PruneAllPorts() override;
+  static std::vector<const rtc::Network*> SelectIPv6Networks(
+      std::vector<const rtc::Network*>& all_ipv6_networks,
+      int max_ipv6_networks);
+
+ protected:
+  void UpdateIceParametersInternal() override;
+
+  // Starts the process of getting the port configurations.
+  virtual void GetPortConfigurations();
+
+  // Adds a port configuration that is now ready.  Once we have one for each
+  // network (or a timeout occurs), we will start allocating ports.
+  void ConfigReady(std::unique_ptr<PortConfiguration> config);
+  // TODO(bugs.webrtc.org/12840) Remove once unused in downstream projects.
+  ABSL_DEPRECATED(
+      "Use ConfigReady(std::unique_ptr<PortConfiguration>) instead!")
+  void ConfigReady(PortConfiguration* config);
+
+ private:
+  class PortData {
+   public:
+    enum State {
+      STATE_INPROGRESS,  // Still gathering candidates.
+      STATE_COMPLETE,    // All candidates allocated and ready for process.
+      STATE_ERROR,       // Error in gathering candidates.
+      STATE_PRUNED       // Pruned by higher priority ports on the same network
+                         // interface. Only TURN ports may be pruned.
+    };
+
+    PortData() {}
+    PortData(Port* port, AllocationSequence* seq)
+        : port_(port), sequence_(seq) {}
+
+    Port* port() const { return port_; }
+    AllocationSequence* sequence() const { return sequence_; }
+    bool has_pairable_candidate() const { return has_pairable_candidate_; }
+    State state() const { return state_; }
+    bool complete() const { return state_ == STATE_COMPLETE; }
+    bool error() const { return state_ == STATE_ERROR; }
+    bool pruned() const { return state_ == STATE_PRUNED; }
+    bool inprogress() const { return state_ == STATE_INPROGRESS; }
+    // Returns true if this port is ready to be used.
+    bool ready() const {
+      return has_pairable_candidate_ && state_ != STATE_ERROR &&
+             state_ != STATE_PRUNED;
+    }
+    // Sets the state to "PRUNED" and prunes the Port.
+    void Prune() {
+      state_ = STATE_PRUNED;
+      if (port()) {
+        port()->Prune();
+      }
+    }
+    void set_has_pairable_candidate(bool has_pairable_candidate) {
+      if (has_pairable_candidate) {
+        RTC_DCHECK(state_ == STATE_INPROGRESS);
+      }
+      has_pairable_candidate_ = has_pairable_candidate;
+    }
+    void set_state(State state) {
+      RTC_DCHECK(state != STATE_ERROR || state_ == STATE_INPROGRESS);
+      state_ = state;
+    }
+
+   private:
+    Port* port_ = nullptr;
+    AllocationSequence* sequence_ = nullptr;
+    bool has_pairable_candidate_ = false;
+    State state_ = STATE_INPROGRESS;
+  };
+
+  void OnConfigReady(std::unique_ptr<PortConfiguration> config);
+  void OnConfigStop();
+  void AllocatePorts();
+  void OnAllocate(int allocation_epoch);
+  void DoAllocate(bool disable_equivalent_phases);
+  void OnNetworksChanged();
+  void OnAllocationSequenceObjectsCreated();
+  void DisableEquivalentPhases(const rtc::Network* network,
+                               PortConfiguration* config,
+                               uint32_t* flags);
+  void AddAllocatedPort(Port* port, AllocationSequence* seq);
+  void OnCandidateReady(Port* port, const Candidate& c);
+  void OnCandidateError(Port* port, const IceCandidateErrorEvent& event);
+  void OnPortComplete(Port* port);
+  void OnPortError(Port* port);
+  void OnProtocolEnabled(AllocationSequence* seq, ProtocolType proto);
+  void OnPortDestroyed(PortInterface* port);
+  void MaybeSignalCandidatesAllocationDone();
+  void OnPortAllocationComplete();
+  PortData* FindPort(Port* port);
+  std::vector<const rtc::Network*> GetNetworks();
+  std::vector<const rtc::Network*> GetFailedNetworks();
+  void Regather(const std::vector<const rtc::Network*>& networks,
+                bool disable_equivalent_phases,
+                IceRegatheringReason reason);
+
+  bool CheckCandidateFilter(const Candidate& c) const;
+  bool CandidatePairable(const Candidate& c, const Port* port) const;
+
+  std::vector<PortData*> GetUnprunedPorts(
+      const std::vector<const rtc::Network*>& networks);
+  // Prunes ports and signal the remote side to remove the candidates that
+  // were previously signaled from these ports.
+  void PrunePortsAndRemoveCandidates(
+      const std::vector<PortData*>& port_data_list);
+  // Gets filtered and sanitized candidates generated from a port and
+  // append to `candidates`.
+  void GetCandidatesFromPort(const PortData& data,
+                             std::vector<Candidate>* candidates) const;
+  Port* GetBestTurnPortForNetwork(absl::string_view network_name) const;
+  // Returns true if at least one TURN port is pruned.
+  bool PruneTurnPorts(Port* newly_pairable_turn_port);
+  bool PruneNewlyPairableTurnPort(PortData* newly_pairable_turn_port);
+
+  BasicPortAllocator* allocator_;
+  rtc::Thread* network_thread_;
+  rtc::PacketSocketFactory* socket_factory_;
+  bool allocation_started_;
+  bool network_manager_started_;
+  bool allocation_sequences_created_;
+  std::vector<std::unique_ptr<PortConfiguration>> configs_;
+  std::vector<AllocationSequence*> sequences_;
+  std::vector<PortData> ports_;
+  std::vector<IceCandidateErrorEvent> candidate_error_events_;
+  uint32_t candidate_filter_ = CF_ALL;
+  // Policy on how to prune turn ports, taken from the port allocator.
+  webrtc::PortPrunePolicy turn_port_prune_policy_;
+  SessionState state_ = SessionState::CLEARED;
+  int allocation_epoch_ RTC_GUARDED_BY(network_thread_) = 0;
+  webrtc::ScopedTaskSafety network_safety_;
+
+  friend class AllocationSequence;
+};
+
+// Records configuration information useful in creating ports.
+// TODO(deadbeef): Rename "relay" to "turn_server" in this struct.
+struct RTC_EXPORT PortConfiguration {
+  // TODO(jiayl): remove `stun_address` when Chrome is updated.
+  rtc::SocketAddress stun_address;
+  ServerAddresses stun_servers;
+  std::string username;
+  std::string password;
+  bool use_turn_server_as_stun_server_disabled = false;
+
+  typedef std::vector<RelayServerConfig> RelayList;
+  RelayList relays;
+
+  PortConfiguration(const ServerAddresses& stun_servers,
+                    absl::string_view username,
+                    absl::string_view password,
+                    const webrtc::FieldTrialsView* field_trials = nullptr);
+
+  // Returns addresses of both the explicitly configured STUN servers,
+  // and TURN servers that should be used as STUN servers.
+  ServerAddresses StunServers();
+
+  // Adds another relay server, with the given ports and modifier, to the list.
+  void AddRelay(const RelayServerConfig& config);
+
+  // Determines whether the given relay server supports the given protocol.
+  bool SupportsProtocol(const RelayServerConfig& relay,
+                        ProtocolType type) const;
+  bool SupportsProtocol(ProtocolType type) const;
+  // Helper method returns the server addresses for the matching RelayType and
+  // Protocol type.
+  ServerAddresses GetRelayServerAddresses(ProtocolType type) const;
+};
+
+class UDPPort;
+class TurnPort;
+
+// Performs the allocation of ports, in a sequenced (timed) manner, for a given
+// network and IP address.
+// This class is thread-compatible.
+class AllocationSequence {
+ public:
+  enum State {
+    kInit,       // Initial state.
+    kRunning,    // Started allocating ports.
+    kStopped,    // Stopped from running.
+    kCompleted,  // All ports are allocated.
+
+    // kInit --> kRunning --> {kCompleted|kStopped}
+  };
+  // `port_allocation_complete_callback` is called when AllocationSequence is
+  // done with allocating ports. This signal is useful when port allocation
+  // fails which doesn't result in any candidates. Using this signal
+  // BasicPortAllocatorSession can send its candidate discovery conclusion
+  // signal. Without this signal, BasicPortAllocatorSession doesn't have any
+  // event to trigger signal. This can also be achieved by starting a timer in
+  // BPAS, but this is less deterministic.
+  AllocationSequence(BasicPortAllocatorSession* session,
+                     const rtc::Network* network,
+                     PortConfiguration* config,
+                     uint32_t flags,
+                     std::function<void()> port_allocation_complete_callback);
+  void Init();
+  void Clear();
+  void OnNetworkFailed();
+
+  State state() const { return state_; }
+  const rtc::Network* network() const { return network_; }
+
+  bool network_failed() const { return network_failed_; }
+  void set_network_failed() { network_failed_ = true; }
+
+  // Disables the phases for a new sequence that this one already covers for an
+  // equivalent network setup.
+  void DisableEquivalentPhases(const rtc::Network* network,
+                               PortConfiguration* config,
+                               uint32_t* flags);
+
+  // Starts and stops the sequence.  When started, it will continue allocating
+  // new ports on its own timed schedule.
+  void Start();
+  void Stop();
+
+ private:
+  void CreateTurnPort(const RelayServerConfig& config, int relative_priority);
+
+  typedef std::vector<ProtocolType> ProtocolList;
+
+  void Process(int epoch);
+  bool IsFlagSet(uint32_t flag) { return ((flags_ & flag) != 0); }
+  void CreateUDPPorts();
+  void CreateTCPPorts();
+  void CreateStunPorts();
+  void CreateRelayPorts();
+
+  void OnReadPacket(rtc::AsyncPacketSocket* socket,
+                    const rtc::ReceivedPacket& packet);
+
+  void OnPortDestroyed(PortInterface* port);
+
+  BasicPortAllocatorSession* session_;
+  bool network_failed_ = false;
+  const rtc::Network* network_;
+  // Compared with the new best IP in DisableEquivalentPhases.
+  rtc::IPAddress previous_best_ip_;
+  PortConfiguration* config_;
+  State state_;
+  uint32_t flags_;
+  ProtocolList protocols_;
+  std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_;
+  // There will be only one udp port per AllocationSequence.
+  UDPPort* udp_port_;
+  std::vector<Port*> relay_ports_;
+  int phase_;
+  std::function<void()> port_allocation_complete_callback_;
+  // This counter is sampled and passed together with tasks when tasks are
+  // posted. If the sampled counter doesn't match `epoch_` on reception, the
+  // posted task is ignored.
+  int epoch_ = 0;
+  webrtc::ScopedTaskSafety safety_;
+};
+
+}  // namespace cricket
+
+#endif  // P2P_CLIENT_BASIC_PORT_ALLOCATOR_H_

TMessagesProj/jni/voip/webrtc/p2p/client/relay_port_factory_interface.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright 2017 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_CLIENT_RELAY_PORT_FACTORY_INTERFACE_H_
+#define P2P_CLIENT_RELAY_PORT_FACTORY_INTERFACE_H_
+
+#include <memory>
+#include <string>
+
+#include "p2p/base/port_interface.h"
+#include "rtc_base/ref_count.h"
+
+namespace rtc {
+class AsyncPacketSocket;
+class Network;
+class PacketSocketFactory;
+class Thread;
+}  // namespace rtc
+
+namespace webrtc {
+class TurnCustomizer;
+class FieldTrialsView;
+}  // namespace webrtc
+
+namespace cricket {
+class Port;
+struct ProtocolAddress;
+struct RelayServerConfig;
+
+// A struct containing arguments to RelayPortFactory::Create()
+struct CreateRelayPortArgs {
+  rtc::Thread* network_thread;
+  rtc::PacketSocketFactory* socket_factory;
+  const rtc::Network* network;
+  const ProtocolAddress* server_address;
+  const RelayServerConfig* config;
+  std::string username;
+  std::string password;
+  webrtc::TurnCustomizer* turn_customizer = nullptr;
+  const webrtc::FieldTrialsView* field_trials = nullptr;
+  // Relative priority of candidates from this TURN server in relation
+  // to the candidates from other servers. Required because ICE priorities
+  // need to be unique.
+  int relative_priority = 0;
+};
+
+// A factory for creating RelayPort's.
+class RelayPortFactoryInterface {
+ public:
+  virtual ~RelayPortFactoryInterface() {}
+
+  // This variant is used for UDP connection to the relay server
+  // using a already existing shared socket.
+  virtual std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
+                                       rtc::AsyncPacketSocket* udp_socket) = 0;
+
+  // This variant is used for the other cases.
+  virtual std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
+                                       int min_port,
+                                       int max_port) = 0;
+};
+
+}  // namespace cricket
+
+#endif  // P2P_CLIENT_RELAY_PORT_FACTORY_INTERFACE_H_

TMessagesProj/jni/voip/webrtc/p2p/client/turn_port_factory.cc

@@ -0,0 +1,45 @@
+/*
+ *  Copyright 2017 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 "p2p/client/turn_port_factory.h"
+
+#include <memory>
+#include <utility>
+
+#include "p2p/base/port_allocator.h"
+#include "p2p/base/turn_port.h"
+
+namespace cricket {
+
+TurnPortFactory::~TurnPortFactory() {}
+
+std::unique_ptr<Port> TurnPortFactory::Create(
+    const CreateRelayPortArgs& args,
+    rtc::AsyncPacketSocket* udp_socket) {
+  auto port = TurnPort::Create(args, udp_socket);
+  if (!port)
+    return nullptr;
+  port->SetTlsCertPolicy(args.config->tls_cert_policy);
+  port->SetTurnLoggingId(args.config->turn_logging_id);
+  return std::move(port);
+}
+
+std::unique_ptr<Port> TurnPortFactory::Create(const CreateRelayPortArgs& args,
+                                              int min_port,
+                                              int max_port) {
+  auto port = TurnPort::Create(args, min_port, max_port);
+  if (!port)
+    return nullptr;
+  port->SetTlsCertPolicy(args.config->tls_cert_policy);
+  port->SetTurnLoggingId(args.config->turn_logging_id);
+  return std::move(port);
+}
+
+}  // namespace cricket

TMessagesProj/jni/voip/webrtc/p2p/client/turn_port_factory.h

@@ -0,0 +1,37 @@
+/*
+ *  Copyright 2017 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_CLIENT_TURN_PORT_FACTORY_H_
+#define P2P_CLIENT_TURN_PORT_FACTORY_H_
+
+#include <memory>
+
+#include "p2p/base/port.h"
+#include "p2p/client/relay_port_factory_interface.h"
+#include "rtc_base/async_packet_socket.h"
+
+namespace cricket {
+
+// This is a RelayPortFactory that produces TurnPorts.
+class TurnPortFactory : public RelayPortFactoryInterface {
+ public:
+  ~TurnPortFactory() override;
+
+  std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
+                               rtc::AsyncPacketSocket* udp_socket) override;
+
+  std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
+                               int min_port,
+                               int max_port) override;
+};
+
+}  // namespace cricket
+
+#endif  // P2P_CLIENT_TURN_PORT_FACTORY_H_