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

Revert "Add RelayPortFactoryInterface that allows for custom relay (e.g turn) ports"

Browse Source 
This reverts commit 26246cac660a95f439b7d1c593edec2929806d3f.

Reason for revert: Introduces compile failure on MSVC, which is preventing rolls into Chromium.

Sample errors:
[12263/40346] CXX obj/third_party/webrtc/p2p/rtc_p2p/stun.obj
FAILED: obj/third_party/webrtc/p2p/rtc_p2p/stun.obj 
ninja -t msvc -e environment.x64 -- E:\b\c\goma_client/gomacc.exe "e:\b\c\win_toolchain\vs_files\a9e1098bba66d2acccc377d5ee81265910f29272\vc\tools\msvc\14.11.25503\bin\hostx64\x64/cl.exe" /nologo /showIncludes  @obj/third_party/webrtc/p2p/rtc_p2p/stun.obj.rsp /c ../../third_party/webrtc/p2p/base/stun.cc /Foobj/third_party/webrtc/p2p/rtc_p2p/stun.obj /Fd"obj/third_party/webrtc/p2p/rtc_p2p_cc.pdb"
../../third_party/webrtc/p2p/base/stun.cc(1018): error C2220: warning treated as error - no 'object' file generated
../../third_party/webrtc/p2p/base/stun.cc(1018): warning C4267: 'argument': conversion from 'size_t' to 'uint16_t', possible loss of data
  

Original change's description:
> Add RelayPortFactoryInterface that allows for custom relay (e.g turn) ports
> 
> This patch adds a RelayPortFactoryInterface that allows
> for custom relay ports. The factor is added as optional argument
> to BasicPortAlloctor. If none is provided a default implementation
> that mimics existing behavior is created.
> 
> The patch also adds 2 stun functions, namely to copy a
> StunAttribute and to remove StunAttribute's from a StunMessage.
> 
> Bug: webrtc:8640
> Change-Id: I59bd51f0f5e2f8c187dff9fcf003a24c35ed037f
> Reviewed-on: https://webrtc-review.googlesource.com/32600
> Commit-Queue: Jonas Oreland <jonaso@webrtc.org>
> Reviewed-by: Peter Thatcher <pthatcher@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#21267}

TBR=jonaso@webrtc.org,pthatcher@webrtc.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: webrtc:8640
Change-Id: Idf83a1111727d2b5188b9c123f7471be7e99e973
Reviewed-on: https://webrtc-review.googlesource.com/33600
Reviewed-by: Guido Urdaneta <guidou@webrtc.org>
Commit-Queue: Guido Urdaneta <guidou@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21304}
This commit is contained in:
Guido Urdaneta 2017-12-15 17:47:37 +00:00 committed by Commit Bot
parent 3bb8781115
commit f1a7a8c602
13 changed files with 40 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
p2p/BUILD.gn
View File

@ -81,11 +81,8 @@ rtc_static_library("rtc_p2p") {
"base/udptransport.h", "base/udptransport.h",
"client/basicportallocator.cc", "client/basicportallocator.cc",
"client/basicportallocator.h", "client/basicportallocator.h",
"client/relayportfactoryinterface.h",
"client/socketmonitor.cc", "client/socketmonitor.cc",
"client/socketmonitor.h", "client/socketmonitor.h",
"client/turnportfactory.cc",
"client/turnportfactory.h",
] ]
defines = [] defines = []

4
p2p/base/port.cc
View File

@ -621,10 +621,6 @@ bool Port::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
return false; return false;
} }
bool Port::CanHandleIncomingPacketsFrom(const rtc::SocketAddress&) const {
return false;
}
void Port::SendBindingResponse(StunMessage* request, void Port::SendBindingResponse(StunMessage* request,
const rtc::SocketAddress& addr) { const rtc::SocketAddress& addr) {
RTC_DCHECK(request->type() == STUN_BINDING_REQUEST); RTC_DCHECK(request->type() == STUN_BINDING_REQUEST);

5
p2p/base/port.h
View File

@ -254,11 +254,6 @@ class Port : public PortInterface, public rtc::MessageHandler,
const rtc::SocketAddress& remote_addr, const rtc::SocketAddress& remote_addr,
const rtc::PacketTime& packet_time); const rtc::PacketTime& packet_time);
// Shall the port handle packet from this |remote_addr|.
// This method is overridden by TurnPort.
virtual bool CanHandleIncomingPacketsFrom(
const rtc::SocketAddress& remote_addr) const;
// Sends a response message (normal or error) to the given request. One of // Sends a response message (normal or error) to the given request. One of
// these methods should be called as a response to SignalUnknownAddress. // these methods should be called as a response to SignalUnknownAddress.
// NOTE: You MUST call CreateConnection BEFORE SendBindingResponse. // NOTE: You MUST call CreateConnection BEFORE SendBindingResponse.

48
p2p/base/stun.cc
View File

@ -92,26 +92,6 @@ void StunMessage::AddAttribute(std::unique_ptr<StunAttribute> attr) {
attrs_.push_back(std::move(attr)); attrs_.push_back(std::move(attr));
} }
std::unique_ptr<StunAttribute> StunMessage::RemoveAttribute(int type) {
std::unique_ptr<StunAttribute> attribute;
for (auto it = attrs_.rbegin(); it != attrs_.rend(); ++it) {
if ((* it)->type() == type) {
attribute = std::move(* it);
attrs_.erase(std::next(it).base());
break;
}
}
if (attribute) {
attribute->SetOwner(nullptr);
size_t attr_length = attribute->length();
if (attr_length % 4 != 0) {
attr_length += (4 - (attr_length % 4));
}
length_ -= static_cast<uint16_t>(attr_length + 4);
}
return attribute;
}
const StunAddressAttribute* StunMessage::GetAddress(int type) const { const StunAddressAttribute* StunMessage::GetAddress(int type) const {
switch (type) { switch (type) {
case STUN_ATTR_MAPPED_ADDRESS: { case STUN_ATTR_MAPPED_ADDRESS: {
@ -1004,34 +984,6 @@ bool ComputeStunCredentialHash(const std::string& username,
return true; return true;
} }
std::unique_ptr<StunAttribute> CopyStunAttribute(
const StunAttribute& attribute,
rtc::ByteBufferWriter* tmp_buffer_ptr) {
ByteBufferWriter tmpBuffer;
if (tmp_buffer_ptr == nullptr) {
tmp_buffer_ptr = &tmpBuffer;
}
std::unique_ptr<StunAttribute> copy(
StunAttribute::Create(attribute.value_type(),
attribute.type(),
attribute.length(), nullptr));
if (!copy) {
return nullptr;
}
tmp_buffer_ptr->Clear();
if (!attribute.Write(tmp_buffer_ptr)) {
return nullptr;
}
rtc::ByteBufferReader reader(*tmp_buffer_ptr);
if (!copy->Read(&reader)) {
return nullptr;
}
return copy;
}
StunAttributeValueType RelayMessage::GetAttributeValueType(int type) const { StunAttributeValueType RelayMessage::GetAttributeValueType(int type) const {
switch (type) { switch (type) {
case STUN_ATTR_LIFETIME: case STUN_ATTR_LIFETIME:

15
p2p/base/stun.h
View File

@ -165,9 +165,6 @@ class StunMessage {
// Takes ownership of the specified attribute and adds it to the message. // Takes ownership of the specified attribute and adds it to the message.
void AddAttribute(std::unique_ptr<StunAttribute> attr); void AddAttribute(std::unique_ptr<StunAttribute> attr);
// Remove the last occurrence of an attribute.
std::unique_ptr<StunAttribute> RemoveAttribute(int type);
// Validates that a raw STUN message has a correct MESSAGE-INTEGRITY value. // Validates that a raw STUN message has a correct MESSAGE-INTEGRITY value.
// This can't currently be done on a StunMessage, since it is affected by // This can't currently be done on a StunMessage, since it is affected by
// padding data (which we discard when reading a StunMessage). // padding data (which we discard when reading a StunMessage).
@ -480,18 +477,6 @@ bool IsStunErrorResponseType(int msg_type);
bool ComputeStunCredentialHash(const std::string& username, bool ComputeStunCredentialHash(const std::string& username,
const std::string& realm, const std::string& password, std::string* hash); const std::string& realm, const std::string& password, std::string* hash);
// Make a copy af |attribute| and return a new StunAttribute.
// This is useful if you don't care about what kind of attribute you
// are handling.
//
// The implementation copies by calling Write() followed by Read().
//
// If |tmp_buffer| is supplied this buffer will be used, otherwise
// a buffer will created in the method.
std::unique_ptr<StunAttribute> CopyStunAttribute(
const StunAttribute& attribute,
rtc::ByteBufferWriter* tmp_buffer_ptr = 0);
// TODO(?): Move the TURN/ICE stuff below out to separate files. // TODO(?): Move the TURN/ICE stuff below out to separate files.
extern const char TURN_MAGIC_COOKIE_VALUE[4]; extern const char TURN_MAGIC_COOKIE_VALUE[4];

90
p2p/base/stun_unittest.cc
View File

@ -1480,94 +1480,4 @@ TEST_F(StunTest, ReadRelayMessage) {
EXPECT_EQ(0, memcmp(outstring2.c_str(), input, len2)); EXPECT_EQ(0, memcmp(outstring2.c_str(), input, len2));
} }
// Test that we can remove attribute from a message.
TEST_F(StunTest, RemoveAttribute) {
StunMessage msg;
// Removing something that does exist should return nullptr.
EXPECT_EQ(msg.RemoveAttribute(STUN_ATTR_USERNAME), nullptr);
{
auto attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
attr->CopyBytes("kes", sizeof("kes"));
msg.AddAttribute(std::move(attr));
}
size_t len = msg.length();
{
auto attr = msg.RemoveAttribute(STUN_ATTR_USERNAME);
ASSERT_NE(attr, nullptr);
EXPECT_EQ(attr->type(), STUN_ATTR_USERNAME);
EXPECT_STREQ("kes",
static_cast<StunByteStringAttribute*>(attr.get())->bytes());
EXPECT_LT(msg.length(), len);
}
// Now add same attribute type twice.
{
auto attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
attr->CopyBytes("kes", sizeof("kes"));
msg.AddAttribute(std::move(attr));
}
{
auto attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
attr->CopyBytes("kenta", sizeof("kenta"));
msg.AddAttribute(std::move(attr));
}
// Remove should remove the last added occurrence.
{
auto attr = msg.RemoveAttribute(STUN_ATTR_USERNAME);
ASSERT_NE(attr, nullptr);
EXPECT_EQ(attr->type(), STUN_ATTR_USERNAME);
EXPECT_STREQ("kenta",
static_cast<StunByteStringAttribute*>(attr.get())->bytes());
}
// Remove should remove the last added occurrence.
{
auto attr = msg.RemoveAttribute(STUN_ATTR_USERNAME);
ASSERT_NE(attr, nullptr);
EXPECT_EQ(attr->type(), STUN_ATTR_USERNAME);
EXPECT_STREQ("kes",
static_cast<StunByteStringAttribute*>(attr.get())->bytes());
}
// Removing something that does exist should return nullptr.
EXPECT_EQ(msg.RemoveAttribute(STUN_ATTR_USERNAME), nullptr);
}
// Test CopyStunAttribute
TEST_F(StunTest, CopyAttribute) {
rtc::ByteBufferWriter buf;
rtc::ByteBufferWriter* buffer_ptrs[] = { &buf, nullptr };
// Test both with and without supplied ByteBufferWriter.
for (auto buffer_ptr : buffer_ptrs) {
{ // Test StunByteStringAttribute.
auto attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
attr->CopyBytes("kes", sizeof("kes"));
auto copy = CopyStunAttribute(*attr.get(), buffer_ptr);
ASSERT_EQ(copy->value_type(), STUN_VALUE_BYTE_STRING);
EXPECT_STREQ("kes",
static_cast<StunByteStringAttribute*>(copy.get())->bytes());
}
{ // Test StunAddressAttribute.
rtc::IPAddress test_ip(kIPv6TestAddress2);
auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
addr->SetAddress(test_addr);
CheckStunAddressAttribute(addr.get(),
STUN_ADDRESS_IPV6, kTestMessagePort2, test_ip);
auto copy = CopyStunAttribute(*addr.get(), buffer_ptr);
ASSERT_EQ(copy->value_type(), STUN_VALUE_ADDRESS);
CheckStunAddressAttribute(static_cast<StunAddressAttribute*>(copy.get()),
STUN_ADDRESS_IPV6, kTestMessagePort2, test_ip);
}
}
}
} // namespace cricket } // namespace cricket

18
p2p/base/turnport.cc
View File

@ -523,11 +523,7 @@ Connection* TurnPort::CreateConnection(const Candidate& remote_candidate,
remote_candidate.address().family()) { remote_candidate.address().family()) {
// Create an entry, if needed, so we can get our permissions set up // Create an entry, if needed, so we can get our permissions set up
// correctly. // correctly.
if (CreateOrRefreshEntry(remote_candidate.address(), CreateOrRefreshEntry(remote_candidate.address());
next_channel_number_)) {
// An entry was created.
next_channel_number_++;
}
ProxyConnection* conn = ProxyConnection* conn =
new ProxyConnection(this, index, remote_candidate); new ProxyConnection(this, index, remote_candidate);
AddOrReplaceConnection(conn); AddOrReplaceConnection(conn);
@ -600,11 +596,6 @@ int TurnPort::SendTo(const void* data, size_t size,
return static_cast<int>(size); return static_cast<int>(size);
} }
bool TurnPort::CanHandleIncomingPacketsFrom(
const rtc::SocketAddress& addr) const {
return server_address_.address == addr;
}
bool TurnPort::HandleIncomingPacket(rtc::AsyncPacketSocket* socket, bool TurnPort::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
const char* data, size_t size, const char* data, size_t size,
const rtc::SocketAddress& remote_addr, const rtc::SocketAddress& remote_addr,
@ -1079,13 +1070,11 @@ bool TurnPort::EntryExists(TurnEntry* e) {
return it != entries_.end(); return it != entries_.end();
} }
bool TurnPort::CreateOrRefreshEntry(const rtc::SocketAddress& addr, void TurnPort::CreateOrRefreshEntry(const rtc::SocketAddress& addr) {
int channel_number) {
TurnEntry* entry = FindEntry(addr); TurnEntry* entry = FindEntry(addr);
if (entry == nullptr) { if (entry == nullptr) {
entry = new TurnEntry(this, channel_number, addr); entry = new TurnEntry(this, next_channel_number_++, addr);
entries_.push_back(entry); entries_.push_back(entry);
return true;
} else { } else {
if (entry->destruction_timestamp()) { if (entry->destruction_timestamp()) {
// Destruction should have only been scheduled (indicated by // Destruction should have only been scheduled (indicated by
@ -1103,7 +1092,6 @@ bool TurnPort::CreateOrRefreshEntry(const rtc::SocketAddress& addr,
RTC_DCHECK(GetConnection(addr)); RTC_DCHECK(GetConnection(addr));
} }
} }
return false;
} }
void TurnPort::DestroyEntry(TurnEntry* entry) { void TurnPort::DestroyEntry(TurnEntry* entry) {

11
p2p/base/turnport.h
View File

@ -124,8 +124,6 @@ class TurnPort : public Port {
size_t size, size_t size,
const rtc::SocketAddress& remote_addr, const rtc::SocketAddress& remote_addr,
const rtc::PacketTime& packet_time) override; const rtc::PacketTime& packet_time) override;
bool CanHandleIncomingPacketsFrom(
const rtc::SocketAddress& addr) const override;
virtual void OnReadPacket(rtc::AsyncPacketSocket* socket, virtual void OnReadPacket(rtc::AsyncPacketSocket* socket,
const char* data, size_t size, const char* data, size_t size,
const rtc::SocketAddress& remote_addr, const rtc::SocketAddress& remote_addr,
@ -177,8 +175,6 @@ class TurnPort : public Port {
// Shuts down the turn port, usually because of some fatal errors. // Shuts down the turn port, usually because of some fatal errors.
void Close(); void Close();
void HandleConnectionDestroyed(Connection* conn) override;
protected: protected:
TurnPort(rtc::Thread* thread, TurnPort(rtc::Thread* thread,
rtc::PacketSocketFactory* factory, rtc::PacketSocketFactory* factory,
@ -207,11 +203,6 @@ class TurnPort : public Port {
const std::vector<std::string>& tls_elliptic_curves, const std::vector<std::string>& tls_elliptic_curves,
webrtc::TurnCustomizer* customizer); webrtc::TurnCustomizer* customizer);
// NOTE: This method needs to be accessible for StacPort
// return true if entry was created (i.e channel_number consumed).
bool CreateOrRefreshEntry(const rtc::SocketAddress& addr,
int channel_number);
private: private:
enum { enum {
MSG_ALLOCATE_ERROR = MSG_FIRST_AVAILABLE, MSG_ALLOCATE_ERROR = MSG_FIRST_AVAILABLE,
@ -225,6 +216,7 @@ class TurnPort : public Port {
typedef std::set<rtc::SocketAddress> AttemptedServerSet; typedef std::set<rtc::SocketAddress> AttemptedServerSet;
void OnMessage(rtc::Message* pmsg) override; void OnMessage(rtc::Message* pmsg) override;
void HandleConnectionDestroyed(Connection* conn) override;
bool CreateTurnClientSocket(); bool CreateTurnClientSocket();
@ -272,6 +264,7 @@ class TurnPort : public Port {
TurnEntry* FindEntry(const rtc::SocketAddress& address) const; TurnEntry* FindEntry(const rtc::SocketAddress& address) const;
TurnEntry* FindEntry(int channel_id) const; TurnEntry* FindEntry(int channel_id) const;
bool EntryExists(TurnEntry* e); bool EntryExists(TurnEntry* e);
void CreateOrRefreshEntry(const rtc::SocketAddress& address);
void DestroyEntry(TurnEntry* entry); void DestroyEntry(TurnEntry* entry);
// Destroys the entry only if |timestamp| matches the destruction timestamp // Destroys the entry only if |timestamp| matches the destruction timestamp
// in |entry|. // in |entry|.

94
p2p/client/basicportallocator.cc
View File

@ -100,11 +100,8 @@ const uint32_t DISABLE_ALL_PHASES =
BasicPortAllocator::BasicPortAllocator( BasicPortAllocator::BasicPortAllocator(
rtc::NetworkManager* network_manager, rtc::NetworkManager* network_manager,
rtc::PacketSocketFactory* socket_factory, rtc::PacketSocketFactory* socket_factory,
webrtc::TurnCustomizer* customizer, webrtc::TurnCustomizer* customizer)
RelayPortFactoryInterface* relay_port_factory)
: network_manager_(network_manager), socket_factory_(socket_factory) { : network_manager_(network_manager), socket_factory_(socket_factory) {
InitRelayPortFactory(relay_port_factory);
RTC_DCHECK(relay_port_factory_ != nullptr);
RTC_DCHECK(network_manager_ != nullptr); RTC_DCHECK(network_manager_ != nullptr);
RTC_DCHECK(socket_factory_ != nullptr); RTC_DCHECK(socket_factory_ != nullptr);
SetConfiguration(ServerAddresses(), std::vector<RelayServerConfig>(), SetConfiguration(ServerAddresses(), std::vector<RelayServerConfig>(),
@ -112,22 +109,16 @@ BasicPortAllocator::BasicPortAllocator(
Construct(); Construct();
} }
BasicPortAllocator::BasicPortAllocator( BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager)
rtc::NetworkManager* network_manager)
: network_manager_(network_manager), socket_factory_(nullptr) { : network_manager_(network_manager), socket_factory_(nullptr) {
InitRelayPortFactory(nullptr);
RTC_DCHECK(relay_port_factory_ != nullptr);
RTC_DCHECK(network_manager_ != nullptr); RTC_DCHECK(network_manager_ != nullptr);
Construct(); Construct();
} }
BasicPortAllocator::BasicPortAllocator( BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager,
rtc::NetworkManager* network_manager,
rtc::PacketSocketFactory* socket_factory, rtc::PacketSocketFactory* socket_factory,
const ServerAddresses& stun_servers) const ServerAddresses& stun_servers)
: network_manager_(network_manager), socket_factory_(socket_factory) { : network_manager_(network_manager), socket_factory_(socket_factory) {
InitRelayPortFactory(nullptr);
RTC_DCHECK(relay_port_factory_ != nullptr);
RTC_DCHECK(socket_factory_ != NULL); RTC_DCHECK(socket_factory_ != NULL);
SetConfiguration(stun_servers, std::vector<RelayServerConfig>(), 0, false, SetConfiguration(stun_servers, std::vector<RelayServerConfig>(), 0, false,
nullptr); nullptr);
@ -141,9 +132,6 @@ BasicPortAllocator::BasicPortAllocator(
const rtc::SocketAddress& relay_address_tcp, const rtc::SocketAddress& relay_address_tcp,
const rtc::SocketAddress& relay_address_ssl) const rtc::SocketAddress& relay_address_ssl)
: network_manager_(network_manager), socket_factory_(NULL) { : network_manager_(network_manager), socket_factory_(NULL) {
InitRelayPortFactory(nullptr);
RTC_DCHECK(relay_port_factory_ != nullptr);
RTC_DCHECK(network_manager_ != nullptr);
std::vector<RelayServerConfig> turn_servers; std::vector<RelayServerConfig> turn_servers;
RelayServerConfig config(RELAY_GTURN); RelayServerConfig config(RELAY_GTURN);
if (!relay_address_udp.IsNil()) { if (!relay_address_udp.IsNil()) {
@ -216,16 +204,6 @@ void BasicPortAllocator::AddTurnServer(const RelayServerConfig& turn_server) {
prune_turn_ports(), turn_customizer()); prune_turn_ports(), turn_customizer());
} }
void BasicPortAllocator::InitRelayPortFactory(
RelayPortFactoryInterface* relay_port_factory) {
if (relay_port_factory != nullptr) {
relay_port_factory_ = relay_port_factory;
} else {
default_relay_port_factory_.reset(new TurnPortFactory());
relay_port_factory_ = default_relay_port_factory_.get();
}
}
// BasicPortAllocatorSession // BasicPortAllocatorSession
BasicPortAllocatorSession::BasicPortAllocatorSession( BasicPortAllocatorSession::BasicPortAllocatorSession(
BasicPortAllocator* allocator, BasicPortAllocator* allocator,
@ -1129,7 +1107,7 @@ void AllocationSequence::Init() {
void AllocationSequence::Clear() { void AllocationSequence::Clear() {
udp_port_ = NULL; udp_port_ = NULL;
relay_ports_.clear(); turn_ports_.clear();
} }
void AllocationSequence::OnNetworkFailed() { void AllocationSequence::OnNetworkFailed() {
@ -1409,6 +1387,8 @@ void AllocationSequence::CreateTurnPort(const RelayServerConfig& config) {
PortList::const_iterator relay_port; PortList::const_iterator relay_port;
for (relay_port = config.ports.begin(); for (relay_port = config.ports.begin();
relay_port != config.ports.end(); ++relay_port) { relay_port != config.ports.end(); ++relay_port) {
TurnPort* port = NULL;
// Skip UDP connections to relay servers if it's disallowed. // Skip UDP connections to relay servers if it's disallowed.
if (IsFlagSet(PORTALLOCATOR_DISABLE_UDP_RELAY) && if (IsFlagSet(PORTALLOCATOR_DISABLE_UDP_RELAY) &&
relay_port->proto == PROTO_UDP) { relay_port->proto == PROTO_UDP) {
@ -1427,53 +1407,35 @@ void AllocationSequence::CreateTurnPort(const RelayServerConfig& config) {
continue; continue;
} }
CreateRelayPortArgs args;
args.network_thread = session_->network_thread();
args.socket_factory = session_->socket_factory();
args.network = network_;
args.username = session_->username();
args.password = session_->password();
args.server_address = &(*relay_port);
args.config = &config;
args.origin = session_->allocator()->origin();
args.turn_customizer = session_->allocator()->turn_customizer();
std::unique_ptr<cricket::Port> port;
// Shared socket mode must be enabled only for UDP based ports. Hence // Shared socket mode must be enabled only for UDP based ports. Hence
// don't pass shared socket for ports which will create TCP sockets. // don't pass shared socket for ports which will create TCP sockets.
// TODO(mallinath) - Enable shared socket mode for TURN ports. Disabled // TODO(mallinath) - Enable shared socket mode for TURN ports. Disabled
// due to webrtc bug https://code.google.com/p/webrtc/issues/detail?id=3537 // due to webrtc bug https://code.google.com/p/webrtc/issues/detail?id=3537
if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) && if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) &&
relay_port->proto == PROTO_UDP && udp_socket_) { relay_port->proto == PROTO_UDP && udp_socket_) {
port = session_->allocator()->relay_port_factory()->Create( port = TurnPort::Create(session_->network_thread(),
args, udp_socket_.get()); session_->socket_factory(),
network_, udp_socket_.get(),
if (!port) { session_->username(), session_->password(),
RTC_LOG(LS_WARNING) *relay_port, config.credentials, config.priority,
<< "Failed to create relay port with " session_->allocator()->origin(),
<< args.server_address->address.ToString(); session_->allocator()->turn_customizer());
continue; turn_ports_.push_back(port);
}
relay_ports_.push_back(port.get());
// Listen to the port destroyed signal, to allow AllocationSequence to // Listen to the port destroyed signal, to allow AllocationSequence to
// remove entrt from it's map. // remove entrt from it's map.
port->SignalDestroyed.connect(this, &AllocationSequence::OnPortDestroyed); port->SignalDestroyed.connect(this, &AllocationSequence::OnPortDestroyed);
} else { } else {
port = session_->allocator()->relay_port_factory()->Create( port = TurnPort::Create(
args, session_->network_thread(), session_->socket_factory(), network_,
session_->allocator()->min_port(), session_->allocator()->min_port(), session_->allocator()->max_port(),
session_->allocator()->max_port()); session_->username(), session_->password(), *relay_port,
config.credentials, config.priority, session_->allocator()->origin(),
if (!port) { config.tls_alpn_protocols, config.tls_elliptic_curves,
RTC_LOG(LS_WARNING) session_->allocator()->turn_customizer());
<< "Failed to create relay port with "
<< args.server_address->address.ToString();
continue;
}
} }
RTC_DCHECK(port != NULL); RTC_DCHECK(port != NULL);
session_->AddAllocatedPort(port.release(), this, true); port->SetTlsCertPolicy(config.tls_cert_policy);
session_->AddAllocatedPort(port, this, true);
} }
} }
@ -1491,8 +1453,8 @@ void AllocationSequence::OnReadPacket(
// a STUN binding response, so we pass the message to TurnPort regardless of // a STUN binding response, so we pass the message to TurnPort regardless of
// the message type. The TurnPort will just ignore the message since it will // the message type. The TurnPort will just ignore the message since it will
// not find any request by transaction ID. // not find any request by transaction ID.
for (auto* port : relay_ports_) { for (TurnPort* port : turn_ports_) {
if (port->CanHandleIncomingPacketsFrom(remote_addr)) { if (port->server_address().address == remote_addr) {
if (port->HandleIncomingPacket(socket, data, size, remote_addr, if (port->HandleIncomingPacket(socket, data, size, remote_addr,
packet_time)) { packet_time)) {
return; return;
@ -1521,9 +1483,9 @@ void AllocationSequence::OnPortDestroyed(PortInterface* port) {
return; return;
} }
auto it = std::find(relay_ports_.begin(), relay_ports_.end(), port); auto it = std::find(turn_ports_.begin(), turn_ports_.end(), port);
if (it != relay_ports_.end()) { if (it != turn_ports_.end()) {
relay_ports_.erase(it); turn_ports_.erase(it);
} else { } else {
RTC_LOG(LS_ERROR) << "Unexpected OnPortDestroyed for nonexistent port."; RTC_LOG(LS_ERROR) << "Unexpected OnPortDestroyed for nonexistent port.";
RTC_NOTREACHED(); RTC_NOTREACHED();

28
p2p/client/basicportallocator.h
View File

@ -17,8 +17,6 @@
#include "api/turncustomizer.h" #include "api/turncustomizer.h"
#include "p2p/base/portallocator.h" #include "p2p/base/portallocator.h"
#include "p2p/client/turnportfactory.h"
#include "p2p/client/relayportfactoryinterface.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/messagequeue.h" #include "rtc_base/messagequeue.h"
#include "rtc_base/network.h" #include "rtc_base/network.h"
@ -28,21 +26,18 @@ namespace cricket {
class BasicPortAllocator : public PortAllocator { class BasicPortAllocator : public PortAllocator {
public: 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, BasicPortAllocator(rtc::NetworkManager* network_manager,
rtc::PacketSocketFactory* socket_factory, rtc::PacketSocketFactory* socket_factory,
webrtc::TurnCustomizer* customizer = nullptr, webrtc::TurnCustomizer* customizer = nullptr);
RelayPortFactoryInterface* relay_port_factory = nullptr);
explicit BasicPortAllocator(rtc::NetworkManager* network_manager); explicit BasicPortAllocator(rtc::NetworkManager* network_manager);
BasicPortAllocator(rtc::NetworkManager* network_manager, BasicPortAllocator(rtc::NetworkManager* network_manager,
rtc::PacketSocketFactory* socket_factory, rtc::PacketSocketFactory* socket_factory,
const ServerAddresses& stun_servers); const ServerAddresses& stun_servers);
BasicPortAllocator(rtc::NetworkManager* network_manager, BasicPortAllocator(rtc::NetworkManager* network_manager,
const ServerAddresses& stun_servers, const ServerAddresses& stun_servers,
const rtc::SocketAddress& relay_address_udp, const rtc::SocketAddress& relay_server_udp,
const rtc::SocketAddress& relay_address_tcp, const rtc::SocketAddress& relay_server_tcp,
const rtc::SocketAddress& relay_address_ssl); const rtc::SocketAddress& relay_server_ssl);
~BasicPortAllocator() override; ~BasicPortAllocator() override;
// Set to kDefaultNetworkIgnoreMask by default. // Set to kDefaultNetworkIgnoreMask by default.
@ -64,29 +59,16 @@ class BasicPortAllocator : public PortAllocator {
// Convenience method that adds a TURN server to the configuration. // Convenience method that adds a TURN server to the configuration.
void AddTurnServer(const RelayServerConfig& turn_server); void AddTurnServer(const RelayServerConfig& turn_server);
RelayPortFactoryInterface* relay_port_factory() {
return relay_port_factory_;
}
private: private:
void Construct(); void Construct();
void OnIceRegathering(PortAllocatorSession* session, void OnIceRegathering(PortAllocatorSession* session,
IceRegatheringReason reason); IceRegatheringReason reason);
// This function makes sure that relay_port_factory_ is set properly.
void InitRelayPortFactory(RelayPortFactoryInterface* relay_port_factory);
rtc::NetworkManager* network_manager_; rtc::NetworkManager* network_manager_;
rtc::PacketSocketFactory* socket_factory_; rtc::PacketSocketFactory* socket_factory_;
bool allow_tcp_listen_; bool allow_tcp_listen_;
int network_ignore_mask_ = rtc::kDefaultNetworkIgnoreMask; 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; struct PortConfiguration;
@ -387,7 +369,7 @@ class AllocationSequence : public rtc::MessageHandler,
std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_; std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_;
// There will be only one udp port per AllocationSequence. // There will be only one udp port per AllocationSequence.
UDPPort* udp_port_; UDPPort* udp_port_;
std::vector<Port*> relay_ports_; std::vector<TurnPort*> turn_ports_;
int phase_; int phase_;
}; };

72
p2p/client/relayportfactoryinterface.h
View File

@ -1,72 +0,0 @@
/*
* Copyright 2017 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_RELAYPORTFACTORYINTERFACE_H_
#define P2P_CLIENT_RELAYPORTFACTORYINTERFACE_H_
#include <memory>
#include <string>
#include "p2p/base/portinterface.h"
#include "rtc_base/refcount.h"
namespace rtc {
class AsyncPacketSocket;
class Network;
class PacketSocketFactory;
class Thread;
} // namespace rtc
namespace webrtc {
class TurnCustomizer;
} // namespace webrtc
namespace cricket {
class Port;
struct ProtocolAddress;
struct RelayServerConfig;
// A struct containing arguments to RelayPortFactory::Create()
struct CreateRelayPortArgs {
CreateRelayPortArgs();
rtc::Thread* network_thread;
rtc::PacketSocketFactory* socket_factory;
rtc::Network* network;
const ProtocolAddress* server_address;
const RelayServerConfig* config;
std::string username;
std::string password;
std::string origin;
webrtc::TurnCustomizer* turn_customizer;
};
inline CreateRelayPortArgs::CreateRelayPortArgs() {}
// A factory for creating RelayPort's.
class RelayPortFactoryInterface {
public:
virtual ~RelayPortFactoryInterface() {}
// This variant is used for UDP connection to the relay server
// using a already existing shared socket.
virtual std::unique_ptr<Port> Create(
const CreateRelayPortArgs& args,
rtc::AsyncPacketSocket* udp_socket) = 0;
// This variant is used for the other cases.
virtual std::unique_ptr<Port> Create(
const CreateRelayPortArgs& args,
int min_port,
int max_port) = 0;
};
} // namespace cricket
#endif // P2P_CLIENT_RELAYPORTFACTORYINTERFACE_H_

66
p2p/client/turnportfactory.cc
View File

@ -1,66 +0,0 @@
/*
* Copyright 2017 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.
*/
#include "p2p/client/turnportfactory.h"
#include <memory>
#include "p2p/base/turnport.h"
namespace cricket {
TurnPortFactory::~TurnPortFactory() {
}
std::unique_ptr<Port> TurnPortFactory::Create(
const CreateRelayPortArgs& args,
rtc::AsyncPacketSocket* udp_socket) {
TurnPort* port = TurnPort::Create(
args.network_thread,
args.socket_factory,
args.network,
udp_socket,
args.username,
args.password,
*args.server_address,
args.config->credentials,
args.config->priority,
args.origin,
args.turn_customizer);
port->SetTlsCertPolicy(args.config->tls_cert_policy);
return std::unique_ptr<Port>(port);
}
std::unique_ptr<Port> TurnPortFactory::Create(
const CreateRelayPortArgs& args,
int min_port,
int max_port) {
TurnPort* port = TurnPort::Create(
args.network_thread,
args.socket_factory,
args.network,
min_port,
max_port,
args.username,
args.password,
*args.server_address,
args.config->credentials,
args.config->priority,
args.origin,
args.config->tls_alpn_protocols,
args.config->tls_elliptic_curves,
args.turn_customizer);
port->SetTlsCertPolicy(args.config->tls_cert_policy);
return std::unique_ptr<Port>(port);
}
} // namespace cricket

37
p2p/client/turnportfactory.h
View File

@ -1,37 +0,0 @@
/*
* Copyright 2017 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_TURNPORTFACTORY_H_
#define P2P_CLIENT_TURNPORTFACTORY_H_
#include <memory>
#include "p2p/client/relayportfactoryinterface.h"
namespace cricket {
// This is a RelayPortFactory that produces TurnPorts.
class TurnPortFactory : public RelayPortFactoryInterface {
public:
~TurnPortFactory() override;
std::unique_ptr<Port> Create(
const CreateRelayPortArgs& args,
rtc::AsyncPacketSocket* udp_socket) override;
std::unique_ptr<Port> Create(
const CreateRelayPortArgs& args,
int min_port,
int max_port) override;
};
} // namespace cricket
#endif // P2P_CLIENT_TURNPORTFACTORY_H_