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

ice: include tiebreaker in computation of foundation attribute (tests)

Browse Source 
split from the actual change for easier review and cherry-picking.

BUG=webrtc:14605

Change-Id: I7dbaf8e1f4a03f35a5d8c4da1a2784b00589bfc3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/280680
Commit-Queue: Philipp Hancke <phancke@microsoft.com>
Reviewed-by: Jonas Oreland <jonaso@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38519}
This commit is contained in:
Philipp Hancke 2022-10-27 20:08:23 +02:00 committed by WebRTC LUCI CQ
parent fab70495f6
commit fd91d02210
12 changed files with 83 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
p2p/base/fake_port_allocator.h
View File

@ -109,6 +109,7 @@ class FakePortAllocatorSession : public PortAllocatorSession {
field_trials_(field_trials) {
ipv4_network_.AddIP(rtc::IPAddress(INADDR_LOOPBACK));
ipv6_network_.AddIP(rtc::IPAddress(in6addr_loopback));
set_ice_tiebreaker(/*kTiebreakerDefault = */ 44444);
}
void SetCandidateFilter(uint32_t filter) override {
@ -125,6 +126,7 @@ class FakePortAllocatorSession : public PortAllocatorSession {
username(), password(), false,
&field_trials_));
RTC_DCHECK(port_);
port_->SetIceTiebreaker(ice_tiebreaker());
port_->SubscribePortDestroyed(
[this](PortInterface* port) { OnPortDestroyed(port); });
AddPort(port_.get());

8
p2p/base/p2p_transport_channel_unittest.cc
View File

@ -141,6 +141,7 @@ const cricket::IceParameters kIceParams[4] = {
const uint64_t kLowTiebreaker = 11111;
const uint64_t kHighTiebreaker = 22222;
const uint64_t kTiebreakerDefault = 44444;
cricket::IceConfig CreateIceConfig(
int receiving_timeout,
@ -300,6 +301,11 @@ class P2PTransportChannelTestBase : public ::testing::Test,
ep2_.allocator_.reset(CreateBasicPortAllocator(
&ep2_.network_manager_, ss_.get(), stun_servers, kTurnUdpIntAddr,
rtc::SocketAddress()));
ep1_.SetIceTiebreaker(kTiebreakerDefault);
ep1_.allocator_->SetIceTiebreaker(kTiebreakerDefault);
ep2_.SetIceTiebreaker(kTiebreakerDefault);
ep2_.allocator_->SetIceTiebreaker(kTiebreakerDefault);
webrtc::metrics::Reset();
}
@ -3476,6 +3482,7 @@ class P2PTransportChannelPingTest : public TestWithParam<std::string>,
protected:
void PrepareChannel(P2PTransportChannel* ch) {
ch->SetIceRole(ICEROLE_CONTROLLING);
ch->SetIceTiebreaker(kTiebreakerDefault);
ch->SetIceParameters(kIceParams[0]);
ch->SetRemoteIceParameters(kIceParams[1]);
ch->SignalNetworkRouteChanged.connect(
@ -3840,6 +3847,7 @@ TEST_P(P2PTransportChannelPingTest, PingingStartedAsSoonAsPossible) {
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory());
P2PTransportChannel ch("TestChannel", 1, &pa, &field_trials_);
ch.SetIceRole(ICEROLE_CONTROLLING);
ch.SetIceTiebreaker(kTiebreakerDefault);
ch.SetIceParameters(kIceParams[0]);
ch.MaybeStartGathering();
EXPECT_EQ_WAIT(IceGatheringState::kIceGatheringComplete, ch.gathering_state(),

1
p2p/base/port.cc
View File

@ -209,6 +209,7 @@ void Port::SetIceRole(IceRole role) {
void Port::SetIceTiebreaker(uint64_t tiebreaker) {
tiebreaker_ = tiebreaker;
}
uint64_t Port::IceTiebreaker() const {
return tiebreaker_;
}

5
p2p/base/port_allocator_unittest.cc
View File

@ -25,6 +25,7 @@ static const char kIceUfrag[] = "UF00";
static const char kIcePwd[] = "TESTICEPWD00000000000000";
static const char kTurnUsername[] = "test";
static const char kTurnPassword[] = "test";
constexpr uint64_t kTiebreakerDefault = 44444;
class PortAllocatorTest : public ::testing::Test, public sigslot::has_slots<> {
public:
@ -35,7 +36,9 @@ class PortAllocatorTest : public ::testing::Test, public sigslot::has_slots<> {
std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())),
allocator_(std::make_unique<cricket::FakePortAllocator>(
rtc::Thread::Current(),
packet_socket_factory_.get())) {}
packet_socket_factory_.get())) {
allocator_->SetIceTiebreaker(kTiebreakerDefault);
}
protected:
void SetConfigurationWithPoolSize(int candidate_pool_size) {

61
p2p/base/port_unittest.cc
View File

@ -105,6 +105,7 @@ const uint32_t kDefaultPrflxPriority = ICE_TYPE_PREFERENCE_PRFLX << 24 |
constexpr int kTiebreaker1 = 11111;
constexpr int kTiebreaker2 = 22222;
constexpr int kTiebreakerDefault = 44444;
const char* data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
@ -534,35 +535,44 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
}
std::unique_ptr<UDPPort> CreateUdpPort(const SocketAddress& addr,
PacketSocketFactory* socket_factory) {
return UDPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
username_, password_, true, absl::nullopt,
&field_trials_);
auto port = UDPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
username_, password_, true, absl::nullopt,
&field_trials_);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<UDPPort> CreateUdpPortMultipleAddrs(
const SocketAddress& global_addr,
const SocketAddress& link_local_addr,
PacketSocketFactory* socket_factory,
const webrtc::test::ScopedKeyValueConfig& field_trials) {
return UDPPort::Create(
auto port = UDPPort::Create(
&main_, socket_factory,
MakeNetworkMultipleAddrs(global_addr, link_local_addr, &field_trials),
0, 0, username_, password_, true, absl::nullopt, &field_trials);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr) {
return CreateTcpPort(addr, &socket_factory_);
}
std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr,
PacketSocketFactory* socket_factory) {
return TCPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
username_, password_, true, &field_trials_);
auto port = TCPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
username_, password_, true, &field_trials_);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<StunPort> CreateStunPort(const SocketAddress& addr,
rtc::PacketSocketFactory* factory) {
ServerAddresses stun_servers;
stun_servers.insert(kStunAddr);
return StunPort::Create(&main_, factory, MakeNetwork(addr), 0, 0, username_,
password_, stun_servers, absl::nullopt,
&field_trials_);
auto port = StunPort::Create(&main_, factory, MakeNetwork(addr), 0, 0,
username_, password_, stun_servers,
absl::nullopt, &field_trials_);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<Port> CreateRelayPort(const SocketAddress& addr,
ProtocolType int_proto,
@ -597,7 +607,9 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
args.config = &config;
args.field_trials = &field_trials_;
return TurnPort::Create(args, 0, 0);
auto port = TurnPort::Create(args, 0, 0);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<rtc::NATServer> CreateNatServer(const SocketAddress& addr,
@ -1772,6 +1784,7 @@ TEST_F(PortTest, TestUdpMultipleAddressesV6CrossTypePorts) {
factory.set_next_udp_socket(socket);
ports[i] = CreateUdpPortMultipleAddrs(addresses[i], kLinkLocalIPv6Addr,
&factory, field_trials);
ports[i]->SetIceTiebreaker(kTiebreakerDefault);
socket->set_state(AsyncPacketSocket::STATE_BINDING);
socket->SignalAddressReady(socket, addresses[i]);
ports[i]->PrepareAddress();
@ -2468,10 +2481,10 @@ TEST_F(PortTest,
TEST_F(PortTest,
TestHandleStunResponseWithUnknownComprehensionRequiredAttribute) {
// Generic setup.
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
cricket::ICEROLE_CONTROLLING, kTiebreakerDefault);
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
cricket::ICEROLE_CONTROLLED, kTiebreakerDefault);
lport->PrepareAddress();
rport->PrepareAddress();
ASSERT_FALSE(lport->Candidates().empty());
@ -2505,10 +2518,10 @@ TEST_F(PortTest,
TEST_F(PortTest,
TestHandleStunIndicationWithUnknownComprehensionRequiredAttribute) {
// Generic set up.
auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass");
lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass",
cricket::ICEROLE_CONTROLLING, kTiebreakerDefault);
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
cricket::ICEROLE_CONTROLLED, kTiebreakerDefault);
lport->PrepareAddress();
rport->PrepareAddress();
ASSERT_FALSE(lport->Candidates().empty());
@ -2530,9 +2543,8 @@ TEST_F(PortTest,
// Test handling of STUN binding indication messages . STUN binding
// indications are allowed only to the connection which is in read mode.
TEST_F(PortTest, TestHandleStunBindingIndication) {
auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass");
lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass",
cricket::ICEROLE_CONTROLLING, kTiebreaker1);
// Verifying encoding and decoding STUN indication message.
std::unique_ptr<IceMessage> in_msg, out_msg;
@ -2586,6 +2598,7 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
TEST_F(PortTest, TestComputeCandidatePriority) {
auto port = CreateTestPort(kLocalAddr1, "name", "pass");
port->SetIceTiebreaker(kTiebreakerDefault);
port->set_type_preference(90);
port->set_component(177);
port->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
@ -2623,6 +2636,7 @@ TEST_F(PortTest, TestComputeCandidatePriority) {
// Test that candidates with different types will have different foundation.
TEST_F(PortTest, TestFoundation) {
auto testport = CreateTestPort(kLocalAddr1, "name", "pass");
testport->SetIceTiebreaker(kTiebreakerDefault);
testport->AddCandidateAddress(kLocalAddr1, kLocalAddr1, LOCAL_PORT_TYPE,
cricket::ICE_TYPE_PREFERENCE_HOST, false);
testport->AddCandidateAddress(kLocalAddr2, kLocalAddr1, STUN_PORT_TYPE,
@ -2743,8 +2757,11 @@ TEST_F(PortTest, TestCandidatePriority) {
// Test the Connection priority is calculated correctly.
TEST_F(PortTest, TestConnectionPriority) {
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
lport->SetIceTiebreaker(kTiebreakerDefault);
lport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_HOST);
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
rport->SetIceTiebreaker(kTiebreakerDefault);
rport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_RELAY_UDP);
lport->set_component(123);
lport->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
@ -3629,6 +3646,7 @@ TEST_F(PortTest, TestSupportsProtocol) {
// on both the port itself and its candidates.
TEST_F(PortTest, TestSetIceParameters) {
auto port = CreateTestPort(kLocalAddr1, "ufrag1", "password1");
port->SetIceTiebreaker(kTiebreakerDefault);
port->PrepareAddress();
EXPECT_EQ(1UL, port->Candidates().size());
port->SetIceParameters(1, "ufrag2", "password2");
@ -3643,6 +3661,7 @@ TEST_F(PortTest, TestSetIceParameters) {
TEST_F(PortTest, TestAddConnectionWithSameAddress) {
auto port = CreateTestPort(kLocalAddr1, "ufrag1", "password1");
port->SetIceTiebreaker(kTiebreakerDefault);
port->PrepareAddress();
EXPECT_EQ(1u, port->Candidates().size());
rtc::SocketAddress address("1.1.1.1", 5000);

2
p2p/base/regathering_controller_unittest.cc
View File

@ -39,6 +39,7 @@ const rtc::SocketAddress kTurnUdpIntAddr("99.99.99.3",
const cricket::RelayCredentials kRelayCredentials("test", "test");
const char kIceUfrag[] = "UF00";
const char kIcePwd[] = "TESTICEPWD00000000000000";
constexpr uint64_t kTiebreakerDefault = 44444;
} // namespace
@ -56,6 +57,7 @@ class RegatheringControllerTest : public ::testing::Test,
allocator_(std::make_unique<cricket::FakePortAllocator>(
rtc::Thread::Current(),
packet_socket_factory_.get())) {
allocator_->SetIceTiebreaker(kTiebreakerDefault);
BasicRegatheringController::Config regathering_config;
regathering_config.regather_on_failed_networks_interval = 0;
regathering_controller_.reset(new BasicRegatheringController(

4
p2p/base/stun_port_unittest.cc
View File

@ -59,6 +59,8 @@ static const uint32_t kIPv6StunCandidatePriority =
static const int kInfiniteLifetime = -1;
static const int kHighCostPortKeepaliveLifetimeMs = 2 * 60 * 1000;
constexpr uint64_t kTiebreakerDefault = 44444;
// A PacketSocketFactory implementation that uses a mock DnsResolver and allows
// setting expectations on the resolver and results.
class MockDnsResolverPacketSocketFactory
@ -141,6 +143,7 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
rtc::Thread::Current(), socket_factory(), &network_, 0, 0,
rtc::CreateRandomString(16), rtc::CreateRandomString(22), stun_servers,
absl::nullopt, field_trials);
stun_port_->SetIceTiebreaker(kTiebreakerDefault);
stun_port_->set_stun_keepalive_delay(stun_keepalive_delay_);
// If `stun_keepalive_lifetime_` is negative, let the stun port
// choose its lifetime from the network type.
@ -171,6 +174,7 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
rtc::CreateRandomString(16), rtc::CreateRandomString(22), false,
absl::nullopt, field_trials);
ASSERT_TRUE(stun_port_ != NULL);
stun_port_->SetIceTiebreaker(kTiebreakerDefault);
ServerAddresses stun_servers;
stun_servers.insert(server_addr);
stun_port_->set_server_addresses(stun_servers);

10
p2p/base/tcp_port_unittest.cc
View File

@ -43,6 +43,8 @@ static const SocketAddress kRemoteAddr("22.22.22.22", 0);
static const SocketAddress kRemoteIPv6Addr("2401:fa00:4:1000:be30:5bff:fee5:c4",
0);
constexpr uint64_t kTiebreakerDefault = 44444;
class ConnectionObserver : public sigslot::has_slots<> {
public:
explicit ConnectionObserver(Connection* conn) : conn_(conn) {
@ -81,15 +83,19 @@ class TCPPortTest : public ::testing::Test, public sigslot::has_slots<> {
}
std::unique_ptr<TCPPort> CreateTCPPort(const SocketAddress& addr) {
return std::unique_ptr<TCPPort>(
auto port = std::unique_ptr<TCPPort>(
TCPPort::Create(&main_, &socket_factory_, MakeNetwork(addr), 0, 0,
username_, password_, true, &field_trials_));
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
std::unique_ptr<TCPPort> CreateTCPPort(const rtc::Network* network) {
return std::unique_ptr<TCPPort>(
auto port = std::unique_ptr<TCPPort>(
TCPPort::Create(&main_, &socket_factory_, network, 0, 0, username_,
password_, true, &field_trials_));
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
protected:

5
p2p/base/turn_port_unittest.cc
View File

@ -95,6 +95,8 @@ static constexpr unsigned int kConnectionDestructionDelay = 1;
// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5191
static constexpr unsigned int kResolverTimeout = 10000;
constexpr uint64_t kTiebreakerDefault = 44444;
static const cricket::ProtocolAddress kTurnUdpProtoAddr(kTurnUdpIntAddr,
cricket::PROTO_UDP);
static const cricket::ProtocolAddress kTurnTcpProtoAddr(kTurnTcpIntAddr,
@ -293,6 +295,7 @@ class TurnPortTest : public ::testing::Test,
}
// This TURN port will be the controlling.
turn_port_->SetIceRole(ICEROLE_CONTROLLING);
turn_port_->SetIceTiebreaker(kTiebreakerDefault);
ConnectSignals();
if (server_address.proto == cricket::PROTO_TLS) {
@ -333,6 +336,7 @@ class TurnPortTest : public ::testing::Test,
turn_port_ = TurnPort::Create(args, socket_.get());
// This TURN port will be the controlling.
turn_port_->SetIceRole(ICEROLE_CONTROLLING);
turn_port_->SetIceTiebreaker(kTiebreakerDefault);
ConnectSignals();
}
@ -357,6 +361,7 @@ class TurnPortTest : public ::testing::Test,
absl::nullopt, &field_trials_);
// UDP port will be controlled.
udp_port_->SetIceRole(ICEROLE_CONTROLLED);
udp_port_->SetIceTiebreaker(kTiebreakerDefault);
udp_port_->SignalPortComplete.connect(this,
&TurnPortTest::OnUdpPortComplete);
}

5
p2p/client/basic_port_allocator_unittest.cc
View File

@ -111,6 +111,8 @@ static const char kTurnPassword[] = "test";
// Add some margin of error for slow bots.
static const int kStunTimeoutMs = cricket::STUN_TOTAL_TIMEOUT;
constexpr uint64_t kTiebreakerDefault = 44444;
namespace {
void CheckStunKeepaliveIntervalOfAllReadyPorts(
@ -174,6 +176,7 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
stun_servers, &field_trials_);
allocator_->Initialize();
allocator_->set_step_delay(kMinimumStepDelay);
allocator_->SetIceTiebreaker(kTiebreakerDefault);
webrtc::metrics::Reset();
}
@ -212,6 +215,7 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
&network_manager_,
std::make_unique<rtc::BasicPacketSocketFactory>(fss_.get())));
allocator_->Initialize();
allocator_->SetIceTiebreaker(kTiebreakerDefault);
allocator_->set_step_delay(kMinimumStepDelay);
}
// Endpoint is behind a NAT, with STUN specified.
@ -296,6 +300,7 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
this, &BasicPortAllocatorTestBase::OnCandidatesRemoved);
session->SignalCandidatesAllocationDone.connect(
this, &BasicPortAllocatorTestBase::OnCandidatesAllocationDone);
session->set_ice_tiebreaker(kTiebreakerDefault);
return session;
}

2
pc/peer_connection_ice_unittest.cc
View File

@ -85,6 +85,7 @@ using ::testing::Values;
constexpr int kIceCandidatesTimeout = 10000;
constexpr int64_t kWaitTimeout = 10000;
constexpr uint64_t kTiebreakerDefault = 44444;
class PeerConnectionWrapperForIceTest : public PeerConnectionWrapper {
public:
@ -1426,6 +1427,7 @@ class PeerConnectionIceConfigTest : public ::testing::Test {
new cricket::FakePortAllocator(rtc::Thread::Current(),
packet_socket_factory_.get()));
port_allocator_ = port_allocator.get();
port_allocator_->SetIceTiebreaker(kTiebreakerDefault);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.allocator = std::move(port_allocator);
auto result = pc_factory_->CreatePeerConnectionOrError(

2
pc/peer_connection_interface_unittest.cc
View File

@ -106,6 +106,7 @@ static const char kVideoTracks[][32] = {"videotrack0", "videotrack1"};
static const char kRecvonly[] = "recvonly";
static const char kSendrecv[] = "sendrecv";
constexpr uint64_t kTiebreakerDefault = 44444;
// Reference SDP with a MediaStream with label "stream1" and audio track with
// id "audio_1" and a video track with id "video_1;
@ -734,6 +735,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
rtc::Thread::Current(),
std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())));
port_allocator_ = port_allocator.get();
port_allocator_->SetIceTiebreaker(kTiebreakerDefault);
// Create certificate generator unless DTLS constraint is explicitly set to
// false.