| /* | |
| * 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 "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/network.h" | |
| #include "rtc_base/system/rtc_export.h" | |
| #include "rtc_base/thread.h" | |
| namespace cricket { | |
| class RTC_EXPORT BasicPortAllocator : public PortAllocator { | |
| public: | |
| // note: The (optional) relay_port_factory is 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); | |
| explicit BasicPortAllocator(rtc::NetworkManager* network_manager); | |
| BasicPortAllocator(rtc::NetworkManager* network_manager, | |
| const ServerAddresses& stun_servers); | |
| BasicPortAllocator(rtc::NetworkManager* network_manager, | |
| rtc::PacketSocketFactory* socket_factory, | |
| const ServerAddresses& stun_servers); | |
| ~BasicPortAllocator() override; | |
| // Set to kDefaultNetworkIgnoreMask by default. | |
| void SetNetworkIgnoreMask(int network_ignore_mask) override; | |
| int network_ignore_mask() const { | |
| CheckRunOnValidThreadIfInitialized(); | |
| return network_ignore_mask_; | |
| } | |
| 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( | |
| const std::string& content_name, | |
| int component, | |
| const std::string& ice_ufrag, | |
| const std::string& ice_pwd) override; | |
| // Convenience method that adds a TURN server to the configuration. | |
| void AddTurnServer(const RelayServerConfig& turn_server); | |
| RelayPortFactoryInterface* relay_port_factory() { | |
| CheckRunOnValidThreadIfInitialized(); | |
| return relay_port_factory_; | |
| } | |
| private: | |
| void OnIceRegathering(PortAllocatorSession* session, | |
| IceRegatheringReason reason); | |
| // This function makes sure that relay_port_factory_ is set properly. | |
| void InitRelayPortFactory(RelayPortFactoryInterface* relay_port_factory); | |
| bool MdnsObfuscationEnabled() const override; | |
| rtc::NetworkManager* network_manager_; | |
| rtc::PacketSocketFactory* socket_factory_; | |
| int network_ignore_mask_ = rtc::kDefaultNetworkIgnoreMask; | |
| // This is the factory being used. | |
| RelayPortFactoryInterface* relay_port_factory_; | |
| // This instance is created if caller does pass a factory. | |
| std::unique_ptr<RelayPortFactoryInterface> default_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. | |
| }; | |
| class RTC_EXPORT BasicPortAllocatorSession : public PortAllocatorSession, | |
| public rtc::MessageHandler { | |
| public: | |
| BasicPortAllocatorSession(BasicPortAllocator* allocator, | |
| const std::string& content_name, | |
| int component, | |
| const std::string& ice_ufrag, | |
| const std::string& 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; | |
| 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. | |
| virtual void ConfigReady(PortConfiguration* config); | |
| // MessageHandler. Can be overriden if message IDs do not conflict. | |
| void OnMessage(rtc::Message* message) override; | |
| 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(PortConfiguration* config); | |
| void OnConfigStop(); | |
| void AllocatePorts(); | |
| void OnAllocate(); | |
| void DoAllocate(bool disable_equivalent_phases); | |
| void OnNetworksChanged(); | |
| void OnAllocationSequenceObjectsCreated(); | |
| void DisableEquivalentPhases(rtc::Network* network, | |
| PortConfiguration* config, | |
| uint32_t* flags); | |
| void AddAllocatedPort(Port* port, | |
| AllocationSequence* seq, | |
| bool prepare_address); | |
| 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(AllocationSequence* seq); | |
| PortData* FindPort(Port* port); | |
| std::vector<rtc::Network*> GetNetworks(); | |
| std::vector<rtc::Network*> GetFailedNetworks(); | |
| void Regather(const std::vector<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<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(const std::string& 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_; | |
| std::unique_ptr<rtc::PacketSocketFactory> owned_socket_factory_; | |
| rtc::PacketSocketFactory* socket_factory_; | |
| bool allocation_started_; | |
| bool network_manager_started_; | |
| bool allocation_sequences_created_; | |
| std::vector<PortConfiguration*> configs_; | |
| std::vector<AllocationSequence*> sequences_; | |
| std::vector<PortData> ports_; | |
| 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; | |
| friend class AllocationSequence; | |
| }; | |
| // Records configuration information useful in creating ports. | |
| // TODO(deadbeef): Rename "relay" to "turn_server" in this struct. | |
| struct RTC_EXPORT PortConfiguration : public rtc::MessageData { | |
| // 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; | |
| // TODO(jiayl): remove this ctor when Chrome is updated. | |
| PortConfiguration(const rtc::SocketAddress& stun_address, | |
| const std::string& username, | |
| const std::string& password); | |
| PortConfiguration(const ServerAddresses& stun_servers, | |
| const std::string& username, | |
| const std::string& password); | |
| ~PortConfiguration() override; | |
| // 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. | |
| class AllocationSequence : public rtc::MessageHandler, | |
| public sigslot::has_slots<> { | |
| public: | |
| enum State { | |
| kInit, // Initial state. | |
| kRunning, // Started allocating ports. | |
| kStopped, // Stopped from running. | |
| kCompleted, // All ports are allocated. | |
| // kInit --> kRunning --> {kCompleted|kStopped} | |
| }; | |
| AllocationSequence(BasicPortAllocatorSession* session, | |
| rtc::Network* network, | |
| PortConfiguration* config, | |
| uint32_t flags); | |
| ~AllocationSequence() override; | |
| void Init(); | |
| void Clear(); | |
| void OnNetworkFailed(); | |
| State state() const { return state_; } | |
| 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(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(); | |
| // MessageHandler | |
| void OnMessage(rtc::Message* msg) override; | |
| // Signal from AllocationSequence, when it's 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 timer in BPAS. | |
| sigslot::signal1<AllocationSequence*> SignalPortAllocationComplete; | |
| protected: | |
| // For testing. | |
| void CreateTurnPort(const RelayServerConfig& config); | |
| private: | |
| typedef std::vector<ProtocolType> ProtocolList; | |
| bool IsFlagSet(uint32_t flag) { return ((flags_ & flag) != 0); } | |
| void CreateUDPPorts(); | |
| void CreateTCPPorts(); | |
| void CreateStunPorts(); | |
| void CreateRelayPorts(); | |
| void OnReadPacket(rtc::AsyncPacketSocket* socket, | |
| const char* data, | |
| size_t size, | |
| const rtc::SocketAddress& remote_addr, | |
| const int64_t& packet_time_us); | |
| void OnPortDestroyed(PortInterface* port); | |
| BasicPortAllocatorSession* session_; | |
| bool network_failed_ = false; | |
| 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_; | |
| }; | |
| } // namespace cricket | |
| #endif // P2P_CLIENT_BASIC_PORT_ALLOCATOR_H_ |