| /* | |
| * 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_STUN_PORT_H_ | |
| #define P2P_BASE_STUN_PORT_H_ | |
| #include <functional> | |
| #include <map> | |
| #include <memory> | |
| #include <string> | |
| #include "absl/memory/memory.h" | |
| #include "absl/strings/string_view.h" | |
| #include "api/task_queue/pending_task_safety_flag.h" | |
| #include "p2p/base/port.h" | |
| #include "p2p/base/stun_request.h" | |
| #include "rtc_base/async_packet_socket.h" | |
| namespace cricket { | |
| // Lifetime chosen for STUN ports on low-cost networks. | |
| static const int INFINITE_LIFETIME = -1; | |
| // Lifetime for STUN ports on high-cost networks: 2 minutes | |
| static const int HIGH_COST_PORT_KEEPALIVE_LIFETIME = 2 * 60 * 1000; | |
| // Communicates using the address on the outside of a NAT. | |
| class UDPPort : public Port { | |
| public: | |
| static std::unique_ptr<UDPPort> Create( | |
| rtc::Thread* thread, | |
| rtc::PacketSocketFactory* factory, | |
| const rtc::Network* network, | |
| rtc::AsyncPacketSocket* socket, | |
| absl::string_view username, | |
| absl::string_view password, | |
| bool emit_local_for_anyaddress, | |
| absl::optional<int> stun_keepalive_interval, | |
| const webrtc::FieldTrialsView* field_trials = nullptr) { | |
| // Using `new` to access a non-public constructor. | |
| auto port = absl::WrapUnique( | |
| new UDPPort(thread, factory, network, socket, username, password, | |
| emit_local_for_anyaddress, field_trials)); | |
| port->set_stun_keepalive_delay(stun_keepalive_interval); | |
| if (!port->Init()) { | |
| return nullptr; | |
| } | |
| return port; | |
| } | |
| static std::unique_ptr<UDPPort> Create( | |
| rtc::Thread* thread, | |
| rtc::PacketSocketFactory* factory, | |
| const rtc::Network* network, | |
| uint16_t min_port, | |
| uint16_t max_port, | |
| absl::string_view username, | |
| absl::string_view password, | |
| bool emit_local_for_anyaddress, | |
| absl::optional<int> stun_keepalive_interval, | |
| const webrtc::FieldTrialsView* field_trials = nullptr) { | |
| // Using `new` to access a non-public constructor. | |
| auto port = absl::WrapUnique( | |
| new UDPPort(thread, factory, network, min_port, max_port, username, | |
| password, emit_local_for_anyaddress, field_trials)); | |
| port->set_stun_keepalive_delay(stun_keepalive_interval); | |
| if (!port->Init()) { | |
| return nullptr; | |
| } | |
| return port; | |
| } | |
| ~UDPPort() override; | |
| rtc::SocketAddress GetLocalAddress() const { | |
| return socket_->GetLocalAddress(); | |
| } | |
| const ServerAddresses& server_addresses() const { return server_addresses_; } | |
| void set_server_addresses(const ServerAddresses& addresses) { | |
| server_addresses_ = addresses; | |
| } | |
| void PrepareAddress() override; | |
| Connection* CreateConnection(const Candidate& address, | |
| CandidateOrigin origin) override; | |
| int SetOption(rtc::Socket::Option opt, int value) override; | |
| int GetOption(rtc::Socket::Option opt, int* value) override; | |
| int GetError() override; | |
| bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket, | |
| const char* data, | |
| size_t size, | |
| const rtc::SocketAddress& remote_addr, | |
| int64_t packet_time_us) override; | |
| bool SupportsProtocol(absl::string_view protocol) const override; | |
| ProtocolType GetProtocol() const override; | |
| void GetStunStats(absl::optional<StunStats>* stats) override; | |
| void set_stun_keepalive_delay(const absl::optional<int>& delay); | |
| int stun_keepalive_delay() const { return stun_keepalive_delay_; } | |
| // Visible for testing. | |
| int stun_keepalive_lifetime() const { return stun_keepalive_lifetime_; } | |
| void set_stun_keepalive_lifetime(int lifetime) { | |
| stun_keepalive_lifetime_ = lifetime; | |
| } | |
| StunRequestManager& request_manager() { return request_manager_; } | |
| protected: | |
| UDPPort(rtc::Thread* thread, | |
| rtc::PacketSocketFactory* factory, | |
| const rtc::Network* network, | |
| uint16_t min_port, | |
| uint16_t max_port, | |
| absl::string_view username, | |
| absl::string_view password, | |
| bool emit_local_for_anyaddress, | |
| const webrtc::FieldTrialsView* field_trials); | |
| UDPPort(rtc::Thread* thread, | |
| rtc::PacketSocketFactory* factory, | |
| const rtc::Network* network, | |
| rtc::AsyncPacketSocket* socket, | |
| absl::string_view username, | |
| absl::string_view password, | |
| bool emit_local_for_anyaddress, | |
| const webrtc::FieldTrialsView* field_trials); | |
| bool Init(); | |
| int SendTo(const void* data, | |
| size_t size, | |
| const rtc::SocketAddress& addr, | |
| const rtc::PacketOptions& options, | |
| bool payload) override; | |
| void UpdateNetworkCost() override; | |
| rtc::DiffServCodePoint StunDscpValue() const override; | |
| void OnLocalAddressReady(rtc::AsyncPacketSocket* socket, | |
| const rtc::SocketAddress& address); | |
| void PostAddAddress(bool is_final) override; | |
| void OnReadPacket(rtc::AsyncPacketSocket* socket, | |
| const char* data, | |
| size_t size, | |
| const rtc::SocketAddress& remote_addr, | |
| const int64_t& packet_time_us); | |
| void OnSentPacket(rtc::AsyncPacketSocket* socket, | |
| const rtc::SentPacket& sent_packet) override; | |
| void OnReadyToSend(rtc::AsyncPacketSocket* socket); | |
| // This method will send STUN binding request if STUN server address is set. | |
| void MaybePrepareStunCandidate(); | |
| void SendStunBindingRequests(); | |
| // Helper function which will set `addr`'s IP to the default local address if | |
| // `addr` is the "any" address and `emit_local_for_anyaddress_` is true. When | |
| // returning false, it indicates that the operation has failed and the | |
| // address shouldn't be used by any candidate. | |
| bool MaybeSetDefaultLocalAddress(rtc::SocketAddress* addr) const; | |
| private: | |
| // A helper class which can be called repeatedly to resolve multiple | |
| // addresses, as opposed to rtc::AsyncDnsResolverInterface, which can only | |
| // resolve one address per instance. | |
| class AddressResolver { | |
| public: | |
| explicit AddressResolver( | |
| rtc::PacketSocketFactory* factory, | |
| std::function<void(const rtc::SocketAddress&, int)> done_callback); | |
| void Resolve(const rtc::SocketAddress& address, | |
| int family, | |
| const webrtc::FieldTrialsView& field_trials); | |
| bool GetResolvedAddress(const rtc::SocketAddress& input, | |
| int family, | |
| rtc::SocketAddress* output) const; | |
| private: | |
| typedef std::map<rtc::SocketAddress, | |
| std::unique_ptr<webrtc::AsyncDnsResolverInterface>> | |
| ResolverMap; | |
| rtc::PacketSocketFactory* socket_factory_; | |
| // The function is called when resolving the specified address is finished. | |
| // The first argument is the input address, the second argument is the error | |
| // or 0 if it succeeded. | |
| std::function<void(const rtc::SocketAddress&, int)> done_; | |
| // Resolver may fire callbacks that refer to done_, so ensure | |
| // that all resolvers are destroyed first. | |
| ResolverMap resolvers_; | |
| }; | |
| // DNS resolution of the STUN server. | |
| void ResolveStunAddress(const rtc::SocketAddress& stun_addr); | |
| void OnResolveResult(const rtc::SocketAddress& input, int error); | |
| // Send a STUN binding request to the given address. Calling this method may | |
| // cause the set of known server addresses to be modified, eg. by replacing an | |
| // unresolved server address with a resolved address. | |
| void SendStunBindingRequest(const rtc::SocketAddress& stun_addr); | |
| // Below methods handles binding request responses. | |
| void OnStunBindingRequestSucceeded( | |
| int rtt_ms, | |
| const rtc::SocketAddress& stun_server_addr, | |
| const rtc::SocketAddress& stun_reflected_addr); | |
| void OnStunBindingOrResolveRequestFailed( | |
| const rtc::SocketAddress& stun_server_addr, | |
| int error_code, | |
| absl::string_view reason); | |
| // Sends STUN requests to the server. | |
| void OnSendPacket(const void* data, size_t size, StunRequest* req); | |
| // TODO(mallinaht) - Move this up to cricket::Port when SignalAddressReady is | |
| // changed to SignalPortReady. | |
| void MaybeSetPortCompleteOrError(); | |
| bool HasCandidateWithAddress(const rtc::SocketAddress& addr) const; | |
| // If this is a low-cost network, it will keep on sending STUN binding | |
| // requests indefinitely to keep the NAT binding alive. Otherwise, stop | |
| // sending STUN binding requests after HIGH_COST_PORT_KEEPALIVE_LIFETIME. | |
| int GetStunKeepaliveLifetime() { | |
| return (network_cost() >= rtc::kNetworkCostHigh) | |
| ? HIGH_COST_PORT_KEEPALIVE_LIFETIME | |
| : INFINITE_LIFETIME; | |
| } | |
| ServerAddresses server_addresses_; | |
| ServerAddresses bind_request_succeeded_servers_; | |
| ServerAddresses bind_request_failed_servers_; | |
| StunRequestManager request_manager_; | |
| rtc::AsyncPacketSocket* socket_; | |
| int error_; | |
| int send_error_count_ = 0; | |
| std::unique_ptr<AddressResolver> resolver_; | |
| bool ready_; | |
| int stun_keepalive_delay_; | |
| int stun_keepalive_lifetime_ = INFINITE_LIFETIME; | |
| rtc::DiffServCodePoint dscp_; | |
| StunStats stats_; | |
| // This is true by default and false when | |
| // PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE is specified. | |
| bool emit_local_for_anyaddress_; | |
| friend class StunBindingRequest; | |
| }; | |
| class StunPort : public UDPPort { | |
| public: | |
| static std::unique_ptr<StunPort> Create( | |
| rtc::Thread* thread, | |
| rtc::PacketSocketFactory* factory, | |
| const rtc::Network* network, | |
| uint16_t min_port, | |
| uint16_t max_port, | |
| absl::string_view username, | |
| absl::string_view password, | |
| const ServerAddresses& servers, | |
| absl::optional<int> stun_keepalive_interval, | |
| const webrtc::FieldTrialsView* field_trials); | |
| void PrepareAddress() override; | |
| protected: | |
| StunPort(rtc::Thread* thread, | |
| rtc::PacketSocketFactory* factory, | |
| const rtc::Network* network, | |
| uint16_t min_port, | |
| uint16_t max_port, | |
| absl::string_view username, | |
| absl::string_view password, | |
| const ServerAddresses& servers, | |
| const webrtc::FieldTrialsView* field_trials); | |
| }; | |
| } // namespace cricket | |
| #endif // P2P_BASE_STUN_PORT_H_ |