core: network: Address review comments

src/core/internal_network/socket_proxy.cpp

@@ -14,10 +14,6 @@ namespace Network {
 
 ProxySocket::ProxySocket(RoomNetwork& room_network_) noexcept : room_network{room_network_} {}
 
-ProxySocket::ProxySocket(ProxySocket&& rhs) noexcept : room_network{rhs.room_network} {
-    fd = std::exchange(rhs.fd, INVALID_SOCKET);
-}
-
 ProxySocket::~ProxySocket() {
     if (fd == INVALID_SOCKET) {
         return;
@@ -36,7 +32,6 @@ void ProxySocket::HandleProxyPacket(const ProxyPacket& packet) {
 
 template <typename T>
 Errno ProxySocket::SetSockOpt(SOCKET fd_, int option, T value) {
-    socket_options[option] = reinterpret_cast<const char*>(&value);
     return Errno::SUCCESS;
 }
 
@@ -100,27 +95,36 @@ std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::vector<u8>& message,
     ASSERT(flags == 0);
     ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max()));
 
-    {
-        std::lock_guard guard(packets_mutex);
-        if (received_packets.size() > 0) {
-            return ReceivePacket(flags, message, addr, message.size());
+    const auto timestamp = std::chrono::steady_clock::now();
+
+    while (true) {
+        {
+            std::lock_guard guard(packets_mutex);
+            if (received_packets.size() > 0) {
+                return ReceivePacket(flags, message, addr, message.size());
+            }
         }
-    }
 
-    if (blocking) {
-        if (receive_timeout > 0) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(receive_timeout));
+        if (!blocking) {
+            return {-1, Errno::AGAIN};
         }
-    } else {
-        return {-1, Errno::AGAIN};
-    }
 
-    std::lock_guard guard(packets_mutex);
-    if (received_packets.size() > 0) {
-        return ReceivePacket(flags, message, addr, message.size());
-    }
+        // TODO: break if socket connection is lost
+
+        std::this_thread::yield();
+
+        if (receive_timeout == 0) {
+            continue;
+        }
 
-    return {-1, Errno::TIMEDOUT};
+        const auto time_diff = std::chrono::steady_clock::now() - timestamp;
+        const auto time_diff_ms =
+            std::chrono::duration_cast<std::chrono::milliseconds>(time_diff).count();
+
+        if (time_diff_ms > receive_timeout) {
+            return {-1, Errno::TIMEDOUT};
+        }
+    }
 }
 
 std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::vector<u8>& message,

src/core/internal_network/socket_proxy.h

@@ -7,6 +7,7 @@
 #include <vector>
 #include <queue>
 
+#include "common/common_funcs.h"
 #include "core/internal_network/sockets.h"
 #include "network/network.h"
 
@@ -14,17 +15,12 @@ namespace Network {
 
 class ProxySocket : public SocketBase {
 public:
+    YUZU_NON_COPYABLE(ProxySocket);
+    YUZU_NON_MOVEABLE(ProxySocket);
+
     explicit ProxySocket(RoomNetwork& room_network_) noexcept;
     ~ProxySocket() override;
 
-    ProxySocket(const ProxySocket&) = delete;
-    ProxySocket& operator=(const ProxySocket&) = delete;
-
-    ProxySocket(ProxySocket&& rhs) noexcept;
-
-    // Avoid closing sockets implicitly
-    ProxySocket& operator=(ProxySocket&&) noexcept = delete;
-
     void HandleProxyPacket(const ProxyPacket& packet) override;
 
     Errno Initialize(Domain domain, Type type, Protocol socket_protocol) override;
@@ -87,7 +83,6 @@ private:
     bool closed = false;
     u32 send_timeout = 0;
     u32 receive_timeout = 0;
-    std::map<int, const char*> socket_options;
     bool is_bound = false;
     SockAddrIn local_endpoint{};
     bool blocking = true;

src/dedicated_room/CMakeLists.txt

@@ -4,8 +4,8 @@
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/CMakeModules)
 
 add_executable(yuzu-room
-    yuzu-room.cpp
-    yuzu-room.rc
+    yuzu_room.cpp
+    yuzu_room.rc
 )
 
 create_target_directory_groups(yuzu-room)