blob: 89617f021719b8c65bb14107a90cacb8d9ce5015 [file] [log] [blame]
/*
* 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"
#include "rtc_base/network/received_packet.h"
#include "rtc_base/system/rtc_export.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 RTC_EXPORT UDPPort : public Port {
public:
static std::unique_ptr<UDPPort> Create(
const PortParametersRef& args,
rtc::AsyncPacketSocket* socket,
bool emit_local_for_anyaddress,
std::optional<int> stun_keepalive_interval) {
// Using `new` to access a non-public constructor.
auto port =
absl::WrapUnique(new UDPPort(args, webrtc::IceCandidateType::kHost,
socket, emit_local_for_anyaddress));
port->set_stun_keepalive_delay(stun_keepalive_interval);
if (!port->Init()) {
return nullptr;
}
return port;
}
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<UDPPort>
Create(webrtc::TaskQueueBase* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
rtc::AsyncPacketSocket* socket,
absl::string_view username,
absl::string_view password,
bool emit_local_for_anyaddress,
std::optional<int> stun_keepalive_interval,
const webrtc::FieldTrialsView* field_trials = nullptr) {
return Create({.network_thread = thread,
.socket_factory = factory,
.network = network,
.ice_username_fragment = username,
.ice_password = password,
.field_trials = field_trials},
socket, emit_local_for_anyaddress, stun_keepalive_interval);
}
static std::unique_ptr<UDPPort> Create(
const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
bool emit_local_for_anyaddress,
std::optional<int> stun_keepalive_interval) {
// Using `new` to access a non-public constructor.
auto port = absl::WrapUnique(
new UDPPort(args, webrtc::IceCandidateType::kHost, min_port, max_port,
emit_local_for_anyaddress));
port->set_stun_keepalive_delay(stun_keepalive_interval);
if (!port->Init()) {
return nullptr;
}
return port;
}
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<UDPPort>
Create(webrtc::TaskQueueBase* 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,
std::optional<int> stun_keepalive_interval,
const webrtc::FieldTrialsView* field_trials = nullptr) {
return Create({.network_thread = thread,
.socket_factory = factory,
.network = network,
.ice_username_fragment = username,
.ice_password = password,
.field_trials = field_trials},
min_port, max_port, emit_local_for_anyaddress,
stun_keepalive_interval);
}
~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 rtc::ReceivedPacket& packet) override;
bool SupportsProtocol(absl::string_view protocol) const override;
ProtocolType GetProtocol() const override;
void GetStunStats(std::optional<StunStats>* stats) override;
void set_stun_keepalive_delay(const std::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(const PortParametersRef& args,
webrtc::IceCandidateType type,
rtc::AsyncPacketSocket* socket,
bool emit_local_for_anyaddress);
UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
uint16_t min_port,
uint16_t max_port,
bool emit_local_for_anyaddress);
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 rtc::ReceivedPacket& packet);
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 HasStunCandidateWithAddress(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(
const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
const ServerAddresses& servers,
std::optional<int> stun_keepalive_interval);
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<StunPort>
Create(webrtc::TaskQueueBase* 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,
std::optional<int> stun_keepalive_interval,
const webrtc::FieldTrialsView* field_trials);
void PrepareAddress() override;
protected:
StunPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
const ServerAddresses& servers);
};
} // namespace cricket
#endif // P2P_BASE_STUN_PORT_H_