From 5d8456b0d04809538d3d2f2f34becf39f8a4e202 Mon Sep 17 00:00:00 2001 From: Francis Tsui Date: Tue, 4 Nov 2025 17:14:15 -0800 Subject: [PATCH] Remove duplicate classes. PiperOrigin-RevId: 828196042 --- .../platform/implementation/windows/BUILD | 31 ++++ .../windows/nearby_client_socket.cc | 14 +- .../windows/nearby_client_socket.h | 45 ++++++ .../windows/nearby_client_socket_test.cc | 148 ++++++++++++++++++ .../windows/nearby_server_socket.cc | 57 ++++--- .../windows/nearby_server_socket.h | 11 +- .../windows/nearby_server_socket_test.cc | 71 +++++++++ .../windows/wifi_hotspot_server_socket.cc | 34 ---- .../windows/wifi_hotspot_server_socket.h | 19 ++- .../windows/wifi_hotspot_socket.cc | 2 - .../windows/wifi_hotspot_socket.h | 41 +---- .../implementation/windows/wifi_lan.h | 62 ++------ .../windows/wifi_lan_server_socket.cc | 36 ----- .../implementation/windows/wifi_lan_socket.cc | 55 ------- 14 files changed, 376 insertions(+), 250 deletions(-) create mode 100644 internal/platform/implementation/windows/nearby_client_socket_test.cc create mode 100644 internal/platform/implementation/windows/nearby_server_socket_test.cc diff --git a/internal/platform/implementation/windows/BUILD b/internal/platform/implementation/windows/BUILD index acddcfe4..9942aa8a 100644 --- a/internal/platform/implementation/windows/BUILD +++ b/internal/platform/implementation/windows/BUILD @@ -532,3 +532,34 @@ cc_test( "@com_google_googletest//:gtest_main", ], ) + +cc_test( + name = "nearby_client_socket_test", + size = "small", + timeout = "short", + srcs = [ + "nearby_client_socket_test.cc", + ], + deps = [ + ":socket_address", + ":windows", + "//internal/platform:base", + "@com_github_protobuf_matchers//protobuf-matchers", + "@com_google_googletest//:gtest_main", + ], +) + +cc_test( + name = "nearby_server_socket_test", + size = "small", + timeout = "short", + srcs = [ + "nearby_server_socket_test.cc", + ], + deps = [ + ":socket_address", + ":windows", + "@com_github_protobuf_matchers//protobuf-matchers", + "@com_google_googletest//:gtest_main", + ], +) diff --git a/internal/platform/implementation/windows/nearby_client_socket.cc b/internal/platform/implementation/windows/nearby_client_socket.cc index 0367bd8d..7870d62f 100644 --- a/internal/platform/implementation/windows/nearby_client_socket.cc +++ b/internal/platform/implementation/windows/nearby_client_socket.cc @@ -31,19 +31,21 @@ namespace nearby::windows { -NearbyClientSocket::NearbyClientSocket() { +NearbyClientSocket::NearbyClientSocket() + : NearbyClientSocket(INVALID_SOCKET) { +} + +NearbyClientSocket::NearbyClientSocket(SOCKET socket) : socket_(socket) { WSADATA wsa_data; int result = WSAStartup(MAKEWORD(2, 2), &wsa_data); if (result != 0) { LOG(WARNING) << "WSAStartup failed with error " << result; } - is_socket_initiated_ = (result == 0); } -NearbyClientSocket::NearbyClientSocket(SOCKET socket) : socket_(socket) {} - NearbyClientSocket::~NearbyClientSocket() { + Close(); if (is_socket_initiated_) { WSACleanup(); } @@ -206,8 +208,8 @@ Exception NearbyClientSocket::Flush() { Exception NearbyClientSocket::Close() { if (socket_ == INVALID_SOCKET) { - LOG(WARNING) << "Trying to close an invalid socket."; - return {Exception::kIo}; + VLOG(1) << "Socket already closed."; + return {Exception::kSuccess}; } shutdown(socket_, SD_BOTH); diff --git a/internal/platform/implementation/windows/nearby_client_socket.h b/internal/platform/implementation/windows/nearby_client_socket.h index 924fff08..ba68c258 100644 --- a/internal/platform/implementation/windows/nearby_client_socket.h +++ b/internal/platform/implementation/windows/nearby_client_socket.h @@ -20,15 +20,24 @@ #include #include +#include "absl/base/nullability.h" #include "internal/platform/byte_array.h" #include "internal/platform/exception.h" #include "internal/platform/implementation/windows/socket_address.h" +#include "internal/platform/input_stream.h" +#include "internal/platform/output_stream.h" namespace nearby::windows { +// Socket wrapper class. +// This class is thread-compatible. class NearbyClientSocket { public: + // Creates a socket not bound to underlying platform implementation. + // `Connect` must be called to create a platform socket. NearbyClientSocket(); + // Creates a socket with the given platform socket. + // Calling `Connect` on this socket will fail. explicit NearbyClientSocket(SOCKET socket); ~NearbyClientSocket(); @@ -44,6 +53,42 @@ class NearbyClientSocket { SOCKET socket_ = INVALID_SOCKET; }; +// A simple wrapper to handle input stream of socket +class SocketInputStream : public InputStream { + public: + explicit SocketInputStream(NearbyClientSocket* absl_nonnull client_socket) + : client_socket_(client_socket) {} + ~SocketInputStream() override = default; + + ExceptionOr Read(std::int64_t size) override { + return client_socket_->Read(size); + } + ExceptionOr Skip(size_t offset) override { + return client_socket_->Skip(offset); + } + Exception Close() override { return client_socket_->Close(); } + + private: + NearbyClientSocket* absl_nonnull const client_socket_; +}; + +// A simple wrapper to handle output stream of socket +class SocketOutputStream : public OutputStream { + public: + explicit SocketOutputStream(NearbyClientSocket* absl_nonnull client_socket) + : client_socket_(client_socket) {} + ~SocketOutputStream() override = default; + + Exception Write(const ByteArray& data) override { + return client_socket_->Write(data); + } + Exception Flush() override { return client_socket_->Flush(); } + Exception Close() override { return client_socket_->Close(); } + + private: + NearbyClientSocket* absl_nonnull const client_socket_; +}; + } // namespace nearby::windows #endif // THIRD_PARTY_NEARBY_INTERNAL_PLATFORM_IMPLEMENTATION_WINDOWS_NEARBY_CLIENT_SOCKET_H_ diff --git a/internal/platform/implementation/windows/nearby_client_socket_test.cc b/internal/platform/implementation/windows/nearby_client_socket_test.cc new file mode 100644 index 00000000..73fe02e2 --- /dev/null +++ b/internal/platform/implementation/windows/nearby_client_socket_test.cc @@ -0,0 +1,148 @@ +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "internal/platform/implementation/windows/nearby_client_socket.h" + +#include "gtest/gtest.h" +#include "internal/platform/byte_array.h" +#include "internal/platform/implementation/windows/socket_address.h" + +namespace nearby::windows { +namespace { + +SOCKET CreateSocket(const SocketAddress& address) { + SOCKET socket_handle = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + DWORD v6_only = 0; + EXPECT_NE( + setsockopt(socket_handle, IPPROTO_IPV6, IPV6_V6ONLY, + reinterpret_cast(&v6_only), sizeof(v6_only)), + SOCKET_ERROR); + EXPECT_NE( + bind(socket_handle, address.address(), sizeof(sockaddr_storage)), + SOCKET_ERROR); + return socket_handle; +} + +SocketAddress GetLocalAddress(SOCKET socket_handle) { + SocketAddress local_address(/*dual_stack=*/true); + int address_length = sizeof(sockaddr_storage); + EXPECT_NE( + getsockname(socket_handle, local_address.address(), &address_length), + SOCKET_ERROR); + return local_address; +} + +TEST(NearbyClientSocketTest, ConnectWithBoundSocketFails) { + SOCKET socket_handle = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + NearbyClientSocket client_socket(socket_handle); + SocketAddress server_address(/*dual_stack=*/true); + SocketAddress::FromString(server_address, "::1", 8080); + + EXPECT_FALSE(client_socket.Connect(server_address)); + + closesocket(socket_handle); +} + +TEST(NearbyClientSocketTest, Connect) { + SocketAddress local_address(/*dual_stack=*/true); + SocketAddress::FromString(local_address, "", 0); + SOCKET socket_handle = CreateSocket(local_address); + SocketAddress bound_address = GetLocalAddress(socket_handle); + EXPECT_NE(listen(socket_handle, SOMAXCONN), SOCKET_ERROR); + NearbyClientSocket client_socket; + SocketAddress server_address(/*dual_stack=*/true); + SocketAddress::FromString(server_address, "::1", bound_address.port()); + + EXPECT_TRUE(client_socket.Connect(server_address)); + + closesocket(socket_handle); +} + +TEST(NearbyClientSocketTest, CloseNotOpened) { + NearbyClientSocket client_socket; + EXPECT_TRUE(client_socket.Close().Ok()); +} + +TEST(NearbyClientSocketTest, Read) { + SocketAddress local_address(/*dual_stack=*/true); + SocketAddress::FromString(local_address, "", 0); + SOCKET socket_handle = CreateSocket(local_address); + SocketAddress bound_address = GetLocalAddress(socket_handle); + EXPECT_NE(listen(socket_handle, SOMAXCONN), SOCKET_ERROR); + NearbyClientSocket client_socket; + SocketAddress server_address(/*dual_stack=*/true); + SocketAddress::FromString(server_address, "::1", bound_address.port()); + EXPECT_TRUE(client_socket.Connect(server_address)); + SocketAddress peer_address; + int peer_address_length = sizeof(sockaddr_storage); + SOCKET accept_socket = accept(socket_handle, peer_address.address(), + /*addrlen=*/&peer_address_length); + EXPECT_NE(accept_socket, INVALID_SOCKET); + EXPECT_NE(send(accept_socket, "hello", 5, 0), SOCKET_ERROR); + + EXPECT_EQ(client_socket.Read(5).result(), ByteArray("hello")); + + closesocket(socket_handle); +} + +TEST(NearbyClientSocketTest, Skip) { + SocketAddress local_address(/*dual_stack=*/true); + SocketAddress::FromString(local_address, "", 0); + SOCKET socket_handle = CreateSocket(local_address); + SocketAddress bound_address = GetLocalAddress(socket_handle); + EXPECT_NE(listen(socket_handle, SOMAXCONN), SOCKET_ERROR); + NearbyClientSocket client_socket; + SocketAddress server_address(/*dual_stack=*/true); + SocketAddress::FromString(server_address, "::1", bound_address.port()); + EXPECT_TRUE(client_socket.Connect(server_address)); + SocketAddress peer_address; + int peer_address_length = sizeof(sockaddr_storage); + SOCKET accept_socket = accept(socket_handle, peer_address.address(), + /*addrlen=*/&peer_address_length); + EXPECT_NE(accept_socket, INVALID_SOCKET); + EXPECT_NE(send(accept_socket, "hello there", 11, 0), SOCKET_ERROR); + + EXPECT_EQ(client_socket.Skip(6).result(), 6); + + EXPECT_EQ(client_socket.Read(5).result(), ByteArray("there")); + closesocket(socket_handle); +} + +TEST(NearbyClientSocketTest, Write) { + SocketAddress local_address(/*dual_stack=*/true); + SocketAddress::FromString(local_address, "", 0); + SOCKET socket_handle = CreateSocket(local_address); + SocketAddress bound_address = GetLocalAddress(socket_handle); + EXPECT_NE(listen(socket_handle, SOMAXCONN), SOCKET_ERROR); + NearbyClientSocket client_socket; + SocketAddress server_address(/*dual_stack=*/true); + SocketAddress::FromString(server_address, "::1", bound_address.port()); + EXPECT_TRUE(client_socket.Connect(server_address)); + SocketAddress peer_address; + int peer_address_length = sizeof(sockaddr_storage); + SOCKET accept_socket = accept(socket_handle, peer_address.address(), + /*addrlen=*/&peer_address_length); + EXPECT_NE(accept_socket, INVALID_SOCKET); + + EXPECT_TRUE(client_socket.Write(ByteArray("hello")).Ok()); + std::string buffer; + buffer.resize(5); + EXPECT_EQ(recv(accept_socket, buffer.data(), 5, 0), 5); + EXPECT_EQ(buffer, "hello"); + + closesocket(socket_handle); +} + +} // namespace +} // namespace nearby::windows diff --git a/internal/platform/implementation/windows/nearby_server_socket.cc b/internal/platform/implementation/windows/nearby_server_socket.cc index 7648547b..4daead8c 100644 --- a/internal/platform/implementation/windows/nearby_server_socket.cc +++ b/internal/platform/implementation/windows/nearby_server_socket.cc @@ -18,8 +18,10 @@ #include #include -#include +#include +#include "absl/functional/any_invocable.h" +#include "absl/synchronization/mutex.h" #include "internal/platform/implementation/windows/nearby_client_socket.h" #include "internal/platform/implementation/windows/socket_address.h" #include "internal/platform/logging.h" @@ -38,6 +40,7 @@ NearbyServerSocket::NearbyServerSocket() { } NearbyServerSocket::~NearbyServerSocket() { + Close(); if (is_socket_initiated_) { WSACleanup(); } @@ -51,6 +54,7 @@ bool NearbyServerSocket::Listen(const SocketAddress& address) { return false; } + absl::MutexLock lock( mutex_ ); socket_ = socket(address.dual_stack() ? AF_INET6 : AF_INET, SOCK_STREAM, IPPROTO_TCP); if (socket_ == INVALID_SOCKET) { @@ -92,6 +96,7 @@ bool NearbyServerSocket::Listen(const SocketAddress& address) { SOCKET_ERROR) { LOG(ERROR) << "Failed to bind socket with error " << WSAGetLastError(); closesocket(socket_); + socket_ = INVALID_SOCKET; return false; } @@ -101,6 +106,7 @@ bool NearbyServerSocket::Listen(const SocketAddress& address) { SOCKET_ERROR) { LOG(ERROR) << "Failed to get socket name with error " << WSAGetLastError(); closesocket(socket_); + socket_ = INVALID_SOCKET; return false; } @@ -111,6 +117,7 @@ bool NearbyServerSocket::Listen(const SocketAddress& address) { if (::listen(socket_, /*backlog=*/SOMAXCONN) == SOCKET_ERROR) { LOG(ERROR) << "Failed to listen socket with error " << WSAGetLastError(); closesocket(socket_); + socket_ = INVALID_SOCKET; return false; } @@ -119,15 +126,21 @@ bool NearbyServerSocket::Listen(const SocketAddress& address) { std::unique_ptr NearbyServerSocket::Accept() { LOG(INFO) << "Accept is called on NearbyServerSocket."; - if (!is_socket_initiated_) { - LOG(WARNING) << "Windows socket is not initiated"; - return nullptr; + SOCKET socket = INVALID_SOCKET; + { + absl::MutexLock lock( mutex_ ); + if (!is_socket_initiated_ || socket_ == INVALID_SOCKET) { + LOG(WARNING) << "Windows socket is not initiated"; + return nullptr; + } + socket = socket_; } SocketAddress peer_address; int peer_address_length = sizeof(sockaddr_storage); - - SOCKET client_socket = accept(socket_, peer_address.address(), + // Release lock before calling accept. Otherwise the accept call blocks and + // prevents other calls from using the socket. + SOCKET client_socket = accept(socket, peer_address.address(), /*addrlen=*/&peer_address_length); if (client_socket == INVALID_SOCKET) { LOG(ERROR) << "Failed to accept socket with error: " << WSAGetLastError(); @@ -140,23 +153,27 @@ std::unique_ptr NearbyServerSocket::Accept() { } bool NearbyServerSocket::Close() { - bool result = true; - if (socket_ != INVALID_SOCKET) { - if (shutdown(/*s=*/socket_, /*how=*/SD_BOTH) == SOCKET_ERROR) { - LOG(WARNING) << "Shutdown failed with error:" << WSAGetLastError(); - result = false; + absl::AnyInvocable close_callback; + { + absl::MutexLock lock( mutex_ ); + if (socket_ != INVALID_SOCKET) { + if (closesocket(/*s=*/socket_) == SOCKET_ERROR) { + LOG(WARNING) << "Close socket failed with error:" << WSAGetLastError(); + } + socket_ = INVALID_SOCKET; + close_callback = std::move(close_notifier_); } - - if (closesocket(/*s=*/socket_) == SOCKET_ERROR) { - LOG(WARNING) << "Close socket failed with error:" << WSAGetLastError(); - result = false; - } - - socket_ = INVALID_SOCKET; } - + if (close_callback) { + close_callback(); + } LOG(INFO) << "Closed NearbyServerSocket."; - return result; + return true; +} + +void NearbyServerSocket::SetCloseNotifier(absl::AnyInvocable notifier) { + absl::MutexLock lock( mutex_ ); + close_notifier_ = std::move(notifier); } } // namespace nearby::windows diff --git a/internal/platform/implementation/windows/nearby_server_socket.h b/internal/platform/implementation/windows/nearby_server_socket.h index 5e0e217a..e0f66528 100644 --- a/internal/platform/implementation/windows/nearby_server_socket.h +++ b/internal/platform/implementation/windows/nearby_server_socket.h @@ -18,8 +18,10 @@ #include #include -#include +#include "absl/base/thread_annotations.h" +#include "absl/functional/any_invocable.h" +#include "absl/synchronization/mutex.h" #include "internal/platform/implementation/windows/nearby_client_socket.h" #include "internal/platform/implementation/windows/socket_address.h" @@ -36,10 +38,15 @@ class NearbyServerSocket { int GetPort() const { return port_; } + // Sets a callback to be called when the socket is closed. + void SetCloseNotifier(absl::AnyInvocable notifier); + private: + mutable absl::Mutex mutex_; bool is_socket_initiated_ = false; - SOCKET socket_ = INVALID_SOCKET; + SOCKET socket_ ABSL_GUARDED_BY(mutex_) = INVALID_SOCKET; int port_ = 0; + absl::AnyInvocable close_notifier_ ABSL_GUARDED_BY(mutex_); }; } // namespace nearby::windows diff --git a/internal/platform/implementation/windows/nearby_server_socket_test.cc b/internal/platform/implementation/windows/nearby_server_socket_test.cc new file mode 100644 index 00000000..8296b768 --- /dev/null +++ b/internal/platform/implementation/windows/nearby_server_socket_test.cc @@ -0,0 +1,71 @@ +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "internal/platform/implementation/windows/nearby_server_socket.h" + +#include "gtest/gtest.h" +#include "internal/platform/implementation/windows/socket_address.h" + +namespace nearby::windows { +namespace { + +SOCKET CreateSocket() { + SOCKET socket_handle = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + DWORD v6_only = 0; + EXPECT_NE( + setsockopt(socket_handle, IPPROTO_IPV6, IPV6_V6ONLY, + reinterpret_cast(&v6_only), sizeof(v6_only)), + SOCKET_ERROR); + return socket_handle; +} + +TEST(NearbyServerSocketTest, Listen) { + NearbyServerSocket server_socket; + SocketAddress address(/*dual_stack=*/true); + SocketAddress::FromString(address, "", 0); + EXPECT_TRUE(server_socket.Listen(address)); + EXPECT_NE(server_socket.GetPort(), 0); +} + +TEST(NearbyServerSocketTest, Accept) { + NearbyServerSocket server_socket; + SocketAddress address(/*dual_stack=*/true); + SocketAddress::FromString(address, "", 0); + EXPECT_TRUE(server_socket.Listen(address)); + SOCKET socket_handle = CreateSocket(); + EXPECT_NE(socket_handle, INVALID_SOCKET); + SocketAddress server_address(/*dual_stack=*/true); + SocketAddress::FromString(server_address, "::1", server_socket.GetPort()); + EXPECT_NE(connect(socket_handle, server_address.address(), + sizeof(sockaddr_storage)), + SOCKET_ERROR); + + auto client_socket = server_socket.Accept(); + ASSERT_NE(client_socket, nullptr); + EXPECT_TRUE(server_socket.Close()); +} + +TEST(NearbyServerSocketTest, CloseNotifier) { + NearbyServerSocket server_socket; + SocketAddress address(/*dual_stack=*/true); + SocketAddress::FromString(address, "", 0); + EXPECT_TRUE(server_socket.Listen(address)); + bool is_closed = false; + server_socket.SetCloseNotifier([&is_closed]() { is_closed = true; }); + EXPECT_TRUE(server_socket.Close()); + EXPECT_TRUE(is_closed); +} + +} // namespace +} // namespace nearby::windows diff --git a/internal/platform/implementation/windows/wifi_hotspot_server_socket.cc b/internal/platform/implementation/windows/wifi_hotspot_server_socket.cc index 00fd0839..20625ff8 100644 --- a/internal/platform/implementation/windows/wifi_hotspot_server_socket.cc +++ b/internal/platform/implementation/windows/wifi_hotspot_server_socket.cc @@ -28,7 +28,6 @@ // Nearby connections headers #include "absl/synchronization/mutex.h" #include "internal/flags/nearby_flags.h" -#include "internal/platform/exception.h" #include "internal/platform/flags/nearby_platform_feature_flags.h" #include "internal/platform/implementation/wifi_hotspot.h" #include "internal/platform/implementation/windows/generated/winrt/Windows.Foundation.Collections.h" @@ -48,12 +47,6 @@ using ::winrt::Windows::Networking::HostNameType; using ::winrt::Windows::Networking::Sockets::SocketQualityOfService; } // namespace -WifiHotspotServerSocket::~WifiHotspotServerSocket() { Close(); } - -int WifiHotspotServerSocket::GetPort() const { - return server_socket_.GetPort(); -} - std::unique_ptr WifiHotspotServerSocket::Accept() { auto client_socket = server_socket_.Accept(); if (client_socket == nullptr) { @@ -64,33 +57,6 @@ std::unique_ptr WifiHotspotServerSocket::Accept() { return std::make_unique(std::move(client_socket)); } -void WifiHotspotServerSocket::SetCloseNotifier( - absl::AnyInvocable notifier) { - absl::MutexLock lock(&mutex_); - close_notifier_ = std::move(notifier); -} - -Exception WifiHotspotServerSocket::Close() { - absl::AnyInvocable close_callback; - { - absl::MutexLock lock(&mutex_); - if (closed_) { - return {Exception::kSuccess}; - } - - server_socket_.Close(); - closed_ = true; - close_callback = std::move(close_notifier_); - } - - if (close_callback) { - close_callback(); - } - - LOG(INFO) << __func__ << ": Close completed succesfully."; - return {Exception::kSuccess}; -} - void WifiHotspotServerSocket::PopulateHotspotCredentials( HotspotCredentials& hotspot_credentials) { // Get current IP addresses of the device. diff --git a/internal/platform/implementation/windows/wifi_hotspot_server_socket.h b/internal/platform/implementation/windows/wifi_hotspot_server_socket.h index 270a982f..5fc90d44 100644 --- a/internal/platform/implementation/windows/wifi_hotspot_server_socket.h +++ b/internal/platform/implementation/windows/wifi_hotspot_server_socket.h @@ -46,10 +46,10 @@ class WifiHotspotServerSocket : public api::WifiHotspotServerSocket { public: WifiHotspotServerSocket() = default; WifiHotspotServerSocket(WifiHotspotServerSocket&&) = default; - ~WifiHotspotServerSocket() override; + ~WifiHotspotServerSocket() override = default; WifiHotspotServerSocket& operator=(WifiHotspotServerSocket&&) = default; - int GetPort() const override; + int GetPort() const override { return server_socket_.GetPort(); } // Blocks until either: // - at least one incoming connection request is available, or @@ -62,10 +62,15 @@ class WifiHotspotServerSocket : public api::WifiHotspotServerSocket { // Called by the server side of a connection before passing ownership of // WifiHotspotServerSocker to user, to track validity of a pointer to this // server socket. - void SetCloseNotifier(absl::AnyInvocable notifier); + void SetCloseNotifier(absl::AnyInvocable notifier) { + server_socket_.SetCloseNotifier(std::move(notifier)); + } // Returns Exception::kIo on error, Exception::kSuccess otherwise. - Exception Close() override; + Exception Close() override { + server_socket_.Close(); + return {Exception::kSuccess}; + } void PopulateHotspotCredentials( HotspotCredentials& hotspot_credentials) override; @@ -76,13 +81,7 @@ class WifiHotspotServerSocket : public api::WifiHotspotServerSocket { private: // Retrieves hotspot IP address from local machine std::string GetHotspotIpAddress() const; - - mutable absl::Mutex mutex_; NearbyServerSocket server_socket_; - - // Close notifier - absl::AnyInvocable close_notifier_ ABSL_GUARDED_BY(mutex_); - bool closed_ ABSL_GUARDED_BY(mutex_) = false; }; } // namespace nearby::windows diff --git a/internal/platform/implementation/windows/wifi_hotspot_socket.cc b/internal/platform/implementation/windows/wifi_hotspot_socket.cc index 3592e4ad..5a1b672e 100644 --- a/internal/platform/implementation/windows/wifi_hotspot_socket.cc +++ b/internal/platform/implementation/windows/wifi_hotspot_socket.cc @@ -33,7 +33,5 @@ WifiHotspotSocket::WifiHotspotSocket( input_stream_(client_socket_.get()), output_stream_(client_socket_.get()) {} -WifiHotspotSocket::~WifiHotspotSocket() { Close(); } - } // namespace windows } // namespace nearby diff --git a/internal/platform/implementation/windows/wifi_hotspot_socket.h b/internal/platform/implementation/windows/wifi_hotspot_socket.h index af272f86..135311a4 100644 --- a/internal/platform/implementation/windows/wifi_hotspot_socket.h +++ b/internal/platform/implementation/windows/wifi_hotspot_socket.h @@ -31,9 +31,6 @@ // Nearby connections headers #include "absl/base/nullability.h" #include "absl/base/thread_annotations.h" -#include "absl/functional/any_invocable.h" -#include "internal/platform/byte_array.h" -#include "internal/platform/cancellation_flag.h" #include "internal/platform/exception.h" #include "internal/platform/implementation/wifi_hotspot.h" #include "internal/platform/implementation/windows/nearby_client_socket.h" @@ -54,7 +51,7 @@ class WifiHotspotSocket : public api::WifiHotspotSocket { explicit WifiHotspotSocket( absl_nonnull std::unique_ptr socket); WifiHotspotSocket(WifiHotspotSocket&&) = default; - ~WifiHotspotSocket() override; + ~WifiHotspotSocket() override = default; WifiHotspotSocket& operator=(WifiHotspotSocket&&) = default; // Returns the InputStream of the WifiHotspotSocket. @@ -79,42 +76,6 @@ class WifiHotspotSocket : public api::WifiHotspotSocket { } private: - // A simple wrapper to handle input stream of socket - class SocketInputStream : public InputStream { - public: - explicit SocketInputStream(NearbyClientSocket* absl_nonnull client_socket) - : client_socket_(client_socket) {} - ~SocketInputStream() override = default; - - ExceptionOr Read(std::int64_t size) override { - return client_socket_->Read(size); - } - ExceptionOr Skip(size_t offset) override { - return client_socket_->Skip(offset); - } - Exception Close() override { return client_socket_->Close(); } - - private: - NearbyClientSocket* absl_nonnull const client_socket_; - }; - - // A simple wrapper to handle output stream of socket - class SocketOutputStream : public OutputStream { - public: - explicit SocketOutputStream(NearbyClientSocket* absl_nonnull client_socket) - : client_socket_(client_socket) {} - ~SocketOutputStream() override = default; - - Exception Write(const ByteArray& data) override { - return client_socket_->Write(data); - } - Exception Flush() override { return client_socket_->Flush(); } - Exception Close() override { return client_socket_->Close(); } - - private: - NearbyClientSocket* absl_nonnull const client_socket_; - }; - absl_nonnull std::unique_ptr client_socket_; SocketInputStream input_stream_; SocketOutputStream output_stream_; diff --git a/internal/platform/implementation/windows/wifi_lan.h b/internal/platform/implementation/windows/wifi_lan.h index fde86424..b2ab68c8 100644 --- a/internal/platform/implementation/windows/wifi_lan.h +++ b/internal/platform/implementation/windows/wifi_lan.h @@ -70,7 +70,7 @@ class WifiLanSocket : public api::WifiLanSocket { explicit WifiLanSocket( absl_nonnull std::unique_ptr socket); WifiLanSocket(WifiLanSocket&&) = default; - ~WifiLanSocket() override; + ~WifiLanSocket() override = default; WifiLanSocket& operator=(WifiLanSocket&&) = default; // Returns the InputStream of the WifiLanSocket. @@ -78,49 +78,23 @@ class WifiLanSocket : public api::WifiLanSocket { // // The returned object is not owned by the caller, and can be invalidated once // the WifiLanSocket object is destroyed. - InputStream& GetInputStream() override; + InputStream& GetInputStream() override { return input_stream_; }; // Returns the OutputStream of the WifiLanSocket. // On error, returned stream will report Exception::kIo on any operation. // // The returned object is not owned by the caller, and can be invalidated once // the WifiLanSocket object is destroyed. - OutputStream& GetOutputStream() override; + OutputStream& GetOutputStream() override { return output_stream_; }; // Returns Exception::kIo on error, Exception::kSuccess otherwise. - Exception Close() override; + Exception Close() override { return client_socket_->Close(); }; - bool Connect(const SocketAddress& server_address); + bool Connect(const SocketAddress& server_address) { + return client_socket_->Connect(server_address); + }; private: - // A simple wrapper to handle input stream of socket - class SocketInputStream : public InputStream { - public: - explicit SocketInputStream(NearbyClientSocket* absl_nonnull client_socket); - ~SocketInputStream() = default; - - ExceptionOr Read(std::int64_t size) override; - ExceptionOr Skip(size_t offset) override; - Exception Close() override; - - private: - NearbyClientSocket* absl_nonnull const client_socket_; - }; - - // A simple wrapper to handle output stream of socket - class SocketOutputStream : public OutputStream { - public: - explicit SocketOutputStream(NearbyClientSocket* absl_nonnull client_socket); - ~SocketOutputStream() = default; - - Exception Write(const ByteArray& data) override; - Exception Flush() override; - Exception Close() override; - - private: - NearbyClientSocket* absl_nonnull const client_socket_; - }; - // Internal properties absl_nonnull std::unique_ptr client_socket_; SocketInputStream input_stream_; @@ -133,14 +107,14 @@ class WifiLanServerSocket : public api::WifiLanServerSocket { public: WifiLanServerSocket() = default; WifiLanServerSocket(WifiLanServerSocket&&) = default; - ~WifiLanServerSocket() override; + ~WifiLanServerSocket() override = default; WifiLanServerSocket& operator=(WifiLanServerSocket&&) = default; // Returns ip address. std::string GetIPAddress() const override; // Returns port. - int GetPort() const override; + int GetPort() const override { return server_socket_.GetPort(); }; // Blocks until either: // - at least one incoming connection request is available, or @@ -153,21 +127,20 @@ class WifiLanServerSocket : public api::WifiLanServerSocket { // Called by the server side of a connection before passing ownership of // WifiLanServerSocker to user, to track validity of a pointer to this // server socket. - void SetCloseNotifier(absl::AnyInvocable notifier); + void SetCloseNotifier(absl::AnyInvocable notifier) { + server_socket_.SetCloseNotifier(std::move(notifier)); + }; // Returns Exception::kIo on error, Exception::kSuccess otherwise. - Exception Close() override; + Exception Close() override { + server_socket_.Close(); + return {Exception::kSuccess}; + } // Binds to local port bool Listen(int port, bool dual_stack); private: - mutable absl::Mutex mutex_; - // Close notifier - absl::AnyInvocable close_notifier_ ABSL_GUARDED_BY(mutex_); - - bool closed_ ABSL_GUARDED_BY(mutex_) = false; - NearbyServerSocket server_socket_; }; @@ -202,8 +175,7 @@ class WifiLanMedium : public api::WifiLanMedium { const std::string& ip_address, int port, CancellationFlag* cancellation_flag) override; - std::unique_ptr ListenForService( - int port) override; + std::unique_ptr ListenForService(int port) override; absl::optional> GetDynamicPortRange() override { diff --git a/internal/platform/implementation/windows/wifi_lan_server_socket.cc b/internal/platform/implementation/windows/wifi_lan_server_socket.cc index 5b3cb7a0..87409184 100644 --- a/internal/platform/implementation/windows/wifi_lan_server_socket.cc +++ b/internal/platform/implementation/windows/wifi_lan_server_socket.cc @@ -31,8 +31,6 @@ namespace nearby::windows { -WifiLanServerSocket::~WifiLanServerSocket() { Close(); } - // Returns the first IP address. std::string WifiLanServerSocket::GetIPAddress() const { // Just pick an IP address from the list of available addresses. @@ -44,9 +42,6 @@ std::string WifiLanServerSocket::GetIPAddress() const { return ipaddr_dotdecimal_to_4bytes_string(ip_addresses.front()); } -// Returns socket port. -int WifiLanServerSocket::GetPort() const { return server_socket_.GetPort(); } - // Blocks until either: // - at least one incoming connection request is available, or // - ServerSocket is closed. @@ -64,37 +59,6 @@ std::unique_ptr WifiLanServerSocket::Accept() { return std::make_unique(std::move(client_socket)); } -void WifiLanServerSocket::SetCloseNotifier( - absl::AnyInvocable notifier) { - absl::MutexLock lock(mutex_); - close_notifier_ = std::move(notifier); -} - -// Returns Exception::kIo on error, Exception::kSuccess otherwise. -Exception WifiLanServerSocket::Close() { - absl::AnyInvocable close_callback; - { - absl::MutexLock lock(mutex_); - VLOG(1) << __func__ << ": Close is called."; - if (closed_) { - return {Exception::kSuccess}; - } - - LOG(INFO) << __func__ << ": closing blocking socket."; - - server_socket_.Close(); - closed_ = true; - close_callback = std::move(close_notifier_); - } - - if (close_callback) { - close_callback(); - } - - LOG(INFO) << __func__ << ": Close completed succesfully."; - return {Exception::kSuccess}; -} - bool WifiLanServerSocket::Listen(int port, bool dual_stack) { // Listen on all interfaces. SocketAddress address(dual_stack); diff --git a/internal/platform/implementation/windows/wifi_lan_socket.cc b/internal/platform/implementation/windows/wifi_lan_socket.cc index 16d702fe..9ea72eb3 100644 --- a/internal/platform/implementation/windows/wifi_lan_socket.cc +++ b/internal/platform/implementation/windows/wifi_lan_socket.cc @@ -12,18 +12,12 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include #include #include #include "absl/base/nullability.h" -#include "internal/platform/byte_array.h" -#include "internal/platform/exception.h" #include "internal/platform/implementation/windows/nearby_client_socket.h" -#include "internal/platform/implementation/windows/socket_address.h" #include "internal/platform/implementation/windows/wifi_lan.h" -#include "internal/platform/input_stream.h" -#include "internal/platform/output_stream.h" namespace nearby::windows { @@ -36,53 +30,4 @@ WifiLanSocket::WifiLanSocket( input_stream_(client_socket_.get()), output_stream_(client_socket_.get()) {} -WifiLanSocket::~WifiLanSocket() { Close(); } - -InputStream& WifiLanSocket::GetInputStream() { return input_stream_; } - -OutputStream& WifiLanSocket::GetOutputStream() { return output_stream_; } - -Exception WifiLanSocket::Close() { - return client_socket_->Close(); -} - -bool WifiLanSocket::Connect(const SocketAddress& server_address) { - return client_socket_->Connect(server_address); -} - -// SocketInputStream -WifiLanSocket::SocketInputStream::SocketInputStream( - NearbyClientSocket* absl_nonnull client_socket) - : client_socket_(client_socket) {} - -ExceptionOr WifiLanSocket::SocketInputStream::Read( - std::int64_t size) { - return client_socket_->Read(size); -} - -ExceptionOr WifiLanSocket::SocketInputStream::Skip(size_t offset) { - return client_socket_->Skip(offset); -} - -Exception WifiLanSocket::SocketInputStream::Close() { - return client_socket_->Close(); -} - -// SocketOutputStream -WifiLanSocket::SocketOutputStream::SocketOutputStream( - NearbyClientSocket* absl_nonnull client_socket) - : client_socket_(client_socket) {} - -Exception WifiLanSocket::SocketOutputStream::Write(const ByteArray& data) { - return client_socket_->Write(data); -} - -Exception WifiLanSocket::SocketOutputStream::Flush() { - return client_socket_->Flush(); -} - -Exception WifiLanSocket::SocketOutputStream::Close() { - return client_socket_->Close(); -} - } // namespace nearby::windows