Move socket_address.h to webrtc namespace
Bug: webrtc:42232595
Change-Id: I58a5a286887e66fad95c6acf146808623a76dd0d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/380842
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44111}
diff --git a/rtc_base/async_dns_resolver.cc b/rtc_base/async_dns_resolver.cc
index 5493548..f269e40 100644
--- a/rtc_base/async_dns_resolver.cc
+++ b/rtc_base/async_dns_resolver.cc
@@ -135,13 +135,13 @@
state_->Kill();
}
-void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
+void AsyncDnsResolver::Start(const SocketAddress& addr,
absl::AnyInvocable<void()> callback) {
Start(addr, addr.family(), std::move(callback));
}
// Start address resolution of the hostname in `addr` matching `family`.
-void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
+void AsyncDnsResolver::Start(const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) {
RTC_DCHECK_RUN_ON(&result_.sequence_checker_);
@@ -178,9 +178,8 @@
return result_;
}
-bool AsyncDnsResolverResultImpl::GetResolvedAddress(
- int family,
- rtc::SocketAddress* addr) const {
+bool AsyncDnsResolverResultImpl::GetResolvedAddress(int family,
+ SocketAddress* addr) const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DCHECK(addr);
if (error_ != 0 || addresses_.empty())
diff --git a/rtc_base/async_dns_resolver.h b/rtc_base/async_dns_resolver.h
index 8ea5d0a..4a5f161 100644
--- a/rtc_base/async_dns_resolver.h
+++ b/rtc_base/async_dns_resolver.h
@@ -26,14 +26,14 @@
class AsyncDnsResolverResultImpl : public AsyncDnsResolverResult {
public:
- bool GetResolvedAddress(int family, rtc::SocketAddress* addr) const override;
+ bool GetResolvedAddress(int family, SocketAddress* addr) const override;
// Returns error from resolver.
int GetError() const override;
private:
friend class AsyncDnsResolver;
RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker sequence_checker_;
- rtc::SocketAddress addr_ RTC_GUARDED_BY(sequence_checker_);
+ SocketAddress addr_ RTC_GUARDED_BY(sequence_checker_);
std::vector<IPAddress> addresses_ RTC_GUARDED_BY(sequence_checker_);
int error_ RTC_GUARDED_BY(sequence_checker_);
};
@@ -43,10 +43,10 @@
AsyncDnsResolver();
~AsyncDnsResolver();
// Start address resolution of the hostname in `addr`.
- void Start(const rtc::SocketAddress& addr,
+ void Start(const SocketAddress& addr,
absl::AnyInvocable<void()> callback) override;
// Start address resolution of the hostname in `addr` matching `family`.
- void Start(const rtc::SocketAddress& addr,
+ void Start(const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) override;
const AsyncDnsResolverResult& result() const override;
diff --git a/rtc_base/async_dns_resolver_unittest.cc b/rtc_base/async_dns_resolver_unittest.cc
index 23f541b..80b567d 100644
--- a/rtc_base/async_dns_resolver_unittest.cc
+++ b/rtc_base/async_dns_resolver_unittest.cc
@@ -38,9 +38,9 @@
TEST(AsyncDnsResolver, ResolvingLocalhostWorks) {
test::RunLoop loop; // Ensure that posting back to main thread works
AsyncDnsResolver resolver;
- rtc::SocketAddress address("localhost",
- kPortNumber); // Port number does not matter
- rtc::SocketAddress resolved_address;
+ SocketAddress address("localhost",
+ kPortNumber); // Port number does not matter
+ SocketAddress resolved_address;
bool done = false;
resolver.Start(address, [&done] { done = true; });
ASSERT_THAT(
@@ -48,7 +48,7 @@
IsRtcOk());
EXPECT_EQ(resolver.result().GetError(), 0);
if (resolver.result().GetResolvedAddress(AF_INET, &resolved_address)) {
- EXPECT_EQ(resolved_address, rtc::SocketAddress("127.0.0.1", kPortNumber));
+ EXPECT_EQ(resolved_address, SocketAddress("127.0.0.1", kPortNumber));
} else {
RTC_LOG(LS_INFO) << "Resolution gave no address, skipping test";
}
@@ -58,9 +58,9 @@
test::RunLoop loop;
std::unique_ptr<AsyncDnsResolver> resolver =
std::make_unique<AsyncDnsResolver>();
- rtc::SocketAddress address("localhost",
- kPortNumber); // Port number does not matter
- rtc::SocketAddress resolved_address;
+ SocketAddress address("localhost",
+ kPortNumber); // Port number does not matter
+ SocketAddress resolved_address;
bool done = false;
resolver->Start(address, [&done] { done = true; });
resolver.reset(); // Deletes resolver.
diff --git a/rtc_base/async_packet_socket.h b/rtc_base/async_packet_socket.h
index 4202fcc..1ff9d73 100644
--- a/rtc_base/async_packet_socket.h
+++ b/rtc_base/async_packet_socket.h
@@ -96,16 +96,16 @@
// Returns current local address. Address may be set to null if the
// socket is not bound yet (GetState() returns STATE_BINDING).
- virtual SocketAddress GetLocalAddress() const = 0;
+ virtual webrtc::SocketAddress GetLocalAddress() const = 0;
// Returns remote address. Returns zeroes if this is not a client TCP socket.
- virtual SocketAddress GetRemoteAddress() const = 0;
+ virtual webrtc::SocketAddress GetRemoteAddress() const = 0;
// Send a packet.
virtual int Send(const void* pv, size_t cb, const PacketOptions& options) = 0;
virtual int SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const PacketOptions& options) = 0;
// Close the socket.
@@ -143,7 +143,8 @@
// Emitted after address for the socket is allocated, i.e. binding
// is finished. State of the socket is changed from BINDING to BOUND
// (for UDP sockets).
- sigslot::signal2<AsyncPacketSocket*, const SocketAddress&> SignalAddressReady;
+ sigslot::signal2<AsyncPacketSocket*, const webrtc::SocketAddress&>
+ SignalAddressReady;
// Emitted for client TCP sockets when state is changed from
// CONNECTING to CONNECTED.
@@ -188,7 +189,7 @@
// Returns current local address. Address may be set to null if the
// socket is not bound yet (GetState() returns kBinding).
- virtual SocketAddress GetLocalAddress() const = 0;
+ virtual webrtc::SocketAddress GetLocalAddress() const = 0;
sigslot::signal2<AsyncListenSocket*, AsyncPacketSocket*> SignalNewConnection;
};
diff --git a/rtc_base/async_packet_socket_unittest.cc b/rtc_base/async_packet_socket_unittest.cc
index ce9f2c3..f0ce150 100644
--- a/rtc_base/async_packet_socket_unittest.cc
+++ b/rtc_base/async_packet_socket_unittest.cc
@@ -24,8 +24,8 @@
public:
~MockAsyncPacketSocket() = default;
- MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
- MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
+ MOCK_METHOD(webrtc::SocketAddress, GetLocalAddress, (), (const, override));
+ MOCK_METHOD(webrtc::SocketAddress, GetRemoteAddress, (), (const, override));
MOCK_METHOD(int,
Send,
(const void* pv, size_t cb, const rtc::PacketOptions& options),
@@ -35,7 +35,7 @@
SendTo,
(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options),
(override));
MOCK_METHOD(int, Close, (), (override));
@@ -58,7 +58,7 @@
EXPECT_CALL(received_packet, Call);
mock_socket.RegisterReceivedPacketCallback(received_packet.AsStdFunction());
- mock_socket.NotifyPacketReceived(ReceivedPacket({}, SocketAddress()));
+ mock_socket.NotifyPacketReceived(ReceivedPacket({}, webrtc::SocketAddress()));
}
} // namespace
diff --git a/rtc_base/async_socket.cc b/rtc_base/async_socket.cc
index 7289b5c..9730919 100644
--- a/rtc_base/async_socket.cc
+++ b/rtc_base/async_socket.cc
@@ -25,19 +25,19 @@
socket_->SignalCloseEvent.connect(this, &AsyncSocketAdapter::OnCloseEvent);
}
-SocketAddress AsyncSocketAdapter::GetLocalAddress() const {
+webrtc::SocketAddress AsyncSocketAdapter::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-SocketAddress AsyncSocketAdapter::GetRemoteAddress() const {
+webrtc::SocketAddress AsyncSocketAdapter::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
-int AsyncSocketAdapter::Bind(const SocketAddress& addr) {
+int AsyncSocketAdapter::Bind(const webrtc::SocketAddress& addr) {
return socket_->Bind(addr);
}
-int AsyncSocketAdapter::Connect(const SocketAddress& addr) {
+int AsyncSocketAdapter::Connect(const webrtc::SocketAddress& addr) {
return socket_->Connect(addr);
}
@@ -47,7 +47,7 @@
int AsyncSocketAdapter::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
return socket_->SendTo(pv, cb, addr);
}
@@ -57,7 +57,7 @@
int AsyncSocketAdapter::RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) {
return socket_->RecvFrom(pv, cb, paddr, timestamp);
}
@@ -66,7 +66,7 @@
return socket_->Listen(backlog);
}
-Socket* AsyncSocketAdapter::Accept(SocketAddress* paddr) {
+Socket* AsyncSocketAdapter::Accept(webrtc::SocketAddress* paddr) {
return socket_->Accept(paddr);
}
diff --git a/rtc_base/async_socket.h b/rtc_base/async_socket.h
index 0772cb8..89f4068 100644
--- a/rtc_base/async_socket.h
+++ b/rtc_base/async_socket.h
@@ -28,19 +28,21 @@
// TODO(bugs.webrtc.org/6424): Change to unique_ptr here and in callers.
explicit AsyncSocketAdapter(Socket* socket);
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
- int Bind(const SocketAddress& addr) override;
- int Connect(const SocketAddress& addr) override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
+ int Bind(const webrtc::SocketAddress& addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override;
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override;
int Listen(int backlog) override;
- Socket* Accept(SocketAddress* paddr) override;
+ Socket* Accept(webrtc::SocketAddress* paddr) override;
int Close() override;
int GetError() const override;
void SetError(int error) override;
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index b0f91f9..840a88f 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -48,8 +48,8 @@
// Binds and connects `socket`
Socket* AsyncTCPSocketBase::ConnectSocket(
rtc::Socket* socket,
- const rtc::SocketAddress& bind_address,
- const rtc::SocketAddress& remote_address) {
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address) {
std::unique_ptr<rtc::Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
@@ -77,11 +77,11 @@
AsyncTCPSocketBase::~AsyncTCPSocketBase() {}
-SocketAddress AsyncTCPSocketBase::GetLocalAddress() const {
+webrtc::SocketAddress AsyncTCPSocketBase::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-SocketAddress AsyncTCPSocketBase::GetRemoteAddress() const {
+webrtc::SocketAddress AsyncTCPSocketBase::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
@@ -121,9 +121,9 @@
int AsyncTCPSocketBase::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) {
- const SocketAddress& remote_address = GetRemoteAddress();
+ const webrtc::SocketAddress& remote_address = GetRemoteAddress();
if (addr == remote_address)
return Send(pv, cb, options);
// Remote address may be empty if there is a sudden network change.
@@ -245,9 +245,10 @@
// Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case).
-AsyncTCPSocket* AsyncTCPSocket::Create(Socket* socket,
- const SocketAddress& bind_address,
- const SocketAddress& remote_address) {
+AsyncTCPSocket* AsyncTCPSocket::Create(
+ Socket* socket,
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address) {
return new AsyncTCPSocket(
AsyncTCPSocketBase::ConnectSocket(socket, bind_address, remote_address));
}
@@ -288,7 +289,7 @@
}
size_t AsyncTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
- SocketAddress remote_addr(GetRemoteAddress());
+ webrtc::SocketAddress remote_addr(GetRemoteAddress());
size_t processed_bytes = 0;
while (true) {
@@ -329,14 +330,14 @@
}
}
-SocketAddress AsyncTcpListenSocket::GetLocalAddress() const {
+webrtc::SocketAddress AsyncTcpListenSocket::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
void AsyncTcpListenSocket::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
- rtc::SocketAddress address;
+ webrtc::SocketAddress address;
rtc::Socket* new_socket = socket->Accept(&address);
if (!new_socket) {
// TODO(stefan): Do something better like forwarding the error
diff --git a/rtc_base/async_tcp_socket.h b/rtc_base/async_tcp_socket.h
index d3aff60..9be56b6 100644
--- a/rtc_base/async_tcp_socket.h
+++ b/rtc_base/async_tcp_socket.h
@@ -42,11 +42,11 @@
// Must return the number of bytes processed.
virtual size_t ProcessInput(rtc::ArrayView<const uint8_t> data) = 0;
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
int SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) override;
int Close() override;
@@ -61,8 +61,8 @@
// it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case).
static Socket* ConnectSocket(Socket* socket,
- const SocketAddress& bind_address,
- const SocketAddress& remote_address);
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address);
int FlushOutBuffer();
// Add data to `outbuf_`.
void AppendToOutBuffer(const void* pv, size_t cb);
@@ -91,8 +91,8 @@
// it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case).
static AsyncTCPSocket* Create(Socket* socket,
- const SocketAddress& bind_address,
- const SocketAddress& remote_address);
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address);
explicit AsyncTCPSocket(Socket* socket);
~AsyncTCPSocket() override {}
@@ -110,7 +110,7 @@
explicit AsyncTcpListenSocket(std::unique_ptr<Socket> socket);
State GetState() const override;
- SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
virtual void HandleIncomingConnection(rtc::Socket* socket);
diff --git a/rtc_base/async_udp_socket.cc b/rtc_base/async_udp_socket.cc
index 046355c..feca7b9 100644
--- a/rtc_base/async_udp_socket.cc
+++ b/rtc_base/async_udp_socket.cc
@@ -29,8 +29,9 @@
namespace rtc {
-AsyncUDPSocket* AsyncUDPSocket::Create(Socket* socket,
- const SocketAddress& bind_address) {
+AsyncUDPSocket* AsyncUDPSocket::Create(
+ Socket* socket,
+ const webrtc::SocketAddress& bind_address) {
std::unique_ptr<Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
@@ -39,8 +40,9 @@
return new AsyncUDPSocket(owned_socket.release());
}
-AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory,
- const SocketAddress& bind_address) {
+AsyncUDPSocket* AsyncUDPSocket::Create(
+ SocketFactory* factory,
+ const webrtc::SocketAddress& bind_address) {
Socket* socket = factory->CreateSocket(bind_address.family(), SOCK_DGRAM);
if (!socket)
return nullptr;
@@ -54,11 +56,11 @@
socket_->SignalWriteEvent.connect(this, &AsyncUDPSocket::OnWriteEvent);
}
-SocketAddress AsyncUDPSocket::GetLocalAddress() const {
+webrtc::SocketAddress AsyncUDPSocket::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-SocketAddress AsyncUDPSocket::GetRemoteAddress() const {
+webrtc::SocketAddress AsyncUDPSocket::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
@@ -75,7 +77,7 @@
int AsyncUDPSocket::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) {
rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis(),
options.info_signaled_after_sent);
@@ -129,7 +131,7 @@
// send datagram, indicating the remote address was unreachable.
// When doing ICE, this kind of thing will often happen.
// TODO: Do something better like forwarding the error to the user.
- SocketAddress local_addr = socket_->GetLocalAddress();
+ webrtc::SocketAddress local_addr = socket_->GetLocalAddress();
RTC_LOG(LS_INFO) << "AsyncUDPSocket[" << local_addr.ToSensitiveString()
<< "] receive failed with error " << socket_->GetError();
return;
diff --git a/rtc_base/async_udp_socket.h b/rtc_base/async_udp_socket.h
index cf68488..2dd61d3 100644
--- a/rtc_base/async_udp_socket.h
+++ b/rtc_base/async_udp_socket.h
@@ -36,22 +36,22 @@
// of `socket`. Returns null if bind() fails (`socket` is destroyed
// in that case).
static AsyncUDPSocket* Create(Socket* socket,
- const SocketAddress& bind_address);
+ const webrtc::SocketAddress& bind_address);
// Creates a new socket for sending asynchronous UDP packets using an
// asynchronous socket from the given factory.
static AsyncUDPSocket* Create(SocketFactory* factory,
- const SocketAddress& bind_address);
+ const webrtc::SocketAddress& bind_address);
explicit AsyncUDPSocket(Socket* socket);
~AsyncUDPSocket() = default;
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
int Send(const void* pv,
size_t cb,
const rtc::PacketOptions& options) override;
int SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) override;
int Close() override;
diff --git a/rtc_base/async_udp_socket_unittest.cc b/rtc_base/async_udp_socket_unittest.cc
index 26ab09e..1fd6bc2 100644
--- a/rtc_base/async_udp_socket_unittest.cc
+++ b/rtc_base/async_udp_socket_unittest.cc
@@ -22,7 +22,7 @@
namespace rtc {
-static const SocketAddress kAddr("22.22.22.22", 0);
+static const webrtc::SocketAddress kAddr("22.22.22.22", 0);
TEST(AsyncUDPSocketTest, SetSocketOptionIfEctChange) {
VirtualSocketServer socket_server;
diff --git a/rtc_base/fake_network.h b/rtc_base/fake_network.h
index 0c74593..8ccc881 100644
--- a/rtc_base/fake_network.h
+++ b/rtc_base/fake_network.h
@@ -34,33 +34,34 @@
FakeNetworkManager() {}
struct Iface {
- SocketAddress socket_address;
+ webrtc::SocketAddress socket_address;
AdapterType adapter_type;
std::optional<AdapterType> underlying_vpn_adapter_type;
};
typedef std::vector<Iface> IfaceList;
- void AddInterface(const SocketAddress& iface) {
+ void AddInterface(const webrtc::SocketAddress& iface) {
// Ensure a unique name for the interface if its name is not given.
AddInterface(iface, "test" + rtc::ToString(next_index_++));
}
- void AddInterface(const SocketAddress& iface, absl::string_view if_name) {
+ void AddInterface(const webrtc::SocketAddress& iface,
+ absl::string_view if_name) {
AddInterface(iface, if_name, ADAPTER_TYPE_UNKNOWN);
}
void AddInterface(
- const SocketAddress& iface,
+ const webrtc::SocketAddress& iface,
absl::string_view if_name,
AdapterType type,
std::optional<AdapterType> underlying_vpn_adapter_type = std::nullopt) {
- SocketAddress address(if_name, 0);
+ webrtc::SocketAddress address(if_name, 0);
address.SetResolvedIP(iface.ipaddr());
ifaces_.push_back({address, type, underlying_vpn_adapter_type});
DoUpdateNetworks();
}
- void RemoveInterface(const SocketAddress& iface) {
+ void RemoveInterface(const webrtc::SocketAddress& iface) {
for (IfaceList::iterator it = ifaces_.begin(); it != ifaces_.end(); ++it) {
if (it->socket_address.EqualIPs(iface)) {
ifaces_.erase(it);
diff --git a/rtc_base/firewall_socket_server.cc b/rtc_base/firewall_socket_server.cc
index cc1fb0c..87efc2e 100644
--- a/rtc_base/firewall_socket_server.cc
+++ b/rtc_base/firewall_socket_server.cc
@@ -28,7 +28,7 @@
FirewallSocket(FirewallSocketServer* server, Socket* socket, int type)
: AsyncSocketAdapter(socket), server_(server), type_(type) {}
- int Bind(const SocketAddress& addr) override {
+ int Bind(const webrtc::SocketAddress& addr) override {
if (!server_->IsBindableIp(addr.ipaddr())) {
SetError(EINVAL);
return SOCKET_ERROR;
@@ -36,7 +36,7 @@
return AsyncSocketAdapter::Bind(addr);
}
- int Connect(const SocketAddress& addr) override {
+ int Connect(const webrtc::SocketAddress& addr) override {
if (type_ == SOCK_STREAM) {
if (!server_->Check(FP_TCP, GetLocalAddress(), addr)) {
RTC_LOG(LS_VERBOSE) << "FirewallSocket outbound TCP connection from "
@@ -52,7 +52,9 @@
int Send(const void* pv, size_t cb) override {
return SendTo(pv, cb, GetRemoteAddress());
}
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override {
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override {
RTC_DCHECK(type_ == SOCK_DGRAM || type_ == SOCK_STREAM);
FirewallProtocol protocol = (type_ == SOCK_DGRAM) ? FP_UDP : FP_TCP;
if (!server_->Check(protocol, GetLocalAddress(), addr)) {
@@ -65,12 +67,12 @@
return AsyncSocketAdapter::SendTo(pv, cb, addr);
}
int Recv(void* pv, size_t cb, int64_t* timestamp) override {
- SocketAddress addr;
+ webrtc::SocketAddress addr;
return RecvFrom(pv, cb, &addr, timestamp);
}
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override {
if (type_ == SOCK_DGRAM) {
while (true) {
@@ -96,8 +98,8 @@
return AsyncSocketAdapter::Listen(backlog);
}
- Socket* Accept(SocketAddress* paddr) override {
- SocketAddress addr;
+ Socket* Accept(webrtc::SocketAddress* paddr) override {
+ webrtc::SocketAddress addr;
while (Socket* sock = AsyncSocketAdapter::Accept(&addr)) {
if (server_->Check(FP_TCP, addr, GetLocalAddress())) {
if (paddr)
@@ -144,8 +146,8 @@
void FirewallSocketServer::AddRule(bool allow,
FirewallProtocol p,
FirewallDirection d,
- const SocketAddress& addr) {
- SocketAddress any;
+ const webrtc::SocketAddress& addr) {
+ webrtc::SocketAddress any;
if (d == FD_IN || d == FD_ANY) {
AddRule(allow, p, any, addr);
}
@@ -156,8 +158,8 @@
void FirewallSocketServer::AddRule(bool allow,
FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst) {
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst) {
Rule r;
r.allow = allow;
r.p = p;
@@ -173,8 +175,8 @@
}
bool FirewallSocketServer::Check(FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst) {
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst) {
webrtc::MutexLock scope(&mutex_);
for (size_t i = 0; i < rules_.size(); ++i) {
const Rule& r = rules_[i];
@@ -249,7 +251,7 @@
void FirewallManager::AddRule(bool allow,
FirewallProtocol p,
FirewallDirection d,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
webrtc::MutexLock scope(&mutex_);
for (std::vector<FirewallSocketServer*>::const_iterator it = servers_.begin();
it != servers_.end(); ++it) {
diff --git a/rtc_base/firewall_socket_server.h b/rtc_base/firewall_socket_server.h
index ff48725..822b27d 100644
--- a/rtc_base/firewall_socket_server.h
+++ b/rtc_base/firewall_socket_server.h
@@ -55,16 +55,16 @@
void AddRule(bool allow,
FirewallProtocol p = FP_ANY,
FirewallDirection d = FD_ANY,
- const SocketAddress& addr = SocketAddress());
+ const webrtc::SocketAddress& addr = webrtc::SocketAddress());
void AddRule(bool allow,
FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst);
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst);
void ClearRules();
bool Check(FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst);
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst);
// Set the IP addresses for which Bind will fail. By default this list is
// empty. This can be used to simulate a real OS that refuses to bind to
@@ -92,8 +92,8 @@
bool allow;
FirewallProtocol p;
FirewallDirection d;
- SocketAddress src;
- SocketAddress dst;
+ webrtc::SocketAddress src;
+ webrtc::SocketAddress dst;
};
std::vector<Rule> rules_;
std::vector<webrtc::IPAddress> unbindable_ips_;
@@ -116,7 +116,7 @@
void AddRule(bool allow,
FirewallProtocol p = FP_ANY,
FirewallDirection d = FD_ANY,
- const SocketAddress& addr = SocketAddress());
+ const webrtc::SocketAddress& addr = webrtc::SocketAddress());
void ClearRules();
private:
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index 36e7112..2675df7 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -1038,7 +1038,7 @@
return webrtc::IPAddress();
}
- if (socket->Connect(SocketAddress(
+ if (socket->Connect(webrtc::SocketAddress(
family == AF_INET ? kPublicIPv4Host : kPublicIPv6Host, kPublicPort)) <
0) {
if (socket->GetError() != ENETUNREACH &&
diff --git a/rtc_base/network/received_packet.cc b/rtc_base/network/received_packet.cc
index 346a17f..b10245e 100644
--- a/rtc_base/network/received_packet.cc
+++ b/rtc_base/network/received_packet.cc
@@ -18,7 +18,7 @@
namespace rtc {
ReceivedPacket::ReceivedPacket(rtc::ArrayView<const uint8_t> payload,
- const SocketAddress& source_address,
+ const webrtc::SocketAddress& source_address,
std::optional<webrtc::Timestamp> arrival_time,
EcnMarking ecn,
DecryptionInfo decryption)
@@ -39,7 +39,7 @@
const uint8_t* data,
size_t size,
int64_t packet_time_us,
- const rtc::SocketAddress& source_address) {
+ const webrtc::SocketAddress& source_address) {
RTC_DCHECK(packet_time_us == -1 || packet_time_us >= 0);
return ReceivedPacket(rtc::MakeArrayView(data, size), source_address,
(packet_time_us >= 0)
diff --git a/rtc_base/network/received_packet.h b/rtc_base/network/received_packet.h
index ec0b0bf..b46d0c8 100644
--- a/rtc_base/network/received_packet.h
+++ b/rtc_base/network/received_packet.h
@@ -37,7 +37,7 @@
// Caller must keep memory pointed to by payload and address valid for the
// lifetime of this ReceivedPacket.
ReceivedPacket(rtc::ArrayView<const uint8_t> payload,
- const SocketAddress& source_address,
+ const webrtc::SocketAddress& source_address,
std::optional<webrtc::Timestamp> arrival_time = std::nullopt,
EcnMarking ecn = EcnMarking::kNotEct,
DecryptionInfo decryption = kNotDecrypted);
@@ -45,7 +45,9 @@
ReceivedPacket CopyAndSet(DecryptionInfo decryption_info) const;
// Address/port of the packet sender.
- const SocketAddress& source_address() const { return source_address_; }
+ const webrtc::SocketAddress& source_address() const {
+ return source_address_;
+ }
rtc::ArrayView<const uint8_t> payload() const { return payload_; }
// Timestamp when this packet was received. Not available on all socket
@@ -63,7 +65,7 @@
const char* data,
size_t size,
int64_t packet_time_us,
- const rtc::SocketAddress& addr = rtc::SocketAddress()) {
+ const webrtc::SocketAddress& addr = webrtc::SocketAddress()) {
return CreateFromLegacy(reinterpret_cast<const uint8_t*>(data), size,
packet_time_us, addr);
}
@@ -72,12 +74,12 @@
const uint8_t* data,
size_t size,
int64_t packet_time_us,
- const rtc::SocketAddress& = rtc::SocketAddress());
+ const webrtc::SocketAddress& = webrtc::SocketAddress());
private:
rtc::ArrayView<const uint8_t> payload_;
std::optional<webrtc::Timestamp> arrival_time_;
- const SocketAddress& source_address_;
+ const webrtc::SocketAddress& source_address_;
EcnMarking ecn_;
DecryptionInfo decryption_info_;
};
diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc
index b27d076..ea1e27c 100644
--- a/rtc_base/network_unittest.cc
+++ b/rtc_base/network_unittest.cc
@@ -405,7 +405,7 @@
sockaddr_storage storage;
memset(&storage, 0, sizeof(storage));
webrtc::IPAddress ip = (*it)->GetBestIP();
- SocketAddress bindaddress(ip, 0);
+ webrtc::SocketAddress bindaddress(ip, 0);
bindaddress.SetScopeID((*it)->scope_id());
// TODO(thaloun): Use rtc::Socket once it supports IPv6.
int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
diff --git a/rtc_base/openssl_adapter.cc b/rtc_base/openssl_adapter.cc
index 2879add..6db7f75 100644
--- a/rtc_base/openssl_adapter.cc
+++ b/rtc_base/openssl_adapter.cc
@@ -580,7 +580,7 @@
int OpenSSLAdapter::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
if (GetSocket()->GetState() == Socket::CS_CONNECTED &&
addr == GetSocket()->GetRemoteAddress()) {
return Send(pv, cb);
@@ -641,7 +641,7 @@
int OpenSSLAdapter::RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) {
if (GetSocket()->GetState() == Socket::CS_CONNECTED) {
int ret = Recv(pv, cb, timestamp);
diff --git a/rtc_base/openssl_adapter.h b/rtc_base/openssl_adapter.h
index 9276f60..28ce6b5 100644
--- a/rtc_base/openssl_adapter.h
+++ b/rtc_base/openssl_adapter.h
@@ -62,11 +62,13 @@
void SetRole(webrtc::SSLRole role) override;
int StartSSL(absl::string_view hostname) override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override;
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override;
int Close() override;
// Note that the socket returns ST_CONNECTING while SSL is being negotiated.
diff --git a/rtc_base/openssl_adapter_unittest.cc b/rtc_base/openssl_adapter_unittest.cc
index 5783a87..835ee10 100644
--- a/rtc_base/openssl_adapter_unittest.cc
+++ b/rtc_base/openssl_adapter_unittest.cc
@@ -30,20 +30,20 @@
class MockAsyncSocket : public Socket {
public:
virtual ~MockAsyncSocket() = default;
- MOCK_METHOD(Socket*, Accept, (SocketAddress*), (override));
- MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
- MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
- MOCK_METHOD(int, Bind, (const SocketAddress&), (override));
- MOCK_METHOD(int, Connect, (const SocketAddress&), (override));
+ MOCK_METHOD(Socket*, Accept, (webrtc::SocketAddress*), (override));
+ MOCK_METHOD(webrtc::SocketAddress, GetLocalAddress, (), (const, override));
+ MOCK_METHOD(webrtc::SocketAddress, GetRemoteAddress, (), (const, override));
+ MOCK_METHOD(int, Bind, (const webrtc::SocketAddress&), (override));
+ MOCK_METHOD(int, Connect, (const webrtc::SocketAddress&), (override));
MOCK_METHOD(int, Send, (const void*, size_t), (override));
MOCK_METHOD(int,
SendTo,
- (const void*, size_t, const SocketAddress&),
+ (const void*, size_t, const webrtc::SocketAddress&),
(override));
MOCK_METHOD(int, Recv, (void*, size_t, int64_t*), (override));
MOCK_METHOD(int,
RecvFrom,
- (void*, size_t, SocketAddress*, int64_t*),
+ (void*, size_t, webrtc::SocketAddress*, int64_t*),
(override));
MOCK_METHOD(int, Listen, (int), (override));
MOCK_METHOD(int, Close, (), (override));
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index f829fc5..a6df1a4 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -187,14 +187,14 @@
return s_ != INVALID_SOCKET;
}
-SocketAddress PhysicalSocket::GetLocalAddress() const {
+webrtc::SocketAddress PhysicalSocket::GetLocalAddress() const {
sockaddr_storage addr_storage = {};
socklen_t addrlen = sizeof(addr_storage);
sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
int result = ::getsockname(s_, addr, &addrlen);
- SocketAddress address;
+ webrtc::SocketAddress address;
if (result >= 0) {
- SocketAddressFromSockAddrStorage(addr_storage, &address);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
RTC_LOG(LS_WARNING) << "GetLocalAddress: unable to get local addr, socket="
<< s_;
@@ -202,14 +202,14 @@
return address;
}
-SocketAddress PhysicalSocket::GetRemoteAddress() const {
+webrtc::SocketAddress PhysicalSocket::GetRemoteAddress() const {
sockaddr_storage addr_storage = {};
socklen_t addrlen = sizeof(addr_storage);
sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
int result = ::getpeername(s_, addr, &addrlen);
- SocketAddress address;
+ webrtc::SocketAddress address;
if (result >= 0) {
- SocketAddressFromSockAddrStorage(addr_storage, &address);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
RTC_LOG(LS_WARNING)
<< "GetRemoteAddress: unable to get remote addr, socket=" << s_;
@@ -217,8 +217,8 @@
return address;
}
-int PhysicalSocket::Bind(const SocketAddress& bind_addr) {
- SocketAddress copied_bind_addr = bind_addr;
+int PhysicalSocket::Bind(const webrtc::SocketAddress& bind_addr) {
+ webrtc::SocketAddress copied_bind_addr = bind_addr;
// If a network binder is available, use it to bind a socket to an interface
// instead of bind(), since this is more reliable on an OS with a weak host
// model.
@@ -265,7 +265,7 @@
return err;
}
-int PhysicalSocket::Connect(const SocketAddress& addr) {
+int PhysicalSocket::Connect(const webrtc::SocketAddress& addr) {
// TODO(pthatcher): Implicit creation is required to reconnect...
// ...but should we make it more explicit?
if (state_ != CS_CLOSED) {
@@ -283,7 +283,7 @@
return DoConnect(addr);
}
-int PhysicalSocket::DoConnect(const SocketAddress& connect_addr) {
+int PhysicalSocket::DoConnect(const webrtc::SocketAddress& connect_addr) {
if ((s_ == INVALID_SOCKET) && !Create(connect_addr.family(), SOCK_STREAM)) {
return SOCKET_ERROR;
}
@@ -415,7 +415,7 @@
int PhysicalSocket::SendTo(const void* buffer,
size_t length,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
sockaddr_storage saddr;
size_t len = addr.ToSockAddrStorage(&saddr);
int sent =
@@ -467,7 +467,7 @@
int PhysicalSocket::RecvFrom(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp) {
int received = DoReadFromSocket(buffer, length, out_addr, timestamp, nullptr);
@@ -509,7 +509,7 @@
int PhysicalSocket::DoReadFromSocket(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp,
EcnMarking* ecn) {
sockaddr_storage addr_storage;
@@ -560,7 +560,7 @@
}
}
if (out_addr) {
- SocketAddressFromSockAddrStorage(addr_storage, out_addr);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, out_addr);
}
return received;
@@ -595,7 +595,7 @@
return err;
}
-Socket* PhysicalSocket::Accept(SocketAddress* out_addr) {
+Socket* PhysicalSocket::Accept(webrtc::SocketAddress* out_addr) {
// Always re-subscribe DE_ACCEPT to make sure new incoming connections will
// trigger an event even if DoAccept returns an error here.
EnableEvents(DE_ACCEPT);
@@ -607,7 +607,7 @@
if (s == INVALID_SOCKET)
return nullptr;
if (out_addr != nullptr)
- SocketAddressFromSockAddrStorage(addr_storage, out_addr);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, out_addr);
return ss_->WrapSocket(s);
}
@@ -648,7 +648,7 @@
const webrtc::AsyncDnsResolverResult& result) {
int error = result.GetError();
if (error == 0) {
- SocketAddress address;
+ webrtc::SocketAddress address;
if (result.GetResolvedAddress(AF_INET, &address)) {
error = DoConnect(address);
} else {
diff --git a/rtc_base/physical_socket_server.h b/rtc_base/physical_socket_server.h
index 3bab75a..39dbe38 100644
--- a/rtc_base/physical_socket_server.h
+++ b/rtc_base/physical_socket_server.h
@@ -165,11 +165,11 @@
// Creates the underlying OS socket (same as the "socket" function).
virtual bool Create(int family, int type);
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
- int Bind(const SocketAddress& bind_addr) override;
- int Connect(const SocketAddress& addr) override;
+ int Bind(const webrtc::SocketAddress& bind_addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
int GetError() const override;
void SetError(int error) override;
@@ -182,18 +182,18 @@
int Send(const void* pv, size_t cb) override;
int SendTo(const void* buffer,
size_t length,
- const SocketAddress& addr) override;
+ const webrtc::SocketAddress& addr) override;
int Recv(void* buffer, size_t length, int64_t* timestamp) override;
// TODO(webrtc:15368): Deprecate and remove.
int RecvFrom(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp) override;
int RecvFrom(ReceiveBuffer& buffer) override;
int Listen(int backlog) override;
- Socket* Accept(SocketAddress* out_addr) override;
+ Socket* Accept(webrtc::SocketAddress* out_addr) override;
int Close() override;
@@ -202,7 +202,7 @@
SOCKET GetSocketFD() const { return s_; }
protected:
- int DoConnect(const SocketAddress& connect_addr);
+ int DoConnect(const webrtc::SocketAddress& connect_addr);
// Make virtual so ::accept can be overwritten in tests.
virtual SOCKET DoAccept(SOCKET socket, sockaddr* addr, socklen_t* addrlen);
@@ -220,7 +220,7 @@
int DoReadFromSocket(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp,
EcnMarking* ecn);
diff --git a/rtc_base/physical_socket_server_unittest.cc b/rtc_base/physical_socket_server_unittest.cc
index b30eff9..3d9dc05 100644
--- a/rtc_base/physical_socket_server_unittest.cc
+++ b/rtc_base/physical_socket_server_unittest.cc
@@ -203,7 +203,7 @@
void PhysicalSocketTest::ConnectInternalAcceptError(
const webrtc::IPAddress& loopback) {
webrtc::testing::StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create two clients.
std::unique_ptr<Socket> client1(
@@ -222,7 +222,7 @@
std::unique_ptr<Socket> server(
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
@@ -504,7 +504,7 @@
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
- EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0)));
+ EXPECT_EQ(-1, socket->Bind(webrtc::SocketAddress("192.168.0.1", 0)));
server_.set_network_binder(nullptr);
}
@@ -514,7 +514,7 @@
FakeNetworkBinder fake_network_binder;
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0)));
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress("0.0.0.0", 0)));
EXPECT_EQ(0, fake_network_binder.num_binds());
server_.set_network_binder(nullptr);
}
@@ -528,7 +528,7 @@
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
- EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(kIPv4Loopback, 0)));
server_.set_network_binder(nullptr);
}
diff --git a/rtc_base/proxy_server.cc b/rtc_base/proxy_server.cc
index f8fe23d..9f282b3 100644
--- a/rtc_base/proxy_server.cc
+++ b/rtc_base/proxy_server.cc
@@ -22,9 +22,9 @@
// ProxyServer
ProxyServer::ProxyServer(SocketFactory* int_factory,
- const SocketAddress& int_addr,
+ const webrtc::SocketAddress& int_addr,
SocketFactory* ext_factory,
- const SocketAddress& ext_ip)
+ const webrtc::SocketAddress& ext_ip)
: ext_factory_(ext_factory),
ext_ip_(ext_ip.ipaddr(), 0), // strip off port
server_socket_(
@@ -38,7 +38,7 @@
ProxyServer::~ProxyServer() = default;
-SocketAddress ProxyServer::GetServerAddress() {
+webrtc::SocketAddress ProxyServer::GetServerAddress() {
return server_socket_->GetLocalAddress();
}
@@ -82,7 +82,7 @@
ProxyBinding::~ProxyBinding() = default;
void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
RTC_DCHECK(!connected_);
RTC_DCHECK(ext_socket_);
ext_socket_->Connect(addr);
@@ -119,7 +119,7 @@
void ProxyBinding::OnExternalClose(Socket* socket, int err) {
if (!connected_) {
- int_socket_->SendConnectResult(err, SocketAddress());
+ int_socket_->SendConnectResult(err, webrtc::SocketAddress());
}
Destroy();
}
diff --git a/rtc_base/proxy_server.h b/rtc_base/proxy_server.h
index 033dd82..50afd96 100644
--- a/rtc_base/proxy_server.h
+++ b/rtc_base/proxy_server.h
@@ -43,7 +43,7 @@
private:
void OnConnectRequest(AsyncProxyServerSocket* socket,
- const SocketAddress& addr);
+ const webrtc::SocketAddress& addr);
void OnInternalRead(Socket* socket);
void OnInternalWrite(Socket* socket);
void OnInternalClose(Socket* socket, int err);
@@ -67,16 +67,16 @@
class ProxyServer : public sigslot::has_slots<> {
public:
ProxyServer(SocketFactory* int_factory,
- const SocketAddress& int_addr,
+ const webrtc::SocketAddress& int_addr,
SocketFactory* ext_factory,
- const SocketAddress& ext_ip);
+ const webrtc::SocketAddress& ext_ip);
~ProxyServer() override;
ProxyServer(const ProxyServer&) = delete;
ProxyServer& operator=(const ProxyServer&) = delete;
// Returns the address to which the proxy server is bound
- SocketAddress GetServerAddress();
+ webrtc::SocketAddress GetServerAddress();
protected:
void OnAcceptEvent(Socket* socket);
@@ -84,7 +84,7 @@
private:
SocketFactory* ext_factory_;
- SocketAddress ext_ip_;
+ webrtc::SocketAddress ext_ip_;
std::unique_ptr<Socket> server_socket_;
std::vector<std::unique_ptr<ProxyBinding>> bindings_;
};
diff --git a/rtc_base/server_socket_adapters.h b/rtc_base/server_socket_adapters.h
index 05dcd29..0480d41 100644
--- a/rtc_base/server_socket_adapters.h
+++ b/rtc_base/server_socket_adapters.h
@@ -20,9 +20,10 @@
public:
AsyncProxyServerSocket(Socket* socket, size_t buffer_size);
~AsyncProxyServerSocket() override;
- sigslot::signal2<AsyncProxyServerSocket*, const SocketAddress&>
+ sigslot::signal2<AsyncProxyServerSocket*, const webrtc::SocketAddress&>
SignalConnectRequest;
- virtual void SendConnectResult(int err, const SocketAddress& addr) = 0;
+ virtual void SendConnectResult(int err,
+ const webrtc::SocketAddress& addr) = 0;
};
// Implements a socket adapter that performs the server side of a
diff --git a/rtc_base/socket.h b/rtc_base/socket.h
index 4b9a169..acffcd3 100644
--- a/rtc_base/socket.h
+++ b/rtc_base/socket.h
@@ -89,7 +89,7 @@
ReceiveBuffer(Buffer& payload) : payload(payload) {}
std::optional<webrtc::Timestamp> arrival_time;
- SocketAddress source_address;
+ webrtc::SocketAddress source_address;
EcnMarking ecn = EcnMarking::kNotEct;
Buffer& payload;
};
@@ -100,22 +100,24 @@
// Returns the address to which the socket is bound. If the socket is not
// bound, then the any-address is returned.
- virtual SocketAddress GetLocalAddress() const = 0;
+ virtual webrtc::SocketAddress GetLocalAddress() const = 0;
// Returns the address to which the socket is connected. If the socket is
// not connected, then the any-address is returned.
- virtual SocketAddress GetRemoteAddress() const = 0;
+ virtual webrtc::SocketAddress GetRemoteAddress() const = 0;
- virtual int Bind(const SocketAddress& addr) = 0;
- virtual int Connect(const SocketAddress& addr) = 0;
+ virtual int Bind(const webrtc::SocketAddress& addr) = 0;
+ virtual int Connect(const webrtc::SocketAddress& addr) = 0;
virtual int Send(const void* pv, size_t cb) = 0;
- virtual int SendTo(const void* pv, size_t cb, const SocketAddress& addr) = 0;
+ virtual int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) = 0;
// `timestamp` is in units of microseconds.
virtual int Recv(void* pv, size_t cb, int64_t* timestamp) = 0;
// TODO(webrtc:15368): Deprecate and remove.
virtual int RecvFrom(void* /* pv */,
size_t /* cb */,
- SocketAddress* /* paddr */,
+ webrtc::SocketAddress* /* paddr */,
int64_t* /* timestamp */) {
// Not implemented. Use RecvFrom(ReceiveBuffer& buffer).
RTC_CHECK_NOTREACHED();
@@ -125,7 +127,7 @@
// Returns number of bytes received or a negative value on error.
virtual int RecvFrom(ReceiveBuffer& buffer);
virtual int Listen(int backlog) = 0;
- virtual Socket* Accept(SocketAddress* paddr) = 0;
+ virtual Socket* Accept(webrtc::SocketAddress* paddr) = 0;
virtual int Close() = 0;
virtual int GetError() const = 0;
virtual void SetError(int error) = 0;
diff --git a/rtc_base/socket_adapters.cc b/rtc_base/socket_adapters.cc
index 2a157bf..df9558a 100644
--- a/rtc_base/socket_adapters.cc
+++ b/rtc_base/socket_adapters.cc
@@ -172,7 +172,7 @@
AsyncSSLSocket::AsyncSSLSocket(Socket* socket)
: BufferedReadAdapter(socket, 1024) {}
-int AsyncSSLSocket::Connect(const SocketAddress& addr) {
+int AsyncSSLSocket::Connect(const webrtc::SocketAddress& addr) {
// Begin buffering before we connect, so that there isn't a race condition
// between potential senders and receiving the OnConnectEvent signal
BufferInput(true);
diff --git a/rtc_base/socket_adapters.h b/rtc_base/socket_adapters.h
index c41b4a8..8535faf 100644
--- a/rtc_base/socket_adapters.h
+++ b/rtc_base/socket_adapters.h
@@ -69,7 +69,7 @@
AsyncSSLSocket(const AsyncSSLSocket&) = delete;
AsyncSSLSocket& operator=(const AsyncSSLSocket&) = delete;
- int Connect(const SocketAddress& addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
protected:
void OnConnectEvent(Socket* socket) override;
diff --git a/rtc_base/socket_address.cc b/rtc_base/socket_address.cc
index 2b31212..1e7d941 100644
--- a/rtc_base/socket_address.cc
+++ b/rtc_base/socket_address.cc
@@ -31,7 +31,7 @@
#include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/strings/string_builder.h"
-namespace rtc {
+namespace webrtc {
SocketAddress::SocketAddress() {
Clear();
@@ -43,11 +43,11 @@
}
SocketAddress::SocketAddress(uint32_t ip_as_host_order_integer, int port) {
- SetIP(webrtc::IPAddress(ip_as_host_order_integer));
+ SetIP(IPAddress(ip_as_host_order_integer));
SetPort(port);
}
-SocketAddress::SocketAddress(const webrtc::IPAddress& ip, int port) {
+SocketAddress::SocketAddress(const IPAddress& ip, int port) {
SetIP(ip);
SetPort(port);
}
@@ -59,7 +59,7 @@
void SocketAddress::Clear() {
hostname_.clear();
literal_ = false;
- ip_ = webrtc::IPAddress();
+ ip_ = IPAddress();
port_ = 0;
scope_id_ = 0;
}
@@ -84,11 +84,11 @@
void SocketAddress::SetIP(uint32_t ip_as_host_order_integer) {
hostname_.clear();
literal_ = false;
- ip_ = webrtc::IPAddress(ip_as_host_order_integer);
+ ip_ = IPAddress(ip_as_host_order_integer);
scope_id_ = 0;
}
-void SocketAddress::SetIP(const webrtc::IPAddress& ip) {
+void SocketAddress::SetIP(const IPAddress& ip) {
hostname_.clear();
literal_ = false;
ip_ = ip;
@@ -99,17 +99,17 @@
hostname_ = std::string(hostname);
literal_ = webrtc::IPFromString(hostname, &ip_);
if (!literal_) {
- ip_ = webrtc::IPAddress();
+ ip_ = IPAddress();
}
scope_id_ = 0;
}
void SocketAddress::SetResolvedIP(uint32_t ip_as_host_order_integer) {
- ip_ = webrtc::IPAddress(ip_as_host_order_integer);
+ ip_ = IPAddress(ip_as_host_order_integer);
scope_id_ = 0;
}
-void SocketAddress::SetResolvedIP(const webrtc::IPAddress& ip) {
+void SocketAddress::SetResolvedIP(const IPAddress& ip) {
ip_ = ip;
scope_id_ = 0;
}
@@ -122,7 +122,7 @@
return ip_.v4AddressAsHostOrderInteger();
}
-const webrtc::IPAddress& SocketAddress::ipaddr() const {
+const IPAddress& SocketAddress::ipaddr() const {
return ip_;
}
@@ -160,14 +160,14 @@
std::string SocketAddress::ToString() const {
char buf[1024];
- webrtc::SimpleStringBuilder sb(buf);
+ SimpleStringBuilder sb(buf);
sb << HostAsURIString() << ":" << port();
return sb.str();
}
std::string SocketAddress::ToSensitiveString() const {
char buf[1024];
- webrtc::SimpleStringBuilder sb(buf);
+ SimpleStringBuilder sb(buf);
sb << HostAsSensitiveURIString() << ":" << port();
return sb.str();
}
@@ -177,7 +177,7 @@
return ToSensitiveString();
}
char buf[1024];
- webrtc::SimpleStringBuilder sb(buf);
+ SimpleStringBuilder sb(buf);
sb << HostAsSensitiveURIString() << ":" << port();
sb << " (";
if (ip_.family() == AF_INET6) {
@@ -289,7 +289,7 @@
}
static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
- const webrtc::IPAddress& ip,
+ const IPAddress& ip,
uint16_t port,
int scope_id) {
memset(addr, 0, sizeof(sockaddr_storage));
@@ -324,12 +324,12 @@
}
if (addr.ss_family == AF_INET) {
const sockaddr_in* saddr = reinterpret_cast<const sockaddr_in*>(&addr);
- *out = SocketAddress(webrtc::IPAddress(saddr->sin_addr),
+ *out = SocketAddress(IPAddress(saddr->sin_addr),
webrtc::NetworkToHost16(saddr->sin_port));
return true;
} else if (addr.ss_family == AF_INET6) {
const sockaddr_in6* saddr = reinterpret_cast<const sockaddr_in6*>(&addr);
- *out = SocketAddress(webrtc::IPAddress(saddr->sin6_addr),
+ *out = SocketAddress(IPAddress(saddr->sin6_addr),
webrtc::NetworkToHost16(saddr->sin6_port));
out->SetScopeID(saddr->sin6_scope_id);
return true;
@@ -339,11 +339,11 @@
SocketAddress EmptySocketAddressWithFamily(int family) {
if (family == AF_INET) {
- return SocketAddress(webrtc::IPAddress(INADDR_ANY), 0);
+ return SocketAddress(IPAddress(INADDR_ANY), 0);
} else if (family == AF_INET6) {
- return SocketAddress(webrtc::IPAddress(in6addr_any), 0);
+ return SocketAddress(IPAddress(in6addr_any), 0);
}
return SocketAddress();
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/socket_address.h b/rtc_base/socket_address.h
index ea5dbea..d189d3c 100644
--- a/rtc_base/socket_address.h
+++ b/rtc_base/socket_address.h
@@ -22,7 +22,7 @@
struct sockaddr_in;
struct sockaddr_storage;
-namespace rtc {
+namespace webrtc {
// Records an IP address and port.
class RTC_EXPORT SocketAddress {
@@ -42,7 +42,7 @@
// Creates the address with the given IP and port.
// DCHECKs that port is in valid range (0 to 2^16-1).
- SocketAddress(const webrtc::IPAddress& ip, int port);
+ SocketAddress(const IPAddress& ip, int port);
// Creates a copy of the given address.
SocketAddress(const SocketAddress& addr);
@@ -64,7 +64,7 @@
void SetIP(uint32_t ip_as_host_order_integer);
// Changes the IP of this address to the given one, and clears the hostname.
- void SetIP(const webrtc::IPAddress& ip);
+ void SetIP(const IPAddress& ip);
// Changes the hostname of this address to the given one.
// Does not resolve the address; use Resolve to do so.
@@ -77,7 +77,7 @@
// Sets the IP address while retaining the hostname. Useful for bypassing
// DNS for a pre-resolved IP.
- void SetResolvedIP(const webrtc::IPAddress& ip);
+ void SetResolvedIP(const IPAddress& ip);
// Changes the port of this address to the given one.
// DCHECKs that port is in valid range (0 to 2^16-1).
@@ -90,7 +90,7 @@
// Returns 0 for non-v4 addresses.
uint32_t ip() const;
- const webrtc::IPAddress& ipaddr() const;
+ const IPAddress& ipaddr() const;
int family() const { return ip_.family(); }
@@ -184,7 +184,7 @@
private:
std::string hostname_;
- webrtc::IPAddress ip_;
+ IPAddress ip_;
uint16_t port_;
int scope_id_;
bool literal_; // Indicates that 'hostname_' contains a literal IP string.
@@ -194,6 +194,14 @@
SocketAddress* out);
SocketAddress EmptySocketAddressWithFamily(int family);
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::EmptySocketAddressWithFamily;
+using ::webrtc::SocketAddress;
+using ::webrtc::SocketAddressFromSockAddrStorage;
} // namespace rtc
#endif // RTC_BASE_SOCKET_ADDRESS_H_
diff --git a/rtc_base/socket_address_pair.cc b/rtc_base/socket_address_pair.cc
index 351dbd3..b97c086 100644
--- a/rtc_base/socket_address_pair.cc
+++ b/rtc_base/socket_address_pair.cc
@@ -12,8 +12,8 @@
namespace webrtc {
-SocketAddressPair::SocketAddressPair(const rtc::SocketAddress& src,
- const rtc::SocketAddress& dest)
+SocketAddressPair::SocketAddressPair(const SocketAddress& src,
+ const SocketAddress& dest)
: src_(src), dest_(dest) {}
bool SocketAddressPair::operator==(const SocketAddressPair& p) const {
diff --git a/rtc_base/socket_address_pair.h b/rtc_base/socket_address_pair.h
index aa1b01c..5a3bf81 100644
--- a/rtc_base/socket_address_pair.h
+++ b/rtc_base/socket_address_pair.h
@@ -23,11 +23,10 @@
class SocketAddressPair {
public:
SocketAddressPair() {}
- SocketAddressPair(const rtc::SocketAddress& srs,
- const rtc::SocketAddress& dest);
+ SocketAddressPair(const SocketAddress& srs, const SocketAddress& dest);
- const rtc::SocketAddress& source() const { return src_; }
- const rtc::SocketAddress& destination() const { return dest_; }
+ const SocketAddress& source() const { return src_; }
+ const SocketAddress& destination() const { return dest_; }
bool operator==(const SocketAddressPair& r) const;
bool operator<(const SocketAddressPair& r) const;
@@ -35,8 +34,8 @@
size_t Hash() const;
private:
- rtc::SocketAddress src_;
- rtc::SocketAddress dest_;
+ SocketAddress src_;
+ SocketAddress dest_;
};
} // namespace webrtc
diff --git a/rtc_base/socket_address_unittest.cc b/rtc_base/socket_address_unittest.cc
index 14b6862..e81fb6d 100644
--- a/rtc_base/socket_address_unittest.cc
+++ b/rtc_base/socket_address_unittest.cc
@@ -18,7 +18,7 @@
#include "rtc_base/net_helpers.h"
#include "test/gtest.h"
-namespace rtc {
+namespace webrtc {
const in6_addr kTestV6Addr = {
{{0x20, 0x01, 0x0d, 0xb8, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80,
@@ -36,15 +36,15 @@
TEST(SocketAddressTest, TestDefaultCtor) {
SocketAddress addr;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(0, addr.port());
EXPECT_EQ("", addr.hostname());
}
TEST(SocketAddressTest, TestIPPortCtor) {
- SocketAddress addr(webrtc::IPAddress(0x01020304), 5678);
+ SocketAddress addr(IPAddress(0x01020304), 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -53,7 +53,7 @@
TEST(SocketAddressTest, TestIPv4StringPortCtor) {
SocketAddress addr("1.2.3.4", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -61,7 +61,7 @@
TEST(SocketAddressTest, TestIPv6StringPortCtor) {
SocketAddress addr2(kTestV6AddrString, 1234);
- webrtc::IPAddress tocheck(kTestV6Addr);
+ IPAddress tocheck(kTestV6Addr);
EXPECT_FALSE(addr2.IsUnresolvedIP());
EXPECT_EQ(tocheck, addr2.ipaddr());
@@ -74,7 +74,7 @@
// inet_addr doesn't handle this address properly.
SocketAddress addr("255.255.255.255", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0xFFFFFFFFU), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0xFFFFFFFFU), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("255.255.255.255", addr.hostname());
EXPECT_EQ("255.255.255.255:5678", addr.ToString());
@@ -83,7 +83,7 @@
TEST(SocketAddressTest, TestHostnamePortCtor) {
SocketAddress addr("a.b.com", 5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -93,7 +93,7 @@
SocketAddress from("1.2.3.4", 5678);
SocketAddress addr(from);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -101,49 +101,49 @@
TEST(SocketAddressTest, TestAssign) {
SocketAddress from("1.2.3.4", 5678);
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr = from;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPPort) {
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
- addr.SetIP(webrtc::IPAddress(0x01020304));
+ SocketAddress addr(IPAddress(0x88888888), 9999);
+ addr.SetIP(IPAddress(0x01020304));
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromString) {
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("1.2.3.4");
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromHostname) {
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("a.b.com");
addr.SetPort(5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
- addr.SetResolvedIP(webrtc::IPAddress(0x01020304));
+ addr.SetResolvedIP(IPAddress(0x01020304));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
}
@@ -152,7 +152,7 @@
SocketAddress addr;
EXPECT_TRUE(addr.FromString("1.2.3.4:5678"));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -171,7 +171,7 @@
SocketAddress addr;
EXPECT_TRUE(addr.FromString("a.b.com:5678"));
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -183,7 +183,7 @@
from.ToSockAddr(&addr_in);
EXPECT_TRUE(addr.FromSockAddr(addr_in));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -195,7 +195,7 @@
from.ToSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -204,7 +204,7 @@
from.ToDualStackSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(kMappedV4Addr), addr.ipaddr());
+ EXPECT_EQ(IPAddress(kMappedV4Addr), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("[::ffff:1.2.3.4]:5678", addr.ToString());
@@ -216,7 +216,7 @@
from.ToSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(kTestV6Addr), addr.ipaddr());
+ EXPECT_EQ(IPAddress(kTestV6Addr), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ(kTestV6AddrFullString, addr.ToString());
@@ -226,7 +226,7 @@
from.ToDualStackSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(kTestV6Addr), addr.ipaddr());
+ EXPECT_EQ(IPAddress(kTestV6Addr), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ(kTestV6AddrFullString, addr.ToString());
@@ -338,14 +338,14 @@
SocketAddress ipv4OnlyLiteral("1.2.3.4", 5678);
EXPECT_EQ("1.2.3.x:5678", ipv4OnlyLiteral.ToSensitiveNameAndAddressString());
- SocketAddress ipv4OnlyAddress(webrtc::IPAddress(0x01020304), 5678);
+ SocketAddress ipv4OnlyAddress(IPAddress(0x01020304), 5678);
EXPECT_EQ("1.2.3.x:5678", ipv4OnlyAddress.ToSensitiveNameAndAddressString());
SocketAddress hostOnly("webrtc.org", 443);
EXPECT_EQ("webrtc.org:443", hostOnly.ToSensitiveNameAndAddressString());
SocketAddress hostAndIpv4("webrtc.org", 80);
- hostAndIpv4.SetResolvedIP(webrtc::IPAddress(0x01020304));
+ hostAndIpv4.SetResolvedIP(IPAddress(0x01020304));
EXPECT_EQ("webrtc.org:80 (1.2.3.x:80)",
hostAndIpv4.ToSensitiveNameAndAddressString());
@@ -353,14 +353,14 @@
EXPECT_EQ(kTestV6AddrFullAnonymizedString,
ipv6OnlyLiteral.ToSensitiveNameAndAddressString());
- SocketAddress ipv6OnlyAddress(webrtc::IPAddress(kTestV6Addr), 5678);
+ SocketAddress ipv6OnlyAddress(IPAddress(kTestV6Addr), 5678);
EXPECT_EQ(kTestV6AddrFullAnonymizedString,
ipv6OnlyAddress.ToSensitiveNameAndAddressString());
SocketAddress hostAndIpv6("webrtc.org", 5678);
- hostAndIpv6.SetResolvedIP(webrtc::IPAddress(kTestV6Addr));
+ hostAndIpv6.SetResolvedIP(IPAddress(kTestV6Addr));
EXPECT_EQ("webrtc.org:5678 (" + kTestV6AddrFullAnonymizedString + ")",
hostAndIpv6.ToSensitiveNameAndAddressString());
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index 76715b6..0067e55 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -262,7 +262,7 @@
void SocketTest::ConnectInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -275,7 +275,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
@@ -322,7 +322,7 @@
void SocketTest::ConnectWithDnsLookupInternal(const webrtc::IPAddress& loopback,
absl::string_view host) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -333,11 +333,11 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
- SocketAddress dns_addr(server->GetLocalAddress());
+ webrtc::SocketAddress dns_addr(server->GetLocalAddress());
dns_addr.SetIP(host);
EXPECT_EQ(0, client->Connect(dns_addr));
// TODO: Bind when doing DNS lookup.
@@ -375,7 +375,7 @@
void SocketTest::ConnectFailInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -386,12 +386,12 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
// Attempt connect to a non-existent socket.
// We don't connect to the server socket created above, since on
// MacOS it takes about 75 seconds to get back an error!
- SocketAddress bogus_addr(loopback, 65535);
+ webrtc::SocketAddress bogus_addr(loopback, 65535);
EXPECT_EQ(0, client->Connect(bogus_addr));
// Wait for connection to fail (ECONNREFUSED).
@@ -411,7 +411,7 @@
void SocketTest::ConnectWithDnsLookupFailInternal(
const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -422,12 +422,12 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
// Attempt connect to a non-existent host.
// We don't connect to the server socket created above, since on
// MacOS it takes about 75 seconds to get back an error!
- SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
+ webrtc::SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
EXPECT_EQ(0, client->Connect(bogus_dns_addr));
// Wait for connection to fail (EHOSTNOTFOUND).
@@ -456,7 +456,7 @@
// Create server and listen.
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create a client and put in to CS_CLOSED state.
@@ -466,7 +466,8 @@
EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
// Connect() should reinitialize the socket, and put it in to CS_CONNECTING.
- EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
+ EXPECT_EQ(0,
+ client->Connect(webrtc::SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
}
@@ -477,19 +478,20 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create client, connect.
std::unique_ptr<Socket> client(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
+ EXPECT_EQ(0,
+ client->Connect(webrtc::SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
// Try to connect again. Should fail, but not interfere with original attempt.
EXPECT_EQ(SOCKET_ERROR,
- client->Connect(SocketAddress(server->GetLocalAddress())));
+ client->Connect(webrtc::SocketAddress(server->GetLocalAddress())));
// Accept the original connection.
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
EXPECT_THAT(
webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
@@ -510,7 +512,7 @@
// Try to connect again, to an unresolved hostname.
// Shouldn't break anything.
- EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress(
+ EXPECT_EQ(SOCKET_ERROR, client->Connect(webrtc::SocketAddress(
"localhost", server->GetLocalAddress().port())));
EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
@@ -531,7 +533,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
@@ -555,7 +557,7 @@
void SocketTest::ClientCloseDuringConnectInternal(
const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -566,7 +568,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
@@ -598,7 +600,7 @@
void SocketTest::ServerCloseInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -609,7 +611,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -683,7 +685,7 @@
const webrtc::IPAddress& loopback) {
StreamSink sink;
SocketCloser closer;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -695,7 +697,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -757,8 +759,8 @@
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
std::unique_ptr<Socket> socket2(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0)));
- EXPECT_EQ(0, socket2->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, socket1->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, socket2->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(3, socket1->SendTo("foo", 3, socket1->GetLocalAddress()));
EXPECT_EQ(3, socket2->SendTo("bar", 3, socket1->GetLocalAddress()));
// Sleep a while to ensure sends are both completed at the same time.
@@ -775,7 +777,7 @@
void SocketTest::SocketServerWaitInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create & connect server and client sockets.
std::unique_ptr<Socket> client(
@@ -784,7 +786,7 @@
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
@@ -833,7 +835,7 @@
size_t data_size,
ptrdiff_t max_send_size) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create receiving client.
std::unique_ptr<Socket> receiver(
@@ -844,7 +846,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -973,7 +975,7 @@
void SocketTest::SingleFlowControlCallbackInternal(
const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -984,7 +986,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -1055,12 +1057,13 @@
}
void SocketTest::UdpInternal(const webrtc::IPAddress& loopback) {
- SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(loopback.family());
// Test basic bind and connect behavior.
Socket* socket = socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
- EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
- SocketAddress addr1 = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
+ webrtc::SocketAddress addr1 = socket->GetLocalAddress();
EXPECT_EQ(0, socket->Connect(addr1));
EXPECT_EQ(Socket::CS_CONNECTED, socket->GetState());
socket->Close();
@@ -1073,11 +1076,11 @@
auto client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- SocketAddress addr2;
+ webrtc::SocketAddress addr2;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr2));
- SocketAddress addr3;
+ webrtc::SocketAddress addr3;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr2));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr3));
EXPECT_EQ(addr3, addr1);
@@ -1086,12 +1089,12 @@
client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- SocketAddress addr4;
+ webrtc::SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
EXPECT_EQ(addr4.ipaddr(), addr2.ipaddr());
- SocketAddress addr5;
+ webrtc::SocketAddress addr5;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
EXPECT_EQ(addr5, addr1);
@@ -1101,13 +1104,14 @@
}
void SocketTest::UdpReadyToSend(const webrtc::IPAddress& loopback) {
- SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(loopback.family());
// RFC 5737 - The blocks 192.0.2.0/24 (TEST-NET-1) ... are provided for use in
// documentation.
// RFC 3849 - 2001:DB8::/32 as a documentation-only prefix.
std::string dest =
(loopback.family() == AF_INET6) ? "2001:db8::1" : "192.0.2.0";
- SocketAddress test_addr(dest, 2345);
+ webrtc::SocketAddress test_addr(dest, 2345);
// Test send
auto client = std::make_unique<webrtc::TestClient>(
@@ -1151,7 +1155,7 @@
void SocketTest::GetSetOptionsInternal(const webrtc::IPAddress& loopback) {
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- socket->Bind(SocketAddress(loopback, 0));
+ socket->Bind(webrtc::SocketAddress(loopback, 0));
// Check SNDBUF/RCVBUF.
const int desired_size = 12345;
@@ -1204,7 +1208,7 @@
// Prepare on TCP specific options.
socket.reset(socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- socket->Bind(SocketAddress(loopback, 0));
+ socket->Bind(webrtc::SocketAddress(loopback, 0));
// Check that we can set NODELAY on a TCP socket.
ASSERT_NE(-1, socket->SetOption(Socket::OPT_NODELAY, desired_nd));
@@ -1245,8 +1249,8 @@
StreamSink sink;
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
- SocketAddress address = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
+ webrtc::SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
int64_t send_time_1 = TimeMicros();
@@ -1284,11 +1288,12 @@
void SocketTest::UdpSocketRecvTimestampUseRtcEpoch(
const webrtc::IPAddress& loopback) {
- SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(loopback.family());
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- ASSERT_EQ(socket->Bind(SocketAddress(loopback, 0)), 0);
- SocketAddress address = socket->GetLocalAddress();
+ ASSERT_EQ(socket->Bind(webrtc::SocketAddress(loopback, 0)), 0);
+ webrtc::SocketAddress address = socket->GetLocalAddress();
socket = nullptr;
auto client1 = std::make_unique<webrtc::TestClient>(
@@ -1296,7 +1301,7 @@
auto client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- SocketAddress addr2;
+ webrtc::SocketAddress addr2;
client2->SendTo("foo", 3, address);
std::unique_ptr<webrtc::TestClient::Packet> packet_1 =
client1->NextPacket(10000);
@@ -1316,8 +1321,8 @@
StreamSink sink;
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
- SocketAddress address = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
+ webrtc::SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
rtc::Buffer buffer;
Socket::ReceiveBuffer receive_buffer(buffer);
diff --git a/rtc_base/ssl_adapter.h b/rtc_base/ssl_adapter.h
index 2bce106..c366081 100644
--- a/rtc_base/ssl_adapter.h
+++ b/rtc_base/ssl_adapter.h
@@ -107,7 +107,7 @@
private:
// Not supported.
int Listen(int backlog) override { RTC_CHECK(false); }
- Socket* Accept(SocketAddress* paddr) override { RTC_CHECK(false); }
+ Socket* Accept(webrtc::SocketAddress* paddr) override { RTC_CHECK(false); }
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/rtc_base/ssl_adapter_unittest.cc b/rtc_base/ssl_adapter_unittest.cc
index 032f3a0..6a8d0e6 100644
--- a/rtc_base/ssl_adapter_unittest.cc
+++ b/rtc_base/ssl_adapter_unittest.cc
@@ -39,7 +39,7 @@
static const webrtc::TimeDelta kTimeout = webrtc::TimeDelta::Millis(5000);
static rtc::Socket* CreateSocket() {
- rtc::SocketAddress address(webrtc::IPAddress(INADDR_ANY), 0);
+ webrtc::SocketAddress address(webrtc::IPAddress(INADDR_ANY), 0);
rtc::Socket* socket = rtc::Thread::Current()->socketserver()->CreateSocket(
address.family(), SOCK_STREAM);
@@ -93,7 +93,7 @@
ssl_adapter_->SetEllipticCurves(curves);
}
- rtc::SocketAddress GetAddress() const {
+ webrtc::SocketAddress GetAddress() const {
return ssl_adapter_->GetLocalAddress();
}
@@ -146,7 +146,8 @@
CreateSSLAdapter(socket_.release(), webrtc::SSL_CLIENT);
}
- int Connect(absl::string_view hostname, const rtc::SocketAddress& address) {
+ int Connect(absl::string_view hostname,
+ const webrtc::SocketAddress& address) {
RTC_LOG(LS_INFO) << "Initiating connection with " << address.ToString();
int rv = ssl_adapter_->Connect(address);
@@ -175,7 +176,9 @@
<< socket_->GetLocalAddress().ToString();
}
- rtc::SocketAddress GetAddress() const { return socket_->GetLocalAddress(); }
+ webrtc::SocketAddress GetAddress() const {
+ return socket_->GetLocalAddress();
+ }
std::string GetHostname() const {
// Since we don't have a real certificate anyway, the value here doesn't
diff --git a/rtc_base/test_client.cc b/rtc_base/test_client.cc
index 58409ea..a003599 100644
--- a/rtc_base/test_client.cc
+++ b/rtc_base/test_client.cc
@@ -65,7 +65,7 @@
int TestClient::SendTo(const char* buf,
size_t size,
- const rtc::SocketAddress& dest) {
+ const SocketAddress& dest) {
rtc::PacketOptions options;
return socket_->SendTo(buf, size, dest, options);
}
@@ -106,7 +106,7 @@
bool TestClient::CheckNextPacket(const char* buf,
size_t size,
- rtc::SocketAddress* addr) {
+ SocketAddress* addr) {
bool res = false;
std::unique_ptr<Packet> packet = NextPacket(kTimeoutMs);
if (packet) {
diff --git a/rtc_base/test_client.h b/rtc_base/test_client.h
index 1915c80..5adc108 100644
--- a/rtc_base/test_client.h
+++ b/rtc_base/test_client.h
@@ -32,7 +32,7 @@
Packet(const rtc::ReceivedPacket& received_packet);
Packet(const Packet& p);
- rtc::SocketAddress addr;
+ SocketAddress addr;
Buffer buf;
std::optional<Timestamp> packet_time;
};
@@ -53,10 +53,8 @@
TestClient(const TestClient&) = delete;
TestClient& operator=(const TestClient&) = delete;
- rtc::SocketAddress address() const { return socket_->GetLocalAddress(); }
- rtc::SocketAddress remote_address() const {
- return socket_->GetRemoteAddress();
- }
+ SocketAddress address() const { return socket_->GetLocalAddress(); }
+ SocketAddress remote_address() const { return socket_->GetRemoteAddress(); }
// Checks that the socket moves to the specified connect state.
bool CheckConnState(rtc::AsyncPacketSocket::State state);
@@ -70,7 +68,7 @@
int Send(const char* buf, size_t size);
// Sends using the clients socket to the given destination.
- int SendTo(const char* buf, size_t size, const rtc::SocketAddress& dest);
+ int SendTo(const char* buf, size_t size, const SocketAddress& dest);
// Returns the next packet received by the client or null if none is received
// within the specified timeout.
@@ -78,7 +76,7 @@
// Checks that the next packet has the given contents. Returns the remote
// address that the packet was sent from.
- bool CheckNextPacket(const char* buf, size_t len, rtc::SocketAddress* addr);
+ bool CheckNextPacket(const char* buf, size_t len, SocketAddress* addr);
// Checks that no packets have arrived or will arrive in the next second.
bool CheckNoPacket();
diff --git a/rtc_base/test_client_unittest.cc b/rtc_base/test_client_unittest.cc
index 3b3a8e0..fd7d753 100644
--- a/rtc_base/test_client_unittest.cc
+++ b/rtc_base/test_client_unittest.cc
@@ -39,7 +39,7 @@
namespace webrtc {
namespace {
-void TestUdpInternal(const rtc::SocketAddress& loopback) {
+void TestUdpInternal(const SocketAddress& loopback) {
rtc::PhysicalSocketServer socket_server;
rtc::AutoSocketServerThread main_thread(&socket_server);
rtc::Socket* socket =
@@ -47,14 +47,14 @@
socket->Bind(loopback);
TestClient client(std::make_unique<rtc::AsyncUDPSocket>(socket));
- rtc::SocketAddress addr = client.address(), from;
+ SocketAddress addr = client.address(), from;
EXPECT_EQ(3, client.SendTo("foo", 3, addr));
EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
EXPECT_EQ(from, addr);
EXPECT_TRUE(client.CheckNoPacket());
}
-void TestTcpInternal(const rtc::SocketAddress& loopback) {
+void TestTcpInternal(const SocketAddress& loopback) {
rtc::PhysicalSocketServer socket_server;
rtc::AutoSocketServerThread main_thread(&socket_server);
webrtc::TestEchoServer server(&main_thread, loopback);
@@ -66,7 +66,7 @@
ASSERT_TRUE(tcp_socket != nullptr);
TestClient client(std::move(tcp_socket));
- rtc::SocketAddress addr = client.address(), from;
+ SocketAddress addr = client.address(), from;
EXPECT_TRUE(client.CheckConnected());
EXPECT_EQ(3, client.Send("foo", 3));
EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
@@ -77,7 +77,7 @@
// Tests whether the TestClient can send UDP to itself.
TEST(TestClientTest, TestUdpIPv4) {
MAYBE_SKIP_IPV4;
- TestUdpInternal(rtc::SocketAddress("127.0.0.1", 0));
+ TestUdpInternal(SocketAddress("127.0.0.1", 0));
}
#if defined(WEBRTC_LINUX)
@@ -87,13 +87,13 @@
#endif
TEST(TestClientTest, MAYBE_TestUdpIPv6) {
MAYBE_SKIP_IPV6;
- TestUdpInternal(rtc::SocketAddress("::1", 0));
+ TestUdpInternal(SocketAddress("::1", 0));
}
// Tests whether the TestClient can connect to a server and exchange data.
TEST(TestClientTest, TestTcpIPv4) {
MAYBE_SKIP_IPV4;
- TestTcpInternal(rtc::SocketAddress("127.0.0.1", 0));
+ TestTcpInternal(SocketAddress("127.0.0.1", 0));
}
#if defined(WEBRTC_LINUX)
@@ -103,7 +103,7 @@
#endif
TEST(TestClientTest, MAYBE_TestTcpIPv6) {
MAYBE_SKIP_IPV6;
- TestTcpInternal(rtc::SocketAddress("::1", 0));
+ TestTcpInternal(SocketAddress("::1", 0));
}
} // namespace
diff --git a/rtc_base/test_echo_server.cc b/rtc_base/test_echo_server.cc
index 1888a07..8f80220 100644
--- a/rtc_base/test_echo_server.cc
+++ b/rtc_base/test_echo_server.cc
@@ -14,8 +14,7 @@
namespace webrtc {
-TestEchoServer::TestEchoServer(rtc::Thread* thread,
- const rtc::SocketAddress& addr)
+TestEchoServer::TestEchoServer(rtc::Thread* thread, const SocketAddress& addr)
: server_socket_(
thread->socketserver()->CreateSocket(addr.family(), SOCK_STREAM)) {
server_socket_->Bind(addr);
diff --git a/rtc_base/test_echo_server.h b/rtc_base/test_echo_server.h
index c9d15f0..b549b50 100644
--- a/rtc_base/test_echo_server.h
+++ b/rtc_base/test_echo_server.h
@@ -33,15 +33,13 @@
// Useful for unit tests.
class TestEchoServer : public sigslot::has_slots<> {
public:
- TestEchoServer(rtc::Thread* thread, const rtc::SocketAddress& addr);
+ TestEchoServer(rtc::Thread* thread, const SocketAddress& addr);
~TestEchoServer() override;
TestEchoServer(const TestEchoServer&) = delete;
TestEchoServer& operator=(const TestEchoServer&) = delete;
- rtc::SocketAddress address() const {
- return server_socket_->GetLocalAddress();
- }
+ SocketAddress address() const { return server_socket_->GetLocalAddress(); }
private:
void OnAccept(rtc::Socket* socket) {
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index da7a36e..3184061 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -91,7 +91,7 @@
class SocketClient : public TestGenerator, public sigslot::has_slots<> {
public:
SocketClient(Socket* socket,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
Thread* post_thread,
MessageClient* phandler)
: socket_(AsyncUDPSocket::Create(socket, addr)),
@@ -105,7 +105,7 @@
~SocketClient() override { delete socket_; }
- SocketAddress address() const { return socket_->GetLocalAddress(); }
+ webrtc::SocketAddress address() const { return socket_->GetLocalAddress(); }
void OnPacket(AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
EXPECT_EQ(packet.payload().size(), sizeof(uint32_t));
@@ -159,7 +159,7 @@
// See: https://code.google.com/p/webrtc/issues/detail?id=2409
TEST(ThreadTest, DISABLED_Main) {
rtc::AutoThread main_thread;
- const SocketAddress addr("127.0.0.1", 0);
+ const webrtc::SocketAddress addr("127.0.0.1", 0);
// Create the messaging client on its own thread.
auto th1 = Thread::CreateWithSocketServer();
diff --git a/rtc_base/virtual_socket_server.cc b/rtc_base/virtual_socket_server.cc
index 9e2d657..ebac6b0 100644
--- a/rtc_base/virtual_socket_server.cc
+++ b/rtc_base/virtual_socket_server.cc
@@ -63,7 +63,9 @@
// the kernel does.
class VirtualSocketPacket {
public:
- VirtualSocketPacket(const char* data, size_t size, const SocketAddress& from)
+ VirtualSocketPacket(const char* data,
+ size_t size,
+ const webrtc::SocketAddress& from)
: size_(size), consumed_(0), from_(from) {
RTC_DCHECK(nullptr != data);
data_ = new char[size_];
@@ -74,7 +76,7 @@
const char* data() const { return data_ + consumed_; }
size_t size() const { return size_ - consumed_; }
- const SocketAddress& from() const { return from_; }
+ const webrtc::SocketAddress& from() const { return from_; }
// Remove the first size bytes from the data.
void Consume(size_t size) {
@@ -85,7 +87,7 @@
private:
char* data_;
size_t size_, consumed_;
- SocketAddress from_;
+ webrtc::SocketAddress from_;
};
VirtualSocket::VirtualSocket(VirtualSocketServer* server, int family, int type)
@@ -106,19 +108,19 @@
Close();
}
-SocketAddress VirtualSocket::GetLocalAddress() const {
+webrtc::SocketAddress VirtualSocket::GetLocalAddress() const {
return local_addr_;
}
-SocketAddress VirtualSocket::GetRemoteAddress() const {
+webrtc::SocketAddress VirtualSocket::GetRemoteAddress() const {
return remote_addr_;
}
-void VirtualSocket::SetLocalAddress(const SocketAddress& addr) {
+void VirtualSocket::SetLocalAddress(const webrtc::SocketAddress& addr) {
local_addr_ = addr;
}
-int VirtualSocket::Bind(const SocketAddress& addr) {
+int VirtualSocket::Bind(const webrtc::SocketAddress& addr) {
if (!local_addr_.IsNil()) {
error_ = EINVAL;
return -1;
@@ -135,7 +137,7 @@
return result;
}
-int VirtualSocket::Connect(const SocketAddress& addr) {
+int VirtualSocket::Connect(const webrtc::SocketAddress& addr) {
return InitiateConnect(addr, true);
}
@@ -152,7 +154,7 @@
void VirtualSocket::SafetyBlock::SetNotAlive() {
VirtualSocketServer* const server = socket_.server_;
- const SocketAddress& local_addr = socket_.local_addr_;
+ const webrtc::SocketAddress& local_addr = socket_.local_addr_;
MutexLock lock(&mutex_);
// Cancel pending sockets
@@ -242,7 +244,7 @@
int VirtualSocket::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
if (SOCK_DGRAM == type_) {
return SendUdp(pv, cb, addr);
} else {
@@ -255,13 +257,13 @@
}
int VirtualSocket::Recv(void* pv, size_t cb, int64_t* timestamp) {
- SocketAddress addr;
+ webrtc::SocketAddress addr;
return RecvFrom(pv, cb, &addr, timestamp);
}
int VirtualSocket::RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) {
if (timestamp) {
*timestamp = -1;
@@ -286,7 +288,7 @@
int VirtualSocket::SafetyBlock::RecvFrom(void* buffer,
size_t size,
- SocketAddress& addr) {
+ webrtc::SocketAddress& addr) {
MutexLock lock(&mutex_);
// If we don't have a packet, then either error or wait for one to arrive.
if (recv_buffer_.empty()) {
@@ -332,7 +334,7 @@
listen_queue_.emplace();
}
-VirtualSocket* VirtualSocket::Accept(SocketAddress* paddr) {
+VirtualSocket* VirtualSocket::Accept(webrtc::SocketAddress* paddr) {
SafetyBlock::AcceptResult result = safety_->Accept();
if (result.error != 0) {
error_ = result.error;
@@ -360,7 +362,7 @@
socket->SetLocalAddress(socket_.local_addr_);
// Sockets made from a socket that 'was Any' need to inherit that.
socket->set_was_any(socket_.was_any());
- SocketAddress remote_addr = listen_queue_->front();
+ webrtc::SocketAddress remote_addr = listen_queue_->front();
listen_queue_->pop_front();
if (socket->InitiateConnect(remote_addr, false) != 0) {
continue;
@@ -424,12 +426,13 @@
}
void VirtualSocket::PostConnect(TimeDelta delay,
- const SocketAddress& remote_addr) {
+ const webrtc::SocketAddress& remote_addr) {
safety_->PostConnect(delay, remote_addr);
}
-void VirtualSocket::SafetyBlock::PostConnect(TimeDelta delay,
- const SocketAddress& remote_addr) {
+void VirtualSocket::SafetyBlock::PostConnect(
+ TimeDelta delay,
+ const webrtc::SocketAddress& remote_addr) {
rtc::scoped_refptr<SafetyBlock> safety(this);
MutexLock lock(&mutex_);
@@ -463,7 +466,7 @@
return Signal::kNone;
}
RTC_DCHECK(!posted_connects_.empty());
- SocketAddress remote_addr = *remote_addr_it;
+ webrtc::SocketAddress remote_addr = *remote_addr_it;
posted_connects_.erase(remote_addr_it);
if (listen_queue_.has_value()) {
@@ -506,7 +509,8 @@
server_->msg_queue_->PostDelayedTask(std::move(task), delay);
}
-int VirtualSocket::InitiateConnect(const SocketAddress& addr, bool use_delay) {
+int VirtualSocket::InitiateConnect(const webrtc::SocketAddress& addr,
+ bool use_delay) {
if (!remote_addr_.IsNil()) {
error_ = (CS_CONNECTED == state_) ? EISCONN : EINPROGRESS;
return -1;
@@ -515,9 +519,9 @@
// If there's no local address set, grab a random one in the correct AF.
int result = 0;
if (addr.ipaddr().family() == AF_INET) {
- result = Bind(SocketAddress("0.0.0.0", 0));
+ result = Bind(webrtc::SocketAddress("0.0.0.0", 0));
} else if (addr.ipaddr().family() == AF_INET6) {
- result = Bind(SocketAddress("::", 0));
+ result = Bind(webrtc::SocketAddress("::", 0));
}
if (result != 0) {
return result;
@@ -537,7 +541,7 @@
return 0;
}
-void VirtualSocket::CompleteConnect(const SocketAddress& addr) {
+void VirtualSocket::CompleteConnect(const webrtc::SocketAddress& addr) {
RTC_DCHECK(CS_CONNECTING == state_);
remote_addr_ = addr;
state_ = CS_CONNECTED;
@@ -546,11 +550,11 @@
int VirtualSocket::SendUdp(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
// If we have not been assigned a local port, then get one.
if (local_addr_.IsNil()) {
local_addr_ = server_->AssignBindAddress(
- EmptySocketAddressWithFamily(addr.ipaddr().family()));
+ webrtc::EmptySocketAddressWithFamily(addr.ipaddr().family()));
int result = server_->Bind(this, local_addr_);
if (result != 0) {
local_addr_.Clear();
@@ -773,8 +777,8 @@
}
bool VirtualSocketServer::CloseTcpConnections(
- const SocketAddress& addr_local,
- const SocketAddress& addr_remote) {
+ const webrtc::SocketAddress& addr_local,
+ const webrtc::SocketAddress& addr_remote) {
VirtualSocket* socket = LookupConnection(addr_local, addr_remote);
if (!socket) {
return false;
@@ -789,25 +793,25 @@
}
int VirtualSocketServer::Bind(VirtualSocket* socket,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
RTC_DCHECK(nullptr != socket);
// Address must be completely specified at this point
RTC_DCHECK(!webrtc::IPIsUnspec(addr.ipaddr()));
RTC_DCHECK(addr.port() != 0);
// Normalize the address (turns v6-mapped addresses into v4-addresses).
- SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+ webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
AddressMap::value_type entry(normalized, socket);
return bindings_->insert(entry).second ? 0 : -1;
}
-SocketAddress VirtualSocketServer::AssignBindAddress(
- const SocketAddress& app_addr) {
+webrtc::SocketAddress VirtualSocketServer::AssignBindAddress(
+ const webrtc::SocketAddress& app_addr) {
RTC_DCHECK(!webrtc::IPIsUnspec(app_addr.ipaddr()));
// Normalize the IP.
- SocketAddress addr;
+ webrtc::SocketAddress addr;
addr.SetIP(app_addr.ipaddr().Normalized());
// If the IP appears in `alternative_address_mapping_`, meaning the test has
@@ -833,8 +837,9 @@
return addr;
}
-VirtualSocket* VirtualSocketServer::LookupBinding(const SocketAddress& addr) {
- SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+VirtualSocket* VirtualSocketServer::LookupBinding(
+ const webrtc::SocketAddress& addr) {
+ webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
AddressMap::iterator it = bindings_->find(normalized);
if (it != bindings_->end()) {
return it->second;
@@ -846,8 +851,8 @@
// If we can't find a binding for the packet which is sent to the interface
// corresponding to the default route, it should match a binding with the
// correct port to the any address.
- SocketAddress sock_addr =
- EmptySocketAddressWithFamily(addr.ipaddr().family());
+ webrtc::SocketAddress sock_addr =
+ webrtc::EmptySocketAddressWithFamily(addr.ipaddr().family());
sock_addr.SetPort(addr.port());
return LookupBinding(sock_addr);
}
@@ -855,40 +860,47 @@
return nullptr;
}
-int VirtualSocketServer::Unbind(const SocketAddress& addr,
+int VirtualSocketServer::Unbind(const webrtc::SocketAddress& addr,
VirtualSocket* socket) {
- SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+ webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
RTC_DCHECK((*bindings_)[normalized] == socket);
bindings_->erase(bindings_->find(normalized));
return 0;
}
-void VirtualSocketServer::AddConnection(const SocketAddress& local,
- const SocketAddress& remote,
+void VirtualSocketServer::AddConnection(const webrtc::SocketAddress& local,
+ const webrtc::SocketAddress& remote,
VirtualSocket* remote_socket) {
// Add this socket pair to our routing table. This will allow
// multiple clients to connect to the same server address.
- SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
- SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+ webrtc::SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ webrtc::SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
webrtc::SocketAddressPair address_pair(local_normalized, remote_normalized);
connections_->insert(std::pair<webrtc::SocketAddressPair, VirtualSocket*>(
address_pair, remote_socket));
}
VirtualSocket* VirtualSocketServer::LookupConnection(
- const SocketAddress& local,
- const SocketAddress& remote) {
- SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
- SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+ const webrtc::SocketAddress& local,
+ const webrtc::SocketAddress& remote) {
+ webrtc::SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ webrtc::SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
webrtc::SocketAddressPair address_pair(local_normalized, remote_normalized);
ConnectionMap::iterator it = connections_->find(address_pair);
return (connections_->end() != it) ? it->second : nullptr;
}
-void VirtualSocketServer::RemoveConnection(const SocketAddress& local,
- const SocketAddress& remote) {
- SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
- SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+void VirtualSocketServer::RemoveConnection(
+ const webrtc::SocketAddress& local,
+ const webrtc::SocketAddress& remote) {
+ webrtc::SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ webrtc::SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
webrtc::SocketAddressPair address_pair(local_normalized, remote_normalized);
connections_->erase(address_pair);
}
@@ -898,7 +910,7 @@
}
int VirtualSocketServer::Connect(VirtualSocket* socket,
- const SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
bool use_delay) {
RTC_DCHECK(msg_queue_);
@@ -929,12 +941,12 @@
return true;
}
-bool VirtualSocketServer::Disconnect(const SocketAddress& addr) {
+bool VirtualSocketServer::Disconnect(const webrtc::SocketAddress& addr) {
return Disconnect(LookupBinding(addr));
}
-bool VirtualSocketServer::Disconnect(const SocketAddress& local_addr,
- const SocketAddress& remote_addr) {
+bool VirtualSocketServer::Disconnect(const webrtc::SocketAddress& local_addr,
+ const webrtc::SocketAddress& remote_addr) {
// Disconnect remote socket, check if it is a child of a server socket.
VirtualSocket* socket = LookupConnection(local_addr, remote_addr);
if (!socket) {
@@ -955,7 +967,7 @@
int VirtualSocketServer::SendUdp(VirtualSocket* socket,
const char* data,
size_t data_size,
- const SocketAddress& remote_addr) {
+ const webrtc::SocketAddress& remote_addr) {
{
webrtc::MutexLock lock(&mutex_);
++sent_packets_;
@@ -1074,7 +1086,7 @@
socket->MaybeSignalWriteEvent(send_buffer_capacity());
}
-void VirtualSocketServer::SendTcp(const SocketAddress& addr) {
+void VirtualSocketServer::SendTcp(const webrtc::SocketAddress& addr) {
VirtualSocket* sender = LookupBinding(addr);
RTC_DCHECK(nullptr != sender);
SendTcp(sender);
@@ -1096,7 +1108,7 @@
// When the incoming packet is from a binding of the any address, translate it
// to the default route here such that the recipient will see the default
// route.
- SocketAddress sender_addr = sender->GetLocalAddress();
+ webrtc::SocketAddress sender_addr = sender->GetLocalAddress();
webrtc::IPAddress default_ip =
GetDefaultSourceAddress(sender_addr.ipaddr().family());
if (sender_addr.IsAnyIP() && !webrtc::IPIsUnspec(default_ip)) {
diff --git a/rtc_base/virtual_socket_server.h b/rtc_base/virtual_socket_server.h
index cec649b..9c7f2c3 100644
--- a/rtc_base/virtual_socket_server.h
+++ b/rtc_base/virtual_socket_server.h
@@ -39,21 +39,23 @@
VirtualSocket(VirtualSocketServer* server, int family, int type);
~VirtualSocket() override;
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
- int Bind(const SocketAddress& addr) override;
- int Connect(const SocketAddress& addr) override;
+ int Bind(const webrtc::SocketAddress& addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
int Close() override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override;
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override;
int Listen(int backlog) override;
- VirtualSocket* Accept(SocketAddress* paddr) override;
+ VirtualSocket* Accept(webrtc::SocketAddress* paddr) override;
int GetError() const override;
void SetError(int error) override;
@@ -66,7 +68,7 @@
const char* send_buffer_data() const { return send_buffer_.data(); }
// Used by server sockets to set the local address without binding.
- void SetLocalAddress(const SocketAddress& addr);
+ void SetLocalAddress(const webrtc::SocketAddress& addr);
bool was_any() { return was_any_; }
void set_was_any(bool was_any) { was_any_ = was_any; }
@@ -88,7 +90,8 @@
void PostPacket(webrtc::TimeDelta delay,
std::unique_ptr<VirtualSocketPacket> packet);
- void PostConnect(webrtc::TimeDelta delay, const SocketAddress& remote_addr);
+ void PostConnect(webrtc::TimeDelta delay,
+ const webrtc::SocketAddress& remote_addr);
void PostDisconnect(webrtc::TimeDelta delay);
private:
@@ -108,25 +111,26 @@
// Copies up to `size` bytes into buffer from the next received packet
// and fills `addr` with remote address of that received packet.
// Returns number of bytes copied or negative value on failure.
- int RecvFrom(void* buffer, size_t size, SocketAddress& addr);
+ int RecvFrom(void* buffer, size_t size, webrtc::SocketAddress& addr);
void Listen();
struct AcceptResult {
int error = 0;
std::unique_ptr<VirtualSocket> socket;
- SocketAddress remote_addr;
+ webrtc::SocketAddress remote_addr;
};
AcceptResult Accept();
bool AddPacket(std::unique_ptr<VirtualSocketPacket> packet);
- void PostConnect(webrtc::TimeDelta delay, const SocketAddress& remote_addr);
+ void PostConnect(webrtc::TimeDelta delay,
+ const webrtc::SocketAddress& remote_addr);
private:
enum class Signal { kNone, kReadEvent, kConnectEvent };
// `PostConnect` rely on the fact that std::list iterators are not
// invalidated on any changes to other elements in the container.
- using PostedConnects = std::list<SocketAddress>;
+ using PostedConnects = std::list<webrtc::SocketAddress>;
void PostSignalReadEvent() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void MaybeSignalReadEvent();
@@ -153,7 +157,7 @@
RTC_GUARDED_BY(mutex_);
// Pending sockets which can be Accepted
- std::optional<std::deque<SocketAddress>> listen_queue_
+ std::optional<std::deque<webrtc::SocketAddress>> listen_queue_
RTC_GUARDED_BY(mutex_);
};
@@ -166,9 +170,9 @@
typedef std::vector<char> SendBuffer;
typedef std::map<Option, int> OptionsMap;
- int InitiateConnect(const SocketAddress& addr, bool use_delay);
- void CompleteConnect(const SocketAddress& addr);
- int SendUdp(const void* pv, size_t cb, const SocketAddress& addr);
+ int InitiateConnect(const webrtc::SocketAddress& addr, bool use_delay);
+ void CompleteConnect(const webrtc::SocketAddress& addr);
+ int SendUdp(const void* pv, size_t cb, const webrtc::SocketAddress& addr);
int SendTcp(const void* pv, size_t cb);
void OnSocketServerReadyToSend();
@@ -177,8 +181,8 @@
const int type_;
ConnState state_;
int error_;
- SocketAddress local_addr_;
- SocketAddress remote_addr_;
+ webrtc::SocketAddress local_addr_;
+ webrtc::SocketAddress remote_addr_;
const scoped_refptr<SafetyBlock> safety_ =
make_ref_counted<SafetyBlock>(this);
@@ -289,7 +293,7 @@
bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
- void SetDelayOnAddress(const rtc::SocketAddress& address, int delay_ms) {
+ void SetDelayOnAddress(const webrtc::SocketAddress& address, int delay_ms) {
delay_by_ip_[address.ipaddr()] = delay_ms;
}
@@ -320,8 +324,8 @@
// Close a pair of Tcp connections by addresses. Both connections will have
// its own OnClose invoked.
- bool CloseTcpConnections(const SocketAddress& addr_local,
- const SocketAddress& addr_remote);
+ bool CloseTcpConnections(const webrtc::SocketAddress& addr_local,
+ const webrtc::SocketAddress& addr_remote);
// Number of packets that clients have attempted to send through this virtual
// socket server. Intended to be used for test assertions.
@@ -329,44 +333,45 @@
// Assign IP and Port if application's address is unspecified. Also apply
// `alternative_address_mapping_`.
- SocketAddress AssignBindAddress(const SocketAddress& app_addr);
+ webrtc::SocketAddress AssignBindAddress(
+ const webrtc::SocketAddress& app_addr);
// Binds the given socket to the given (fully-defined) address.
- int Bind(VirtualSocket* socket, const SocketAddress& addr);
+ int Bind(VirtualSocket* socket, const webrtc::SocketAddress& addr);
- int Unbind(const SocketAddress& addr, VirtualSocket* socket);
+ int Unbind(const webrtc::SocketAddress& addr, VirtualSocket* socket);
// Adds a mapping between this socket pair and the socket.
- void AddConnection(const SocketAddress& client,
- const SocketAddress& server,
+ void AddConnection(const webrtc::SocketAddress& client,
+ const webrtc::SocketAddress& server,
VirtualSocket* socket);
// Connects the given socket to the socket at the given address
int Connect(VirtualSocket* socket,
- const SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
bool use_delay);
// Sends a disconnect message to the socket at the given address
bool Disconnect(VirtualSocket* socket);
// Lookup address, and disconnect corresponding socket.
- bool Disconnect(const SocketAddress& addr);
+ bool Disconnect(const webrtc::SocketAddress& addr);
// Lookup connection, close corresponding socket.
- bool Disconnect(const SocketAddress& local_addr,
- const SocketAddress& remote_addr);
+ bool Disconnect(const webrtc::SocketAddress& local_addr,
+ const webrtc::SocketAddress& remote_addr);
// Sends the given packet to the socket at the given address (if one exists).
int SendUdp(VirtualSocket* socket,
const char* data,
size_t data_size,
- const SocketAddress& remote_addr);
+ const webrtc::SocketAddress& remote_addr);
// Moves as much data as possible from the sender's buffer to the network
void SendTcp(VirtualSocket* socket) RTC_LOCKS_EXCLUDED(mutex_);
// Like above, but lookup sender by address.
- void SendTcp(const SocketAddress& addr) RTC_LOCKS_EXCLUDED(mutex_);
+ void SendTcp(const webrtc::SocketAddress& addr) RTC_LOCKS_EXCLUDED(mutex_);
// Computes the number of milliseconds required to send a packet of this size.
uint32_t SendDelay(uint32_t size) RTC_LOCKS_EXCLUDED(mutex_);
@@ -379,18 +384,18 @@
webrtc::IPAddress GetNextIP(int family);
// Find the socket bound to the given address
- VirtualSocket* LookupBinding(const SocketAddress& addr);
+ VirtualSocket* LookupBinding(const webrtc::SocketAddress& addr);
private:
friend VirtualSocket;
uint16_t GetNextPort();
// Find the socket pair corresponding to this server address.
- VirtualSocket* LookupConnection(const SocketAddress& client,
- const SocketAddress& server);
+ VirtualSocket* LookupConnection(const webrtc::SocketAddress& client,
+ const webrtc::SocketAddress& server);
- void RemoveConnection(const SocketAddress& client,
- const SocketAddress& server);
+ void RemoveConnection(const webrtc::SocketAddress& client,
+ const webrtc::SocketAddress& server);
// Places a packet on the network.
void AddPacketToNetwork(VirtualSocket* socket,
@@ -433,7 +438,7 @@
// NB: This scheme doesn't permit non-dualstack IPv6 sockets.
static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote);
- typedef std::map<SocketAddress, VirtualSocket*> AddressMap;
+ typedef std::map<webrtc::SocketAddress, VirtualSocket*> AddressMap;
typedef std::map<webrtc::SocketAddressPair, VirtualSocket*> ConnectionMap;
// May be null if the test doesn't use a fake clock, or it does but doesn't
diff --git a/rtc_base/virtual_socket_unittest.cc b/rtc_base/virtual_socket_unittest.cc
index a9beba3..fd8186d 100644
--- a/rtc_base/virtual_socket_unittest.cc
+++ b/rtc_base/virtual_socket_unittest.cc
@@ -153,8 +153,8 @@
kIPv4AnyAddress(webrtc::IPAddress(INADDR_ANY), 0),
kIPv6AnyAddress(webrtc::IPAddress(in6addr_any), 0) {}
- void CheckPortIncrementalization(const SocketAddress& post,
- const SocketAddress& pre) {
+ void CheckPortIncrementalization(const webrtc::SocketAddress& post,
+ const webrtc::SocketAddress& pre) {
EXPECT_EQ(post.port(), pre.port() + 1);
webrtc::IPAddress post_ip = post.ipaddr();
webrtc::IPAddress pre_ip = pre.ipaddr();
@@ -180,37 +180,38 @@
// Create client1 bound to the any address.
Socket* socket = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
- socket->Bind(EmptySocketAddressWithFamily(default_address.family()));
- SocketAddress client1_any_addr = socket->GetLocalAddress();
+ socket->Bind(
+ webrtc::EmptySocketAddressWithFamily(default_address.family()));
+ webrtc::SocketAddress client1_any_addr = socket->GetLocalAddress();
EXPECT_TRUE(client1_any_addr.IsAnyIP());
auto client1 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
// Create client2 bound to the address route.
Socket* socket2 = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
- socket2->Bind(SocketAddress(default_address, 0));
- SocketAddress client2_addr = socket2->GetLocalAddress();
+ socket2->Bind(webrtc::SocketAddress(default_address, 0));
+ webrtc::SocketAddress client2_addr = socket2->GetLocalAddress();
EXPECT_FALSE(client2_addr.IsAnyIP());
auto client2 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
// Client1 sends to client2, client2 should see the default address as
// client1's address.
- SocketAddress client1_addr;
+ webrtc::SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr,
- SocketAddress(default_address, client1_any_addr.port()));
+ webrtc::SocketAddress(default_address, client1_any_addr.port()));
// Client2 can send back to client1's default address.
EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
}
- void BasicTest(const SocketAddress& initial_addr) {
+ void BasicTest(const webrtc::SocketAddress& initial_addr) {
Socket* socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
socket->Bind(initial_addr);
- SocketAddress server_addr = socket->GetLocalAddress();
+ webrtc::SocketAddress server_addr = socket->GetLocalAddress();
// Make sure VSS didn't switch families on us.
EXPECT_EQ(server_addr.family(), initial_addr.family());
@@ -220,27 +221,28 @@
auto client2 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
- SocketAddress client2_addr;
+ webrtc::SocketAddress client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
- SocketAddress client1_addr;
+ webrtc::SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr, server_addr);
- SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
for (int i = 0; i < 10; i++) {
client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
- SocketAddress next_client2_addr;
+ webrtc::SocketAddress next_client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
CheckPortIncrementalization(next_client2_addr, client2_addr);
// EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
- SocketAddress server_addr2;
+ webrtc::SocketAddress server_addr2;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
EXPECT_EQ(server_addr2, server_addr);
@@ -250,11 +252,11 @@
}
// initial_addr should be made from either INADDR_ANY or in6addr_any.
- void ConnectTest(const SocketAddress& initial_addr) {
+ void ConnectTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- SocketAddress accept_addr;
- const SocketAddress kEmptyAddr =
- EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress accept_addr;
+ const webrtc::SocketAddress kEmptyAddr =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client
std::unique_ptr<Socket> client =
@@ -318,12 +320,12 @@
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
- void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
+ void ConnectToNonListenerTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- SocketAddress accept_addr;
- const SocketAddress nil_addr;
- const SocketAddress empty_addr =
- EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress accept_addr;
+ const webrtc::SocketAddress nil_addr;
+ const webrtc::SocketAddress empty_addr =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client
std::unique_ptr<Socket> client =
@@ -353,11 +355,11 @@
EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
}
- void CloseDuringConnectTest(const SocketAddress& initial_addr) {
+ void CloseDuringConnectTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- SocketAddress accept_addr;
- const SocketAddress empty_addr =
- EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress accept_addr;
+ const webrtc::SocketAddress empty_addr =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client and server
std::unique_ptr<Socket> client(
@@ -440,9 +442,9 @@
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
}
- void CloseTest(const SocketAddress& initial_addr) {
+ void CloseTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- const SocketAddress kEmptyAddr;
+ const webrtc::SocketAddress kEmptyAddr;
// Create clients
std::unique_ptr<Socket> a =
@@ -490,9 +492,9 @@
EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
}
- void TcpSendTest(const SocketAddress& initial_addr) {
+ void TcpSendTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- const SocketAddress kEmptyAddr;
+ const webrtc::SocketAddress kEmptyAddr;
// Connect two sockets
std::unique_ptr<Socket> a =
@@ -613,8 +615,8 @@
EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
}
- void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
- const SocketAddress kEmptyAddr;
+ void TcpSendsPacketsInOrderTest(const webrtc::SocketAddress& initial_addr) {
+ const webrtc::SocketAddress kEmptyAddr;
// Connect two sockets
std::unique_ptr<Socket> a =
@@ -670,7 +672,7 @@
// It is important that initial_addr's port has to be 0 such that the
// incremental port behavior could ensure the 2 Binds result in different
// address.
- void BandwidthTest(const SocketAddress& initial_addr) {
+ void BandwidthTest(const webrtc::SocketAddress& initial_addr) {
Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
@@ -702,7 +704,7 @@
// It is important that initial_addr's port has to be 0 such that the
// incremental port behavior could ensure the 2 Binds result in different
// address.
- void DelayTest(const SocketAddress& initial_addr) {
+ void DelayTest(const webrtc::SocketAddress& initial_addr) {
time_t seed = ::time(nullptr);
RTC_LOG(LS_VERBOSE) << "seed = " << seed;
srand(static_cast<unsigned int>(seed));
@@ -757,12 +759,12 @@
// Test cross-family communication between a client bound to client_addr and a
// server bound to server_addr. shouldSucceed indicates if communication is
// expected to work or not.
- void CrossFamilyConnectionTest(const SocketAddress& client_addr,
- const SocketAddress& server_addr,
+ void CrossFamilyConnectionTest(const webrtc::SocketAddress& client_addr,
+ const webrtc::SocketAddress& server_addr,
bool shouldSucceed) {
StreamSink sink;
- SocketAddress accept_address;
- const SocketAddress kEmptyAddr;
+ webrtc::SocketAddress accept_address;
+ const webrtc::SocketAddress kEmptyAddr;
// Client gets a IPv4 address
std::unique_ptr<Socket> client =
@@ -808,12 +810,12 @@
// Test cross-family datagram sending between a client bound to client_addr
// and a server bound to server_addr. shouldSucceed indicates if sending is
// expected to succeed or not.
- void CrossFamilyDatagramTest(const SocketAddress& client_addr,
- const SocketAddress& server_addr,
+ void CrossFamilyDatagramTest(const webrtc::SocketAddress& client_addr,
+ const webrtc::SocketAddress& server_addr,
bool shouldSucceed) {
Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
socket->Bind(server_addr);
- SocketAddress bound_server_addr = socket->GetLocalAddress();
+ webrtc::SocketAddress bound_server_addr = socket->GetLocalAddress();
auto client1 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
@@ -821,12 +823,12 @@
socket2->Bind(client_addr);
auto client2 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
- SocketAddress client2_addr;
+ webrtc::SocketAddress client2_addr;
if (shouldSucceed) {
EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
- SocketAddress client1_addr;
+ webrtc::SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr, bound_server_addr);
@@ -840,17 +842,17 @@
rtc::ScopedFakeClock fake_clock_;
VirtualSocketServer ss_;
AutoSocketServerThread thread_;
- const SocketAddress kIPv4AnyAddress;
- const SocketAddress kIPv6AnyAddress;
+ const webrtc::SocketAddress kIPv4AnyAddress;
+ const webrtc::SocketAddress kIPv6AnyAddress;
};
TEST_F(VirtualSocketServerTest, basic_v4) {
- SocketAddress ipv4_test_addr(webrtc::IPAddress(INADDR_ANY), 5000);
+ webrtc::SocketAddress ipv4_test_addr(webrtc::IPAddress(INADDR_ANY), 5000);
BasicTest(ipv4_test_addr);
}
TEST_F(VirtualSocketServerTest, basic_v6) {
- SocketAddress ipv6_test_addr(webrtc::IPAddress(in6addr_any), 5000);
+ webrtc::SocketAddress ipv6_test_addr(webrtc::IPAddress(in6addr_any), 5000);
BasicTest(ipv6_test_addr);
}
@@ -932,90 +934,94 @@
// Works, receiving socket sees 127.0.0.2.
TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::ffff:127.0.0.2", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(SocketAddress("::2", 0),
- SocketAddress("0.0.0.0", 5000), false);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), false);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
- CrossFamilyConnectionTest(SocketAddress("::2", 0),
- SocketAddress("::ffff:127.0.0.1", 5000), false);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.1", 5000),
+ false);
}
// Works. receiving socket sees ::ffff:127.0.0.2.
TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
- CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
- CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::1", 5000), false);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::1", 5000), false);
}
// Works. Receiving socket sees ::ffff:127.0.0.1.
TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
- CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
- SocketAddress("::ffff:127.0.0.2", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.1", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.2", 5000),
+ true);
}
// Works, receiving socket sees a result from GetNextIP.
TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(SocketAddress("::", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
// Works, receiving socket sees whatever GetNextIP gave the client.
TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
- CrossFamilyConnectionTest(SocketAddress("0.0.0.0", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("0.0.0.0", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
- CrossFamilyDatagramTest(SocketAddress("0.0.0.0", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("0.0.0.0", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::ffff:127.0.0.1", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(SocketAddress("::2", 0),
- SocketAddress("0.0.0.0", 5000), false);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), false);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
- CrossFamilyDatagramTest(SocketAddress("::2", 0),
- SocketAddress("::ffff:127.0.0.1", 5000), false);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.1", 5000),
+ false);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
- CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
- CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::1", 5000), false);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::1", 5000), false);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
- CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
- SocketAddress("::ffff:127.0.0.2", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.1", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.2", 5000),
+ true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(SocketAddress("::", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
