admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make Port constructor take a CreatePortArgs argument

Browse Source 
Introduces a struct CreatePortArgs that is similar to the existing
CreateRelayPortArgs and contains parameters that will be passed from
the constructors of descendents of the Port class to the Port.

This struct makes it easier to add new arguments to the port
constructor without changing all inheriting classes.

Rebase of https://webrtc-review.googlesource.com/c/src/+/341021

BUG=webrtc:14626

Change-Id: Id8e5c24a36149e1699e2b42c57e52002d27c86c8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/345860
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Philipp Hancke <phancke@meta.com>
Cr-Commit-Position: refs/heads/main@{#42339}
This commit is contained in:
Philipp Hancke 2024-04-09 17:35:41 -07:00 committed by WebRTC LUCI CQ
parent 87976eb7e1
commit 833ec4d123
16 changed files with 497 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
p2p/BUILD.gn
View File

@ -736,7 +736,9 @@ rtc_library("port_interface") {
deps = [
":transport_description",
"../api:candidate",
"../api:field_trials_view",
"../api:packet_socket_factory",
"../api/task_queue:task_queue",
"../rtc_base:async_packet_socket",
"../rtc_base:callback_list",
"../rtc_base:socket_address",

42
p2p/base/fake_port_allocator.h
View File

@ -34,18 +34,12 @@ namespace cricket {
class TestUDPPort : public UDPPort {
public:
static TestUDPPort* Create(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
static TestUDPPort* Create(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
absl::string_view username,
absl::string_view password,
bool emit_localhost_for_anyaddress,
const webrtc::FieldTrialsView* field_trials) {
TestUDPPort* port =
new TestUDPPort(thread, factory, network, min_port, max_port, username,
password, emit_localhost_for_anyaddress, field_trials);
bool emit_localhost_for_anyaddress) {
TestUDPPort* port = new TestUDPPort(args, min_port, max_port,
emit_localhost_for_anyaddress);
if (!port->Init()) {
delete port;
port = nullptr;
@ -54,25 +48,15 @@ class TestUDPPort : public UDPPort {
}
protected:
TestUDPPort(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
TestUDPPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
absl::string_view username,
absl::string_view password,
bool emit_localhost_for_anyaddress,
const webrtc::FieldTrialsView* field_trials)
: UDPPort(thread,
bool emit_localhost_for_anyaddress)
: UDPPort(args,
webrtc::IceCandidateType::kHost,
factory,
network,
min_port,
max_port,
username,
password,
emit_localhost_for_anyaddress,
field_trials) {}
emit_localhost_for_anyaddress) {}
};
// A FakePortAllocatorSession can be used with either a real or fake socket
@ -123,9 +107,13 @@ class FakePortAllocatorSession : public PortAllocatorSession {
(rtc::HasIPv6Enabled() && (flags() & PORTALLOCATOR_ENABLE_IPV6))
? ipv6_network_
: ipv4_network_;
port_.reset(TestUDPPort::Create(network_thread_, factory_, &network, 0, 0,
username(), password(), false,
field_trials_));
port_.reset(TestUDPPort::Create({.network_thread = network_thread_,
.socket_factory = factory_,
.network = &network,
.ice_username_fragment = username(),
.ice_password = password(),
.field_trials = field_trials_},
0, 0, false));
RTC_DCHECK(port_);
port_->SetIceTiebreaker(allocator_->ice_tiebreaker());
port_->SubscribePortDestroyed(

76
p2p/base/port.cc
View File

@ -95,52 +95,32 @@ const char TCPTYPE_ACTIVE_STR[] = "active";
const char TCPTYPE_PASSIVE_STR[] = "passive";
const char TCPTYPE_SIMOPEN_STR[] = "so";
Port::Port(TaskQueueBase* thread,
webrtc::IceCandidateType type,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
absl::string_view username_fragment,
absl::string_view password,
const webrtc::FieldTrialsView* field_trials)
: Port(thread,
type,
factory,
network,
0,
0,
username_fragment,
password,
field_trials,
true) {}
Port::Port(const PortParametersRef& args, webrtc::IceCandidateType type)
: Port(args, type, 0, 0, true) {}
Port::Port(TaskQueueBase* thread,
Port::Port(const PortParametersRef& args,
webrtc::IceCandidateType 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,
bool shared_socket /*= false*/)
: thread_(thread),
factory_(factory),
field_trials_(field_trials),
: thread_(args.network_thread),
factory_(args.socket_factory),
field_trials_(args.field_trials),
type_(type),
send_retransmit_count_attribute_(false),
network_(network),
network_(args.network),
min_port_(min_port),
max_port_(max_port),
component_(ICE_CANDIDATE_COMPONENT_DEFAULT),
generation_(0),
ice_username_fragment_(username_fragment),
password_(password),
ice_username_fragment_(args.ice_username_fragment),
password_(args.ice_password),
timeout_delay_(kPortTimeoutDelay),
enable_port_packets_(false),
ice_role_(ICEROLE_UNKNOWN),
tiebreaker_(0),
shared_socket_(shared_socket),
network_cost_(network->GetCost(*field_trials_)),
network_cost_(args.network->GetCost(*field_trials_)),
weak_factory_(this) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(factory_ != nullptr);
@ -159,6 +139,42 @@ Port::Port(TaskQueueBase* thread,
<< network_cost_;
}
Port::Port(TaskQueueBase* thread,
webrtc::IceCandidateType type,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
absl::string_view username_fragment,
absl::string_view password,
const webrtc::FieldTrialsView* field_trials)
: Port({.network_thread = thread,
.socket_factory = factory,
.network = network,
.ice_username_fragment = username_fragment,
.ice_password = password,
.field_trials = field_trials},
type) {}
Port::Port(TaskQueueBase* thread,
webrtc::IceCandidateType 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,
bool shared_socket /*= false*/)
: Port({.network_thread = thread,
.socket_factory = factory,
.network = network,
.ice_username_fragment = username_fragment,
.ice_password = password,
.field_trials = field_trials},
type,
min_port,
max_port,
shared_socket) {}
Port::~Port() {
RTC_DCHECK_RUN_ON(thread_);
DestroyAllConnections();

46
p2p/base/port.h
View File

@ -170,25 +170,45 @@ typedef std::set<rtc::SocketAddress> ServerAddresses;
// 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:
// A struct containing common arguments to creating a port. See also
// CreateRelayPortArgs.
struct PortParametersRef {
webrtc::TaskQueueBase* network_thread;
rtc::PacketSocketFactory* socket_factory;
const rtc::Network* network;
absl::string_view ice_username_fragment;
absl::string_view ice_password;
const webrtc::FieldTrialsView* field_trials;
};
protected:
// Constructors for use only by via constructors in derived classes.
Port(webrtc::TaskQueueBase* thread,
Port(const PortParametersRef& args, webrtc::IceCandidateType type);
Port(const PortParametersRef& args,
webrtc::IceCandidateType 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,
webrtc::IceCandidateType 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,
bool shared_socket = false);
[[deprecated("Pass arguments using PortParametersRef")]] Port(
webrtc::TaskQueueBase* thread,
webrtc::IceCandidateType type,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
absl::string_view username_fragment,
absl::string_view password,
const webrtc::FieldTrialsView* field_trials = nullptr);
[[deprecated("Pass arguments using PortParametersRef")]] Port(
webrtc::TaskQueueBase* thread,
webrtc::IceCandidateType 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,
bool shared_socket = false);
public:
~Port() override;

2
p2p/base/port_interface.h
View File

@ -19,7 +19,9 @@
#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/task_queue/task_queue_base.h"
#include "p2p/base/transport_description.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/callback_list.h"

82
p2p/base/port_unittest.cc
View File

@ -140,23 +140,8 @@ bool WriteStunMessage(const StunMessage& msg, ByteBufferWriter* buf) {
// Stub port class for testing STUN generation and processing.
class TestPort : public Port {
public:
TestPort(rtc::Thread* thread,
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(thread,
IceCandidateType::kHost,
factory,
network,
min_port,
max_port,
username_fragment,
password,
field_trials) {}
TestPort(const PortParametersRef& args, uint16_t min_port, uint16_t max_port)
: Port(args, IceCandidateType::kHost, min_port, max_port) {}
~TestPort() {}
// Expose GetStunMessage so that we can test it.
@ -550,9 +535,13 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
}
std::unique_ptr<UDPPort> CreateUdpPort(const SocketAddress& addr,
PacketSocketFactory* socket_factory) {
auto port = UDPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
username_, password_, true, absl::nullopt,
&field_trials_);
auto port = UDPPort::Create({.network_thread = &main_,
.socket_factory = socket_factory,
.network = MakeNetwork(addr),
.ice_username_fragment = username_,
.ice_password = password_,
.field_trials = &field_trials_},
0, 0, true, absl::nullopt);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
@ -562,9 +551,13 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
const SocketAddress& link_local_addr,
PacketSocketFactory* socket_factory) {
auto port = UDPPort::Create(
&main_, socket_factory,
MakeNetworkMultipleAddrs(global_addr, link_local_addr), 0, 0, username_,
password_, true, absl::nullopt, &field_trials_);
{.network_thread = &main_,
.socket_factory = socket_factory,
.network = MakeNetworkMultipleAddrs(global_addr, link_local_addr),
.ice_username_fragment = username_,
.ice_password = password_,
.field_trials = &field_trials_},
0, 0, true, absl::nullopt);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
@ -573,18 +566,28 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
}
std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr,
PacketSocketFactory* socket_factory) {
auto port = TCPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
username_, password_, true, &field_trials_);
auto port = TCPPort::Create({.network_thread = &main_,
.socket_factory = socket_factory,
.network = MakeNetwork(addr),
.ice_username_fragment = username_,
.ice_password = password_,
.field_trials = &field_trials_},
0, 0, true);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<StunPort> CreateStunPort(const SocketAddress& addr,
rtc::PacketSocketFactory* factory) {
std::unique_ptr<StunPort> CreateStunPort(
const SocketAddress& addr,
rtc::PacketSocketFactory* socket_factory) {
ServerAddresses stun_servers;
stun_servers.insert(kStunAddr);
auto port = StunPort::Create(&main_, factory, MakeNetwork(addr), 0, 0,
username_, password_, stun_servers,
absl::nullopt, &field_trials_);
auto port = StunPort::Create({.network_thread = &main_,
.socket_factory = socket_factory,
.network = MakeNetwork(addr),
.ice_username_fragment = username_,
.ice_password = password_,
.field_trials = &field_trials_},
0, 0, stun_servers, absl::nullopt);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
@ -824,9 +827,13 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
absl::string_view username,
absl::string_view password,
const webrtc::FieldTrialsView* field_trials = nullptr) {
auto port =
std::make_unique<TestPort>(&main_, &socket_factory_, MakeNetwork(addr),
0, 0, username, password, field_trials);
Port::PortParametersRef args = {.network_thread = &main_,
.socket_factory = &socket_factory_,
.network = MakeNetwork(addr),
.ice_username_fragment = username,
.ice_password = password,
.field_trials = field_trials};
auto port = std::make_unique<TestPort>(args, 0, 0);
port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
return port;
}
@ -844,8 +851,13 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
std::unique_ptr<TestPort> CreateTestPort(const rtc::Network* network,
absl::string_view username,
absl::string_view password) {
auto port = std::make_unique<TestPort>(&main_, &socket_factory_, network, 0,
0, username, password);
Port::PortParametersRef args = {.network_thread = &main_,
.socket_factory = &socket_factory_,
.network = network,
.ice_username_fragment = username,
.ice_password = password,
.field_trials = nullptr};
auto port = std::make_unique<TestPort>(args, 0, 0);
port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
return port;
}

85
p2p/base/stun_port.cc
View File

@ -159,18 +159,13 @@ bool UDPPort::AddressResolver::GetResolvedAddress(
return it->second->result().GetResolvedAddress(family, output);
}
UDPPort::UDPPort(rtc::Thread* thread,
UDPPort::UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
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)
: Port(thread, type, factory, network, username, password, field_trials),
bool emit_local_for_anyaddress)
: Port(args, type),
request_manager_(
thread,
args.network_thread,
[this](const void* data, size_t size, StunRequest* request) {
OnSendPacket(data, size, request);
}),
@ -181,27 +176,14 @@ UDPPort::UDPPort(rtc::Thread* thread,
dscp_(rtc::DSCP_NO_CHANGE),
emit_local_for_anyaddress_(emit_local_for_anyaddress) {}
UDPPort::UDPPort(rtc::Thread* thread,
UDPPort::UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
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)
: Port(thread,
type,
factory,
network,
min_port,
max_port,
username,
password,
field_trials),
bool emit_local_for_anyaddress)
: Port(args, type, min_port, max_port),
request_manager_(
thread,
args.network_thread,
[this](const void* data, size_t size, StunRequest* request) {
OnSendPacket(data, size, request);
}),
@ -624,7 +606,22 @@ bool UDPPort::HasStunCandidateWithAddress(
}
std::unique_ptr<StunPort> StunPort::Create(
rtc::Thread* thread,
const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
const ServerAddresses& servers,
absl::optional<int> stun_keepalive_interval) {
// Using `new` to access a non-public constructor.
auto port = absl::WrapUnique(new StunPort(args, min_port, max_port, servers));
port->set_stun_keepalive_delay(stun_keepalive_interval);
if (!port->Init()) {
return nullptr;
}
return port;
}
std::unique_ptr<StunPort> StunPort::Create(
webrtc::TaskQueueBase* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
@ -634,36 +631,24 @@ std::unique_ptr<StunPort> StunPort::Create(
const ServerAddresses& servers,
absl::optional<int> stun_keepalive_interval,
const webrtc::FieldTrialsView* field_trials) {
// Using `new` to access a non-public constructor.
auto port = absl::WrapUnique(new StunPort(thread, factory, network, min_port,
max_port, username, password,
servers, field_trials));
port->set_stun_keepalive_delay(stun_keepalive_interval);
if (!port->Init()) {
return nullptr;
}
return port;
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, servers, stun_keepalive_interval);
}
StunPort::StunPort(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
StunPort::StunPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
absl::string_view username,
absl::string_view password,
const ServerAddresses& servers,
const webrtc::FieldTrialsView* field_trials)
: UDPPort(thread,
const ServerAddresses& servers)
: UDPPort(args,
webrtc::IceCandidateType::kSrflx,
factory,
network,
min_port,
max_port,
username,
password,
false,
field_trials) {
false) {
set_server_addresses(servers);
}

125
p2p/base/stun_port.h
View File

@ -36,47 +36,77 @@ static const int HIGH_COST_PORT_KEEPALIVE_LIFETIME = 2 * 60 * 1000;
class RTC_EXPORT UDPPort : public Port {
public:
static std::unique_ptr<UDPPort> Create(
rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
const PortParametersRef& args,
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) {
absl::optional<int> stun_keepalive_interval) {
// Using `new` to access a non-public constructor.
auto port = absl::WrapUnique(new UDPPort(
thread, webrtc::IceCandidateType::kHost, factory, network, socket,
username, password, emit_local_for_anyaddress, field_trials));
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,
absl::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(
rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
const PortParametersRef& args,
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) {
absl::optional<int> stun_keepalive_interval) {
// Using `new` to access a non-public constructor.
auto port = absl::WrapUnique(new UDPPort(
thread, webrtc::IceCandidateType::kHost, factory, network, min_port,
max_port, username, password, emit_local_for_anyaddress, field_trials));
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,
absl::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;
@ -117,27 +147,15 @@ class RTC_EXPORT UDPPort : public Port {
StunRequestManager& request_manager() { return request_manager_; }
protected:
UDPPort(rtc::Thread* thread,
UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
rtc::AsyncPacketSocket* socket,
bool emit_local_for_anyaddress);
UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
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,
webrtc::IceCandidateType type,
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 emit_local_for_anyaddress);
bool Init();
int SendTo(const void* data,
@ -268,29 +286,30 @@ class RTC_EXPORT UDPPort : public Port {
class StunPort : public UDPPort {
public:
static std::unique_ptr<StunPort> Create(
rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
const PortParametersRef& args,
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);
absl::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,
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,
StunPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
absl::string_view username,
absl::string_view password,
const ServerAddresses& servers,
const webrtc::FieldTrialsView* field_trials);
const ServerAddresses& servers);
};
} // namespace cricket

20
p2p/base/stun_port_unittest.cc
View File

@ -137,9 +137,13 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
void CreateStunPort(const ServerAddresses& stun_servers,
const webrtc::FieldTrialsView* field_trials = nullptr) {
stun_port_ = cricket::StunPort::Create(
rtc::Thread::Current(), socket_factory(), &network_, 0, 0,
rtc::CreateRandomString(16), rtc::CreateRandomString(22), stun_servers,
absl::nullopt, field_trials);
{.network_thread = rtc::Thread::Current(),
.socket_factory = socket_factory(),
.network = &network_,
.ice_username_fragment = rtc::CreateRandomString(16),
.ice_password = rtc::CreateRandomString(22),
.field_trials = field_trials},
0, 0, stun_servers, absl::nullopt);
stun_port_->SetIceTiebreaker(kTiebreakerDefault);
stun_port_->set_stun_keepalive_delay(stun_keepalive_delay_);
// If `stun_keepalive_lifetime_` is negative, let the stun port
@ -170,9 +174,13 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
OnReadPacket(socket, packet);
});
stun_port_ = cricket::UDPPort::Create(
rtc::Thread::Current(), socket_factory(), &network_, socket_.get(),
rtc::CreateRandomString(16), rtc::CreateRandomString(22), false,
absl::nullopt, field_trials);
{.network_thread = rtc::Thread::Current(),
.socket_factory = socket_factory(),
.network = &network_,
.ice_username_fragment = rtc::CreateRandomString(16),
.ice_password = rtc::CreateRandomString(22),
.field_trials = field_trials},
socket_.get(), false, absl::nullopt);
ASSERT_TRUE(stun_port_ != NULL);
stun_port_->SetIceTiebreaker(kTiebreakerDefault);
ServerAddresses stun_servers;

19
p2p/base/tcp_port.cc
View File

@ -90,24 +90,11 @@ using ::webrtc::IceCandidateType;
using ::webrtc::SafeTask;
using ::webrtc::TimeDelta;
TCPPort::TCPPort(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
TCPPort::TCPPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
absl::string_view username,
absl::string_view password,
bool allow_listen,
const webrtc::FieldTrialsView* field_trials)
: Port(thread,
IceCandidateType::kHost,
factory,
network,
min_port,
max_port,
username,
password,
field_trials),
bool allow_listen)
: Port(args, IceCandidateType::kHost, min_port, max_port),
allow_listen_(allow_listen),
error_(0) {
// TODO(mallinath) - Set preference value as per RFC 6544.

47
p2p/base/tcp_port.h
View File

@ -36,20 +36,32 @@ class TCPConnection;
// call this TCPPort::OnReadPacket (3 arg) to dispatch to a connection.
class TCPPort : public Port {
public:
static std::unique_ptr<TCPPort> 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 allow_listen,
const webrtc::FieldTrialsView* field_trials = nullptr) {
static std::unique_ptr<TCPPort> Create(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
bool allow_listen) {
// Using `new` to access a non-public constructor.
return absl::WrapUnique(new TCPPort(thread, factory, network, min_port,
max_port, username, password,
allow_listen, field_trials));
return absl::WrapUnique(
new TCPPort(args, min_port, max_port, allow_listen));
}
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<TCPPort>
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 allow_listen,
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, allow_listen);
}
~TCPPort() override;
@ -68,15 +80,10 @@ class TCPPort : public Port {
ProtocolType GetProtocol() const override;
protected:
TCPPort(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
TCPPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
absl::string_view username,
absl::string_view password,
bool allow_listen,
const webrtc::FieldTrialsView* field_trials);
bool allow_listen);
// Handles sending using the local TCP socket.
int SendTo(const void* data,

18
p2p/base/tcp_port_unittest.cc
View File

@ -84,16 +84,26 @@ class TCPPortTest : public ::testing::Test, public sigslot::has_slots<> {
std::unique_ptr<TCPPort> CreateTCPPort(const SocketAddress& addr) {
auto port = std::unique_ptr<TCPPort>(
TCPPort::Create(&main_, &socket_factory_, MakeNetwork(addr), 0, 0,
username_, password_, true, &field_trials_));
TCPPort::Create({.network_thread = &main_,
.socket_factory = &socket_factory_,
.network = MakeNetwork(addr),
.ice_username_fragment = username_,
.ice_password = password_,
.field_trials = &field_trials_},
0, 0, true));
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<TCPPort> CreateTCPPort(const rtc::Network* network) {
auto port = std::unique_ptr<TCPPort>(
TCPPort::Create(&main_, &socket_factory_, network, 0, 0, username_,
password_, true, &field_trials_));
TCPPort::Create({.network_thread = &main_,
.socket_factory = &socket_factory_,
.network = network,
.ice_username_fragment = username_,
.ice_password = password_,
.field_trials = &field_trials_},
0, 0, true));
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}

149
p2p/base/turn_port.cc
View File

@ -208,7 +208,68 @@ class TurnEntry : public sigslot::has_slots<> {
webrtc::ScopedTaskSafety task_safety_;
};
TurnPort::TurnPort(TaskQueueBase* thread,
TurnPort::TurnPort(const PortParametersRef& args,
rtc::AsyncPacketSocket* socket,
const ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
const std::vector<std::string>& tls_alpn_protocols,
const std::vector<std::string>& tls_elliptic_curves,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier)
: Port(args, IceCandidateType::kRelay),
server_address_(server_address),
server_url_(ReconstructServerUrl()),
tls_alpn_protocols_(tls_alpn_protocols),
tls_elliptic_curves_(tls_elliptic_curves),
tls_cert_verifier_(tls_cert_verifier),
credentials_(credentials),
socket_(socket),
error_(0),
stun_dscp_value_(rtc::DSCP_NO_CHANGE),
request_manager_(
args.network_thread,
[this](const void* data, size_t size, StunRequest* request) {
OnSendStunPacket(data, size, request);
}),
next_channel_number_(TURN_CHANNEL_NUMBER_START),
state_(STATE_CONNECTING),
server_priority_(server_priority),
allocate_mismatch_retries_(0),
turn_customizer_(customizer) {}
TurnPort::TurnPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
const ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
const std::vector<std::string>& tls_alpn_protocols,
const std::vector<std::string>& tls_elliptic_curves,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier)
: Port(args, IceCandidateType::kRelay, min_port, max_port),
server_address_(server_address),
server_url_(ReconstructServerUrl()),
tls_alpn_protocols_(tls_alpn_protocols),
tls_elliptic_curves_(tls_elliptic_curves),
tls_cert_verifier_(tls_cert_verifier),
credentials_(credentials),
socket_(nullptr),
error_(0),
stun_dscp_value_(rtc::DSCP_NO_CHANGE),
request_manager_(
args.network_thread,
[this](const void* data, size_t size, StunRequest* request) {
OnSendStunPacket(data, size, request);
}),
next_channel_number_(TURN_CHANNEL_NUMBER_START),
state_(STATE_CONNECTING),
server_priority_(server_priority),
allocate_mismatch_retries_(0),
turn_customizer_(customizer) {}
TurnPort::TurnPort(webrtc::TaskQueueBase* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
rtc::AsyncPacketSocket* socket,
@ -222,34 +283,21 @@ TurnPort::TurnPort(TaskQueueBase* thread,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier,
const webrtc::FieldTrialsView* field_trials)
: Port(thread,
IceCandidateType::kRelay,
factory,
network,
username,
password,
field_trials),
server_address_(server_address),
server_url_(ReconstructServerUrl()),
tls_alpn_protocols_(tls_alpn_protocols),
tls_elliptic_curves_(tls_elliptic_curves),
tls_cert_verifier_(tls_cert_verifier),
credentials_(credentials),
socket_(socket),
error_(0),
stun_dscp_value_(rtc::DSCP_NO_CHANGE),
request_manager_(
thread,
[this](const void* data, size_t size, StunRequest* request) {
OnSendStunPacket(data, size, request);
}),
next_channel_number_(TURN_CHANNEL_NUMBER_START),
state_(STATE_CONNECTING),
server_priority_(server_priority),
allocate_mismatch_retries_(0),
turn_customizer_(customizer) {}
TurnPort::TurnPort(TaskQueueBase* thread,
: TurnPort({.network_thread = thread,
.socket_factory = factory,
.network = network,
.ice_username_fragment = username,
.ice_password = password,
.field_trials = field_trials},
socket,
server_address,
credentials,
server_priority,
tls_alpn_protocols,
tls_elliptic_curves,
customizer,
tls_cert_verifier) {}
TurnPort::TurnPort(webrtc::TaskQueueBase* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
@ -264,34 +312,21 @@ TurnPort::TurnPort(TaskQueueBase* thread,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier,
const webrtc::FieldTrialsView* field_trials)
: Port(thread,
IceCandidateType::kRelay,
factory,
network,
min_port,
max_port,
username,
password,
field_trials),
server_address_(server_address),
server_url_(ReconstructServerUrl()),
tls_alpn_protocols_(tls_alpn_protocols),
tls_elliptic_curves_(tls_elliptic_curves),
tls_cert_verifier_(tls_cert_verifier),
credentials_(credentials),
socket_(nullptr),
error_(0),
stun_dscp_value_(rtc::DSCP_NO_CHANGE),
request_manager_(
thread,
[this](const void* data, size_t size, StunRequest* request) {
OnSendStunPacket(data, size, request);
}),
next_channel_number_(TURN_CHANNEL_NUMBER_START),
state_(STATE_CONNECTING),
server_priority_(server_priority),
allocate_mismatch_retries_(0),
turn_customizer_(customizer) {}
: TurnPort({.network_thread = thread,
.socket_factory = factory,
.network = network,
.ice_username_fragment = username,
.ice_password = password,
.field_trials = field_trials},
min_port,
max_port,
server_address,
credentials,
server_priority,
tls_alpn_protocols,
tls_elliptic_curves,
customizer,
tls_cert_verifier) {}
TurnPort::~TurnPort() {
// TODO(juberti): Should this even be necessary?

83
p2p/base/turn_port.h
View File

@ -81,12 +81,16 @@ class TurnPort : public Port {
}
// Using `new` to access a non-public constructor.
return absl::WrapUnique(
new TurnPort(args.network_thread, args.socket_factory, args.network,
socket, args.username, args.password, *args.server_address,
args.config->credentials, args.relative_priority,
args.config->tls_alpn_protocols,
new TurnPort({.network_thread = args.network_thread,
.socket_factory = args.socket_factory,
.network = args.network,
.ice_username_fragment = args.username,
.ice_password = args.password,
.field_trials = args.field_trials},
socket, *args.server_address, args.config->credentials,
args.relative_priority, args.config->tls_alpn_protocols,
args.config->tls_elliptic_curves, args.turn_customizer,
args.config->tls_cert_verifier, args.field_trials));
args.config->tls_cert_verifier));
}
// Create a TURN port that will use a new socket, bound to `network` and
@ -98,13 +102,17 @@ class TurnPort : public Port {
return nullptr;
}
// Using `new` to access a non-public constructor.
return absl::WrapUnique(
new TurnPort(args.network_thread, args.socket_factory, args.network,
min_port, max_port, args.username, args.password,
*args.server_address, args.config->credentials,
args.relative_priority, args.config->tls_alpn_protocols,
args.config->tls_elliptic_curves, args.turn_customizer,
args.config->tls_cert_verifier, args.field_trials));
return absl::WrapUnique(new TurnPort(
{.network_thread = args.network_thread,
.socket_factory = args.socket_factory,
.network = args.network,
.ice_username_fragment = args.username,
.ice_password = args.password,
.field_trials = args.field_trials},
min_port, max_port, *args.server_address, args.config->credentials,
args.relative_priority, args.config->tls_alpn_protocols,
args.config->tls_elliptic_curves, args.turn_customizer,
args.config->tls_cert_verifier));
}
~TurnPort() override;
@ -201,36 +209,59 @@ class TurnPort : public Port {
void SetCallbacksForTest(CallbacksForTest* callbacks);
protected:
TurnPort(webrtc::TaskQueueBase* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
TurnPort(const PortParametersRef& args,
rtc::AsyncPacketSocket* socket,
absl::string_view username,
absl::string_view password,
const ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
const std::vector<std::string>& tls_alpn_protocols,
const std::vector<std::string>& tls_elliptic_curves,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
const webrtc::FieldTrialsView* field_trials = nullptr);
rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr);
TurnPort(webrtc::TaskQueueBase* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
TurnPort(const PortParametersRef& args,
uint16_t min_port,
uint16_t max_port,
absl::string_view username,
absl::string_view password,
const ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
const std::vector<std::string>& tls_alpn_protocols,
const std::vector<std::string>& tls_elliptic_curves,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
const webrtc::FieldTrialsView* field_trials = nullptr);
rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr);
[[deprecated("Pass arguments using PortParametersRef")]] TurnPort(
webrtc::TaskQueueBase* thread,
rtc::PacketSocketFactory* factory,
const rtc::Network* network,
rtc::AsyncPacketSocket* socket,
absl::string_view username,
absl::string_view password,
const ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
const std::vector<std::string>& tls_alpn_protocols,
const std::vector<std::string>& tls_elliptic_curves,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
const webrtc::FieldTrialsView* field_trials = nullptr);
[[deprecated("Pass arguments using PortParametersRef")]] TurnPort(
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 ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
const std::vector<std::string>& tls_alpn_protocols,
const std::vector<std::string>& tls_elliptic_curves,
webrtc::TurnCustomizer* customizer,
rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
const webrtc::FieldTrialsView* field_trials = nullptr);
// NOTE: This method needs to be accessible for StunPort
// return true if entry was created (i.e channel_number consumed).

10
p2p/base/turn_port_unittest.cc
View File

@ -366,9 +366,13 @@ class TurnPortTest : public ::testing::Test,
void CreateUdpPort() { CreateUdpPort(kLocalAddr2); }
void CreateUdpPort(const SocketAddress& address) {
udp_port_ = UDPPort::Create(&main_, socket_factory(), MakeNetwork(address),
0, 0, kIceUfrag2, kIcePwd2, false,
absl::nullopt, &field_trials_);
udp_port_ = UDPPort::Create({.network_thread = &main_,
.socket_factory = socket_factory(),
.network = MakeNetwork(address),
.ice_username_fragment = kIceUfrag2,
.ice_password = kIcePwd2,
.field_trials = &field_trials_},
0, 0, false, absl::nullopt);
// UDP port will be controlled.
udp_port_->SetIceRole(ICEROLE_CONTROLLED);
udp_port_->SetIceTiebreaker(kTiebreakerDefault);

48
p2p/client/basic_port_allocator.cc
View File

@ -1470,19 +1470,25 @@ void AllocationSequence::CreateUDPPorts() {
!IsFlagSet(PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE);
if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) && udp_socket_) {
port = UDPPort::Create(
session_->network_thread(), session_->socket_factory(), network_,
udp_socket_.get(), session_->username(), session_->password(),
emit_local_candidate_for_anyaddress,
session_->allocator()->stun_candidate_keepalive_interval(),
session_->allocator()->field_trials());
{.network_thread = session_->network_thread(),
.socket_factory = session_->socket_factory(),
.network = network_,
.ice_username_fragment = session_->username(),
.ice_password = session_->password(),
.field_trials = session_->allocator()->field_trials()},
udp_socket_.get(), emit_local_candidate_for_anyaddress,
session_->allocator()->stun_candidate_keepalive_interval());
} else {
port = UDPPort::Create(
session_->network_thread(), session_->socket_factory(), network_,
{.network_thread = session_->network_thread(),
.socket_factory = session_->socket_factory(),
.network = network_,
.ice_username_fragment = session_->username(),
.ice_password = session_->password(),
.field_trials = session_->allocator()->field_trials()},
session_->allocator()->min_port(), session_->allocator()->max_port(),
session_->username(), session_->password(),
emit_local_candidate_for_anyaddress,
session_->allocator()->stun_candidate_keepalive_interval(),
session_->allocator()->field_trials());
session_->allocator()->stun_candidate_keepalive_interval());
}
if (port) {
@ -1516,11 +1522,15 @@ void AllocationSequence::CreateTCPPorts() {
}
std::unique_ptr<Port> port = TCPPort::Create(
session_->network_thread(), session_->socket_factory(), network_,
{.network_thread = session_->network_thread(),
.socket_factory = session_->socket_factory(),
.network = network_,
.ice_username_fragment = session_->username(),
.ice_password = session_->password(),
.field_trials = session_->allocator()->field_trials()},
session_->allocator()->min_port(), session_->allocator()->max_port(),
session_->username(), session_->password(),
session_->allocator()->allow_tcp_listen(),
session_->allocator()->field_trials());
session_->allocator()->allow_tcp_listen());
if (port) {
port->SetIceTiebreaker(session_->allocator()->ice_tiebreaker());
session_->AddAllocatedPort(port.release(), this);
@ -1546,11 +1556,15 @@ void AllocationSequence::CreateStunPorts() {
}
std::unique_ptr<StunPort> port = StunPort::Create(
session_->network_thread(), session_->socket_factory(), network_,
{.network_thread = session_->network_thread(),
.socket_factory = session_->socket_factory(),
.network = network_,
.ice_username_fragment = session_->username(),
.ice_password = session_->password(),
.field_trials = session_->allocator()->field_trials()},
session_->allocator()->min_port(), session_->allocator()->max_port(),
session_->username(), session_->password(), config_->StunServers(),
session_->allocator()->stun_candidate_keepalive_interval(),
session_->allocator()->field_trials());
config_->StunServers(),
session_->allocator()->stun_candidate_keepalive_interval());
if (port) {
port->SetIceTiebreaker(session_->allocator()->ice_tiebreaker());
session_->AddAllocatedPort(port.release(), this);