librats 1.0.2 → 2.2.0

package/native-src/src/{socket.cpp → librats/core/socket.cpp}

@@ -1,14 +1,34 @@
-#include "socket.h"
-#include "network_utils.h"
-#include "logger.h"
+#include "librats/core/socket.h"
+#include "librats/util/network_utils.h"
+#include "librats/util/logger.h"
 #include <iostream>
 #include <cstring>
 #include <mutex>
 #include <thread>
 #include <chrono>
 #ifndef _WIN32
-    #include <fcntl.h>    // for O_NONBLOCK
-    #include <errno.h>    // for errno
+    #include <fcntl.h>          // for O_NONBLOCK
+    #include <errno.h>          // for errno
+    #include <sys/uio.h>        // for iovec (send_vectored)
+    #include <limits.h>         // for IOV_MAX (send_vectored)
+    #include <netinet/in.h>     // for IPPROTO_TCP (set_tcp_nodelay)
+    #include <netinet/tcp.h>    // for TCP_NODELAY
+    // macOS/BSD have no MSG_NOSIGNAL; they suppress SIGPIPE with the SO_NOSIGPIPE
+    // socket option instead, which suppress_sigpipe() sets on every TCP socket we
+    // send on — so sending with no flag is the right fallback there.
+    #ifndef MSG_NOSIGNAL
+        #define MSG_NOSIGNAL 0
+    #endif
+#endif
+
+// RATS_HAVE_MMSG (recvmmsg/sendmmsg availability) is decided in socket.h, next to
+// the kUdpBatchIsOneSyscall it publishes — callers outside this file need to know
+// whether a batch is genuinely one syscall.
+
+// On Windows, SIO_UDP_CONNRESET lives in <mstcpip.h>, which mingw doesn't always pull
+// in via <winsock2.h>. Define it from its well-known control code as a fallback.
+#if defined(_WIN32) && !defined(SIO_UDP_CONNRESET)
+    #define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR, 12)
 #endif
 
 // Socket module logging macros
@@ -45,33 +65,71 @@ static std::string socket_error_string(int error) {
 #endif
 }
 
-// Extract sender peer info from sockaddr_storage (shared by UDP receive)
-static void extract_sender_peer(const sockaddr_storage& sender_addr, Peer& peer) {
-    if (sender_addr.ss_family == AF_INET) {
-        char ip_str[INET_ADDRSTRLEN];
-        const auto* addr_in = reinterpret_cast<const sockaddr_in*>(&sender_addr);
-        inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);
-        peer.ip = ip_str;
-        peer.port = ntohs(addr_in->sin_port);
-    } else if (sender_addr.ss_family == AF_INET6) {
-        const auto* addr_in6 = reinterpret_cast<const sockaddr_in6*>(&sender_addr);
-
-        // Check if this is an IPv4-mapped IPv6 address (::ffff:x.x.x.x)
-        if (IN6_IS_ADDR_V4MAPPED(&addr_in6->sin6_addr)) {
-            char ip_str[INET_ADDRSTRLEN];
-            struct in_addr ipv4_addr;
-            memcpy(&ipv4_addr, &addr_in6->sin6_addr.s6_addr[12], 4);
-            inet_ntop(AF_INET, &ipv4_addr, ip_str, INET_ADDRSTRLEN);
-            peer.ip = ip_str;
-        } else {
-            char ip_str[INET6_ADDRSTRLEN];
-            inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);
-            peer.ip = ip_str;
-        }
-        peer.port = ntohs(addr_in6->sin6_port);
+static void set_last_socket_error(int error) {
+#ifdef _WIN32
+    WSASetLastError(error);
+#else
+    errno = error;
+#endif
+}
+
+/*
+ * Put a failing socket back in the caller's hands with the error that actually
+ * caused it. close_socket() is a syscall like any other and overwrites errno on
+ * its way out, so a factory that cleans up before returning would otherwise hand
+ * the caller the close()'s error — or a stale success.
+ */
+static socket_t fail_socket(socket_t socket, int error) {
+    close_socket(socket);
+    set_last_socket_error(error);
+    return RATS_INVALID_SOCKET;
+}
+
+bool last_error_was_port_unavailable() {
+#ifdef _WIN32
+    /*
+     * WSAEACCES from a bind is not "denied" in the POSIX sense: it is how
+     * Windows reports a port inside a reserved range — the blocks Hyper-V,
+     * WinNAT and WSL2 carve out of the ephemeral range, or a port another
+     * process holds with SO_EXCLUSIVEADDRUSE. Like a clash, it is answered by
+     * moving to another port, and it has to be, because the TCP and UDP
+     * exclusion ranges are separate: a stream socket lands on a port the
+     * matching datagram bind is then refused.
+     */
+    const int error = get_last_socket_error();
+    return error == WSAEADDRINUSE || error == WSAEACCES;
+#else
+    // No POSIX counterpart worth adding: EACCES there means a privileged port,
+    // which the next few ports up would be refused for just the same.
+    return get_last_socket_error() == EADDRINUSE;
+#endif
+}
+
+void suppress_sigpipe(socket_t socket) {
+#ifdef SO_NOSIGPIPE
+    int on = 1;
+    if (setsockopt(socket, SOL_SOCKET, SO_NOSIGPIPE,
+                   reinterpret_cast<const char*>(&on), sizeof(on)) != 0) {
+        LOG_SOCKET_WARN("Failed to set SO_NOSIGPIPE on socket " << socket << ": "
+                        << socket_error_string(get_last_socket_error()));
+    }
+#else
+    (void)socket;
+#endif
+}
+
+// Extract sender peer info from sockaddr_storage (shared by UDP receive).
+// IpAddress::from_sockaddr copies the raw address bytes (and unwraps IPv4-mapped
+// IPv6) with no textual round-trip; an unknown family yields an unspecified peer.
+static void extract_sender_peer(const sockaddr_storage& sender_addr, Address& peer) {
+    const auto* sa = reinterpret_cast<const sockaddr*>(&sender_addr);
+    if (auto ip = IpAddress::from_sockaddr(sa)) {
+        peer.ip = *ip;
+        peer.port = (sender_addr.ss_family == AF_INET)
+                        ? ntohs(reinterpret_cast<const sockaddr_in*>(&sender_addr)->sin_port)
+                        : ntohs(reinterpret_cast<const sockaddr_in6*>(&sender_addr)->sin6_port);
     } else {
-        peer.ip = "unknown";
-        peer.port = 0;
+        peer = Address{};
     }
 }
 
@@ -81,10 +139,11 @@ static socket_t create_tcp_client_v4(const std::string& host, int port, int time
     LOG_SOCKET_DEBUG("Creating TCP client socket (IPv4) for " << host << ":" << port);
 
     socket_t client_socket = socket(AF_INET, SOCK_STREAM, 0);
-    if (client_socket == INVALID_SOCKET_VALUE) {
+    if (client_socket == RATS_INVALID_SOCKET) {
         LOG_SOCKET_ERROR("Failed to create IPv4 client socket");
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
+    suppress_sigpipe(client_socket);
 
     sockaddr_in server_addr;
     memset(&server_addr, 0, sizeof(server_addr));
@@ -95,13 +154,13 @@ static socket_t create_tcp_client_v4(const std::string& host, int port, int time
     if (resolved_ip.empty()) {
         LOG_SOCKET_ERROR("Failed to resolve hostname: " << host);
         close_socket(client_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     if (inet_pton(AF_INET, resolved_ip.c_str(), &server_addr.sin_addr) <= 0) {
         LOG_SOCKET_ERROR("Invalid address: " << resolved_ip);
         close_socket(client_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     LOG_SOCKET_DEBUG("Connecting to " << resolved_ip << ":" << port);
@@ -111,13 +170,13 @@ static socket_t create_tcp_client_v4(const std::string& host, int port, int time
                                   sizeof(server_addr), timeout_ms);
     } else {
         ok = (connect(client_socket, reinterpret_cast<sockaddr*>(&server_addr),
-                      sizeof(server_addr)) != SOCKET_ERROR_VALUE);
+                      sizeof(server_addr)) != RATS_SOCKET_ERROR);
     }
 
     if (!ok) {
         LOG_SOCKET_DEBUG("Connection to " << resolved_ip << ":" << port << " failed");
         close_socket(client_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     LOG_SOCKET_INFO("Successfully connected to " << resolved_ip << ":" << port);
@@ -128,10 +187,11 @@ static socket_t create_tcp_client_v6(const std::string& host, int port, int time
     LOG_SOCKET_DEBUG("Creating TCP client socket (IPv6) for " << host << ":" << port);
 
     socket_t client_socket = socket(AF_INET6, SOCK_STREAM, 0);
-    if (client_socket == INVALID_SOCKET_VALUE) {
+    if (client_socket == RATS_INVALID_SOCKET) {
         LOG_SOCKET_ERROR("Failed to create IPv6 client socket");
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
+    suppress_sigpipe(client_socket);
 
     sockaddr_in6 server_addr;
     memset(&server_addr, 0, sizeof(server_addr));
@@ -142,13 +202,13 @@ static socket_t create_tcp_client_v6(const std::string& host, int port, int time
     if (resolved_ip.empty()) {
         LOG_SOCKET_DEBUG("Failed to resolve hostname to IPv6: " << host);
         close_socket(client_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     if (inet_pton(AF_INET6, resolved_ip.c_str(), &server_addr.sin6_addr) <= 0) {
         LOG_SOCKET_ERROR("Invalid IPv6 address: " << resolved_ip);
         close_socket(client_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     LOG_SOCKET_DEBUG("Connecting to IPv6 " << resolved_ip << ":" << port);
@@ -158,13 +218,13 @@ static socket_t create_tcp_client_v6(const std::string& host, int port, int time
                                   sizeof(server_addr), timeout_ms);
     } else {
         ok = (connect(client_socket, reinterpret_cast<sockaddr*>(&server_addr),
-                      sizeof(server_addr)) != SOCKET_ERROR_VALUE);
+                      sizeof(server_addr)) != RATS_SOCKET_ERROR);
     }
 
     if (!ok) {
         LOG_SOCKET_DEBUG("Connection to IPv6 " << resolved_ip << ":" << port << " failed");
         close_socket(client_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     LOG_SOCKET_INFO("Successfully connected to IPv6 " << resolved_ip << ":" << port);
@@ -293,16 +353,102 @@ bool connect_with_timeout(socket_t socket, struct sockaddr* addr, socklen_t addr
     return false;
 }
 
+// ── Non-blocking connect (reactor-driven) ───────────────────────────────────
+
+static socket_t tcp_connect_start_family(int family, const std::string& resolved_ip, int port) {
+    socket_t s = socket(family, SOCK_STREAM, 0);
+    if (s == RATS_INVALID_SOCKET) return RATS_INVALID_SOCKET;
+    suppress_sigpipe(s);
+
+    if (!set_socket_nonblocking(s)) {
+        close_socket(s);
+        return RATS_INVALID_SOCKET;
+    }
+
+    sockaddr_storage ss;
+    memset(&ss, 0, sizeof(ss));
+    socklen_t addr_len = 0;
+
+    if (family == AF_INET) {
+        auto* a = reinterpret_cast<sockaddr_in*>(&ss);
+        a->sin_family = AF_INET;
+        a->sin_port = htons(static_cast<uint16_t>(port));
+        if (inet_pton(AF_INET, resolved_ip.c_str(), &a->sin_addr) <= 0) {
+            close_socket(s);
+            return RATS_INVALID_SOCKET;
+        }
+        addr_len = sizeof(sockaddr_in);
+    } else {
+        auto* a = reinterpret_cast<sockaddr_in6*>(&ss);
+        a->sin6_family = AF_INET6;
+        a->sin6_port = htons(static_cast<uint16_t>(port));
+        if (inet_pton(AF_INET6, resolved_ip.c_str(), &a->sin6_addr) <= 0) {
+            close_socket(s);
+            return RATS_INVALID_SOCKET;
+        }
+        addr_len = sizeof(sockaddr_in6);
+    }
+
+    int r = connect(s, reinterpret_cast<sockaddr*>(&ss), addr_len);
+    if (r == 0) {
+        return s;  // Connected synchronously (common on loopback).
+    }
+#ifdef _WIN32
+    int e = WSAGetLastError();
+    if (e == WSAEWOULDBLOCK || e == WSAEINPROGRESS) return s;  // In progress.
+#else
+    if (errno == EINPROGRESS) return s;  // In progress.
+#endif
+    LOG_SOCKET_DEBUG("Non-blocking connect to " << resolved_ip << ":" << port << " failed to start");
+    close_socket(s);
+    return RATS_INVALID_SOCKET;
+}
+
+socket_t tcp_connect_start(const std::string& host, int port) {
+    if (!validate_port(port)) return RATS_INVALID_SOCKET;
+
+    // Prefer IPv6, fall back to IPv4 — same precedence as create_tcp_client().
+    // Note: fallback happens at *resolution* time; a v6 address that resolves
+    // but fails asynchronously surfaces later as ConnectFailed (happy-eyeballs
+    // sequencing belongs in the higher-level dialer).
+    std::string ip6 = network_utils::resolve_hostname_v6(host);
+    if (!ip6.empty()) {
+        socket_t s = tcp_connect_start_family(AF_INET6, ip6, port);
+        if (is_valid_socket(s)) return s;
+    }
+
+    std::string ip4 = network_utils::resolve_hostname(host);
+    if (!ip4.empty()) {
+        socket_t s = tcp_connect_start_family(AF_INET, ip4, port);
+        if (is_valid_socket(s)) return s;
+    }
+
+    return RATS_INVALID_SOCKET;
+}
+
+int tcp_connect_result(socket_t socket) {
+    int err = 0;
+    socklen_t len = sizeof(err);
+    if (getsockopt(socket, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&err), &len) != 0) {
+#ifdef _WIN32
+        return WSAGetLastError();
+#else
+        return errno;
+#endif
+    }
+    return err;  // 0 == connected
+}
+
 // ── TCP Socket Functions ────────────────────────────────────────────────────
 
 socket_t create_tcp_client(const std::string& host, int port, int timeout_ms) {
-    if (!validate_port(port)) return INVALID_SOCKET_VALUE;
+    if (!validate_port(port)) return RATS_INVALID_SOCKET;
 
     LOG_SOCKET_DEBUG("Creating TCP client socket (dual stack) for " << host << ":" << port);
 
     // Try IPv6 first
     socket_t client_socket = create_tcp_client_v6(host, port, timeout_ms);
-    if (client_socket != INVALID_SOCKET_VALUE) {
+    if (client_socket != RATS_INVALID_SOCKET) {
         LOG_SOCKET_INFO("Successfully connected using IPv6");
         return client_socket;
     }
@@ -310,17 +456,17 @@ socket_t create_tcp_client(const std::string& host, int port, int timeout_ms) {
     // Fall back to IPv4
     LOG_SOCKET_DEBUG("IPv6 connection failed, trying IPv4");
     client_socket = create_tcp_client_v4(host, port, timeout_ms);
-    if (client_socket != INVALID_SOCKET_VALUE) {
+    if (client_socket != RATS_INVALID_SOCKET) {
         LOG_SOCKET_INFO("Successfully connected using IPv4");
         return client_socket;
     }
 
     LOG_SOCKET_DEBUG("Failed to connect using both IPv6 and IPv4");
-    return INVALID_SOCKET_VALUE;
+    return RATS_INVALID_SOCKET;
 }
 
 socket_t create_tcp_server(int port, int backlog, const std::string& bind_address, AddressFamily af) {
-    if (!validate_port(port)) return INVALID_SOCKET_VALUE;
+    if (!validate_port(port)) return RATS_INVALID_SOCKET;
 
     const char* af_label = (af == AddressFamily::IPv4) ? "IPv4" :
                            (af == AddressFamily::IPv6) ? "IPv6" : "dual stack";
@@ -330,27 +476,30 @@ socket_t create_tcp_server(int port, int backlog, const std::string& bind_addres
     int family = (af == AddressFamily::IPv4) ? AF_INET : AF_INET6;
 
     socket_t server_socket = socket(family, SOCK_STREAM, 0);
-    if (server_socket == INVALID_SOCKET_VALUE) {
-        LOG_SOCKET_ERROR("Failed to create " << af_label << " server socket");
-        return INVALID_SOCKET_VALUE;
+    if (server_socket == RATS_INVALID_SOCKET) {
+        LOG_SOCKET_ERROR("Failed to create " << af_label << " server socket (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
+        return RATS_INVALID_SOCKET;
     }
 
     // Set socket option to reuse address
     int opt = 1;
     if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR,
-                   (char*)&opt, sizeof(opt)) == SOCKET_ERROR_VALUE) {
-        LOG_SOCKET_ERROR("Failed to set " << af_label << " socket options");
+                   (char*)&opt, sizeof(opt)) == RATS_SOCKET_ERROR) {
+        LOG_SOCKET_ERROR("Failed to set " << af_label << " socket options (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         close_socket(server_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     // For IPv6/DualStack sockets, configure IPV6_V6ONLY
     if (family == AF_INET6) {
         int ipv6_only = (af == AddressFamily::IPv6) ? 1 : 0;
         if (setsockopt(server_socket, IPPROTO_IPV6, IPV6_V6ONLY,
-                       (char*)&ipv6_only, sizeof(ipv6_only)) == SOCKET_ERROR_VALUE) {
+                       (char*)&ipv6_only, sizeof(ipv6_only)) == RATS_SOCKET_ERROR) {
             if (af == AddressFamily::DualStack) {
-                LOG_SOCKET_WARN("Failed to disable IPv6-only mode, will be IPv6 only");
+                LOG_SOCKET_WARN("Failed to disable IPv6-only mode, will be IPv6 only (error: "
+                                << socket_error_string(get_last_socket_error()) << ")");
             }
         }
     }
@@ -368,15 +517,16 @@ socket_t create_tcp_server(int port, int backlog, const std::string& bind_addres
             if (inet_pton(AF_INET, bind_address.c_str(), &server_addr.sin_addr) != 1) {
                 LOG_SOCKET_ERROR("Invalid IPv4 bind address: " << bind_address);
                 close_socket(server_socket);
-                return INVALID_SOCKET_VALUE;
+                return RATS_INVALID_SOCKET;
             }
         }
 
         if (bind(server_socket, reinterpret_cast<sockaddr*>(&server_addr),
-                 sizeof(server_addr)) == SOCKET_ERROR_VALUE) {
-            LOG_SOCKET_ERROR("Failed to bind " << af_label << " server socket to port " << port);
-            close_socket(server_socket);
-            return INVALID_SOCKET_VALUE;
+                 sizeof(server_addr)) == RATS_SOCKET_ERROR) {
+            const int error = get_last_socket_error();
+            LOG_SOCKET_ERROR("Failed to bind " << af_label << " server socket to port " << port
+                             << " (error: " << socket_error_string(error) << ")");
+            return fail_socket(server_socket, error);
         }
     } else {
         sockaddr_in6 server_addr;
@@ -390,22 +540,24 @@ socket_t create_tcp_server(int port, int backlog, const std::string& bind_addres
             if (inet_pton(AF_INET6, bind_address.c_str(), &server_addr.sin6_addr) != 1) {
                 LOG_SOCKET_ERROR("Invalid IPv6 bind address: " << bind_address);
                 close_socket(server_socket);
-                return INVALID_SOCKET_VALUE;
+                return RATS_INVALID_SOCKET;
             }
         }
 
         if (bind(server_socket, reinterpret_cast<sockaddr*>(&server_addr),
-                 sizeof(server_addr)) == SOCKET_ERROR_VALUE) {
-            LOG_SOCKET_ERROR("Failed to bind " << af_label << " server socket to port " << port);
-            close_socket(server_socket);
-            return INVALID_SOCKET_VALUE;
+                 sizeof(server_addr)) == RATS_SOCKET_ERROR) {
+            const int error = get_last_socket_error();
+            LOG_SOCKET_ERROR("Failed to bind " << af_label << " server socket to port " << port
+                             << " (error: " << socket_error_string(error) << ")");
+            return fail_socket(server_socket, error);
         }
     }
 
-    if (listen(server_socket, backlog) == SOCKET_ERROR_VALUE) {
-        LOG_SOCKET_ERROR("Failed to listen on " << af_label << " server socket");
+    if (listen(server_socket, backlog) == RATS_SOCKET_ERROR) {
+        LOG_SOCKET_ERROR("Failed to listen on " << af_label << " server socket (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         close_socket(server_socket);
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
     LOG_SOCKET_INFO(af_label << " server listening on port " << port << " (backlog: " << backlog << ")");
@@ -417,10 +569,11 @@ socket_t accept_client(socket_t server_socket) {
     socklen_t client_addr_len = sizeof(client_addr);
 
     socket_t client_socket = accept(server_socket, reinterpret_cast<sockaddr*>(&client_addr), &client_addr_len);
-    if (client_socket == INVALID_SOCKET_VALUE) {
+    if (client_socket == RATS_INVALID_SOCKET) {
         LOG_SOCKET_ERROR("Failed to accept client connection");
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
+    suppress_sigpipe(client_socket);
 
     if (client_addr.ss_family == AF_INET) {
         char client_ip[INET_ADDRSTRLEN];
@@ -443,7 +596,7 @@ std::string get_peer_address(socket_t socket) {
     sockaddr_storage peer_addr;
     socklen_t peer_addr_len = sizeof(peer_addr);
 
-    if (getpeername(socket, reinterpret_cast<sockaddr*>(&peer_addr), &peer_addr_len) == SOCKET_ERROR_VALUE) {
+    if (getpeername(socket, reinterpret_cast<sockaddr*>(&peer_addr), &peer_addr_len) == RATS_SOCKET_ERROR) {
         LOG_SOCKET_ERROR("Failed to get peer address for socket " << socket);
         return "";
     }
@@ -471,6 +624,58 @@ std::string get_peer_address(socket_t socket) {
     return peer_ip + ":" + std::to_string(peer_port);
 }
 
+std::optional<Address> get_peer_endpoint(socket_t socket) {
+    sockaddr_storage ss;
+    socklen_t len = sizeof(ss);
+    if (getpeername(socket, reinterpret_cast<sockaddr*>(&ss), &len) == RATS_SOCKET_ERROR)
+        return std::nullopt;
+    auto ip = IpAddress::from_sockaddr(reinterpret_cast<sockaddr*>(&ss));
+    if (!ip) return std::nullopt;
+    const uint16_t port = (ss.ss_family == AF_INET)
+                              ? ntohs(reinterpret_cast<sockaddr_in*>(&ss)->sin_port)
+                              : ntohs(reinterpret_cast<sockaddr_in6*>(&ss)->sin6_port);
+    return Address{*ip, port};
+}
+
+std::ptrdiff_t send_vectored(socket_t socket, const ByteView* slices, size_t count) {
+    if (count == 0) return 0;
+    if (count > kMaxSendSlices) count = kMaxSendSlices;
+#if !defined(_WIN32) && defined(IOV_MAX)
+    // sendmsg() rejects an iovec longer than IOV_MAX with EINVAL — which the callers
+    // read as "the peer is gone" and would close a perfectly healthy connection over.
+    // POSIX only guarantees 16 (Linux and macOS allow 1024), so clamp rather than
+    // trust kMaxSendSlices to be under every platform's limit. The slices that don't
+    // fit are not lost: they go out on the next round of the caller's flush loop.
+    if (count > static_cast<size_t>(IOV_MAX)) count = static_cast<size_t>(IOV_MAX);
+#endif
+
+#ifdef _WIN32
+    WSABUF bufs[kMaxSendSlices];
+    for (size_t i = 0; i < count; ++i) {
+        bufs[i].buf = reinterpret_cast<CHAR*>(const_cast<uint8_t*>(slices[i].data()));
+        bufs[i].len = static_cast<ULONG>(slices[i].size());
+    }
+    DWORD sent = 0;
+    if (WSASend(socket, bufs, static_cast<DWORD>(count), &sent, 0, nullptr, nullptr) == SOCKET_ERROR) {
+        return -1;
+    }
+    return static_cast<std::ptrdiff_t>(sent);
+#else
+    struct iovec iov[kMaxSendSlices];
+    for (size_t i = 0; i < count; ++i) {
+        iov[i].iov_base = const_cast<uint8_t*>(slices[i].data());
+        iov[i].iov_len  = slices[i].size();
+    }
+    struct msghdr msg = {};
+    msg.msg_iov    = iov;
+    msg.msg_iovlen = static_cast<decltype(msg.msg_iovlen)>(count);
+    // MSG_NOSIGNAL keeps a peer that hung up from killing the process with SIGPIPE.
+    // It doesn't exist on macOS/BSD (they use SO_NOSIGPIPE on the socket instead),
+    // where the fallback below makes this a plain sendmsg().
+    return ::sendmsg(socket, &msg, MSG_NOSIGNAL);
+#endif
+}
+
 int send_tcp_data(socket_t socket, const std::vector<uint8_t>& data) {
     LOG_SOCKET_DEBUG("Sending " << data.size() << " bytes to TCP socket " << socket);
 
@@ -484,7 +689,7 @@ int send_tcp_data(socket_t socket, const std::vector<uint8_t>& data) {
 #else
         int bytes_sent = send(socket, buffer + total_sent, remaining, MSG_NOSIGNAL);
 #endif
-        if (bytes_sent == SOCKET_ERROR_VALUE) {
+        if (bytes_sent == RATS_SOCKET_ERROR) {
             int error = get_last_socket_error();
 #ifdef _WIN32
             if (error == WSAEWOULDBLOCK) { continue; }
@@ -523,7 +728,7 @@ std::vector<uint8_t> receive_tcp_data(socket_t socket, size_t buffer_size) {
     std::vector<uint8_t> buffer(buffer_size);
 
     int bytes_received = recv(socket, reinterpret_cast<char*>(buffer.data()), buffer_size, 0);
-    if (bytes_received == SOCKET_ERROR_VALUE) {
+    if (bytes_received == RATS_SOCKET_ERROR) {
         int error = get_last_socket_error();
 #ifdef _WIN32
         if (error == WSAEWOULDBLOCK) { return {}; }
@@ -579,7 +784,7 @@ static std::vector<uint8_t> receive_exact_bytes(socket_t socket, size_t num_byte
         std::vector<uint8_t> buffer(num_bytes - total_received);
         int bytes_received = recv(socket, reinterpret_cast<char*>(buffer.data()), buffer.size(), 0);
 
-        if (bytes_received == SOCKET_ERROR_VALUE) {
+        if (bytes_received == RATS_SOCKET_ERROR) {
             int error = get_last_socket_error();
 #ifdef _WIN32
             if (error == WSAEWOULDBLOCK) {
@@ -656,7 +861,7 @@ int send_tcp_string(socket_t socket, const std::string& data) {
 // ── UDP Socket Functions ────────────────────────────────────────────────────
 
 socket_t create_udp_socket(int port, const std::string& bind_address, AddressFamily af) {
-    if (!validate_port(port)) return INVALID_SOCKET_VALUE;
+    if (!validate_port(port)) return RATS_INVALID_SOCKET;
 
     const char* af_label = (af == AddressFamily::IPv4) ? "IPv4" :
                            (af == AddressFamily::IPv6) ? "IPv6" : "dual stack";
@@ -666,28 +871,55 @@ socket_t create_udp_socket(int port, const std::string& bind_address, AddressFam
     int family = (af == AddressFamily::IPv4) ? AF_INET : AF_INET6;
 
     socket_t udp_socket = socket(family, SOCK_DGRAM, 0);
-    if (udp_socket == INVALID_SOCKET_VALUE) {
+    if (udp_socket == RATS_INVALID_SOCKET) {
         LOG_SOCKET_ERROR("Failed to create " << af_label << " UDP socket (error: "
                          << socket_error_string(get_last_socket_error()) << ")");
-        return INVALID_SOCKET_VALUE;
+        return RATS_INVALID_SOCKET;
     }
 
-    // Set socket option to reuse address
-    int opt = 1;
-    if (setsockopt(udp_socket, SOL_SOCKET, SO_REUSEADDR,
-                   (char*)&opt, sizeof(opt)) == SOCKET_ERROR_VALUE) {
-        LOG_SOCKET_ERROR("Failed to set " << af_label << " UDP socket options");
-        close_socket(udp_socket);
-        return INVALID_SOCKET_VALUE;
+#ifdef _WIN32
+    // Disable the Windows-only "UDP connection reset" behaviour. By default, when a
+    // datagram we sent provokes an ICMP "port unreachable", Windows fails the *next*
+    // recvfrom() on this socket with WSAECONNRESET — nonsensical for a connectionless
+    // protocol. A DHT constantly sends to dead/unreachable nodes, so without this every
+    // such ICMP would cost us a receive cycle. FALSE turns it off.
+    {
+        BOOL connreset = FALSE;
+        DWORD bytes_returned = 0;
+        WSAIoctl(udp_socket, SIO_UDP_CONNRESET, &connreset, sizeof(connreset),
+                 nullptr, 0, &bytes_returned, nullptr, nullptr);
+    }
+#endif
+
+    // Reuse the address — but only for a port we asked for by number, where the
+    // point is to rebind a port a previous run may still be lingering on.
+    //
+    // Never when the kernel is choosing the port. On a datagram socket the option
+    // does not merely relax rebinding, it takes the port out of the set an auto-bind
+    // must avoid: asked for port 0, the kernel may return a port another socket
+    // already holds, provided that one set the option too — and every UDP socket
+    // here did. The two then share the port and the kernel picks one of them per
+    // datagram, so a dial-only socket can land on the port a listener beside it is
+    // serving and start eating its traffic. Rare, and invisible from either end.
+    if (port != 0) {
+        int opt = 1;
+        if (setsockopt(udp_socket, SOL_SOCKET, SO_REUSEADDR,
+                       (char*)&opt, sizeof(opt)) == RATS_SOCKET_ERROR) {
+            LOG_SOCKET_ERROR("Failed to set " << af_label << " UDP socket options (error: "
+                             << socket_error_string(get_last_socket_error()) << ")");
+            close_socket(udp_socket);
+            return RATS_INVALID_SOCKET;
+        }
     }
 
     // For IPv6/DualStack sockets, configure IPV6_V6ONLY
     if (family == AF_INET6) {
         int ipv6_only = (af == AddressFamily::IPv6) ? 1 : 0;
         if (setsockopt(udp_socket, IPPROTO_IPV6, IPV6_V6ONLY,
-                       (char*)&ipv6_only, sizeof(ipv6_only)) == SOCKET_ERROR_VALUE) {
+                       (char*)&ipv6_only, sizeof(ipv6_only)) == RATS_SOCKET_ERROR) {
             if (af == AddressFamily::DualStack) {
-                LOG_SOCKET_WARN("Failed to disable IPv6-only mode, will be IPv6 only");
+                LOG_SOCKET_WARN("Failed to disable IPv6-only mode, will be IPv6 only (error: "
+                                << socket_error_string(get_last_socket_error()) << ")");
             }
         }
     }
@@ -705,15 +937,15 @@ socket_t create_udp_socket(int port, const std::string& bind_address, AddressFam
             if (inet_pton(AF_INET, bind_address.c_str(), &addr.sin_addr) != 1) {
                 LOG_SOCKET_ERROR("Invalid IPv4 bind address: " << bind_address);
                 close_socket(udp_socket);
-                return INVALID_SOCKET_VALUE;
+                return RATS_INVALID_SOCKET;
             }
         }
 
-        if (bind(udp_socket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == SOCKET_ERROR_VALUE) {
+        if (bind(udp_socket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == RATS_SOCKET_ERROR) {
+            const int error = get_last_socket_error();
             LOG_SOCKET_ERROR("Failed to bind " << af_label << " UDP socket to port " << port
-                             << " (error: " << socket_error_string(get_last_socket_error()) << ")");
-            close_socket(udp_socket);
-            return INVALID_SOCKET_VALUE;
+                             << " (error: " << socket_error_string(error) << ")");
+            return fail_socket(udp_socket, error);
         }
     } else {
         sockaddr_in6 addr;
@@ -727,15 +959,15 @@ socket_t create_udp_socket(int port, const std::string& bind_address, AddressFam
             if (inet_pton(AF_INET6, bind_address.c_str(), &addr.sin6_addr) != 1) {
                 LOG_SOCKET_ERROR("Invalid IPv6 bind address: " << bind_address);
                 close_socket(udp_socket);
-                return INVALID_SOCKET_VALUE;
+                return RATS_INVALID_SOCKET;
             }
         }
 
-        if (bind(udp_socket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == SOCKET_ERROR_VALUE) {
+        if (bind(udp_socket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == RATS_SOCKET_ERROR) {
+            const int error = get_last_socket_error();
             LOG_SOCKET_ERROR("Failed to bind " << af_label << " UDP socket to port " << port
-                             << " (error: " << socket_error_string(get_last_socket_error()) << ")");
-            close_socket(udp_socket);
-            return INVALID_SOCKET_VALUE;
+                             << " (error: " << socket_error_string(error) << ")");
+            return fail_socket(udp_socket, error);
         }
     }
 
@@ -833,7 +1065,7 @@ int send_udp_data(socket_t socket, const std::vector<uint8_t>& data,
 
     int bytes_sent = sendto(socket, (char*)data.data(), data.size(), 0,
                             reinterpret_cast<sockaddr*>(&dest_addr), addr_len);
-    if (bytes_sent == SOCKET_ERROR_VALUE) {
+    if (bytes_sent == RATS_SOCKET_ERROR) {
         LOG_SOCKET_ERROR("Failed to send UDP data to " << host << ":" << port
                          << " (error: " << socket_error_string(get_last_socket_error()) << ")");
         return -1;
@@ -843,8 +1075,247 @@ int send_udp_data(socket_t socket, const std::vector<uint8_t>& data,
     return bytes_sent;
 }
 
-std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer& sender_peer,
-                                      int timeout_ms, socket_t interrupt_fd) {
+// Build a UDP destination sockaddr straight from a numeric Address — no hostname
+// resolution and no inet_pton, just a memcpy of the raw address bytes. On a
+// DualStack/IPv6 socket an IPv4 address is written as an IPv4-mapped IPv6 address.
+static bool build_udp_dest_addr(const IpAddress& ip, int port, AddressFamily af,
+                                sockaddr_storage& addr, socklen_t& addr_len) {
+    memset(&addr, 0, sizeof(addr));
+    if (ip.is_v6()) {
+        auto* a6 = reinterpret_cast<sockaddr_in6*>(&addr);
+        a6->sin6_family = AF_INET6;
+        a6->sin6_port   = htons(static_cast<uint16_t>(port));
+        memcpy(&a6->sin6_addr, ip.bytes().data(), 16);
+        addr_len = sizeof(sockaddr_in6);
+        return true;
+    }
+    if (ip.is_v4()) {
+        if (af == AddressFamily::IPv4) {
+            auto* a4 = reinterpret_cast<sockaddr_in*>(&addr);
+            a4->sin_family = AF_INET;
+            a4->sin_port   = htons(static_cast<uint16_t>(port));
+            memcpy(&a4->sin_addr, ip.bytes().data(), 4);
+            addr_len = sizeof(sockaddr_in);
+        } else {
+            auto* a6 = reinterpret_cast<sockaddr_in6*>(&addr);
+            a6->sin6_family = AF_INET6;
+            a6->sin6_port   = htons(static_cast<uint16_t>(port));
+            a6->sin6_addr.s6_addr[10] = 0xff;
+            a6->sin6_addr.s6_addr[11] = 0xff;
+            memcpy(&a6->sin6_addr.s6_addr[12], ip.bytes().data(), 4);
+            addr_len = sizeof(sockaddr_in6);
+        }
+        return true;
+    }
+    return false;  // unspecified — nothing to send to
+}
+
+int send_udp_data(socket_t socket, const std::vector<uint8_t>& data,
+                  const Address& dest, AddressFamily af) {
+    sockaddr_storage dest_addr;
+    socklen_t addr_len;
+    if (!build_udp_dest_addr(dest.ip, dest.port, af, dest_addr, addr_len)) return -1;
+
+    int bytes_sent = sendto(socket, (char*)data.data(), data.size(), 0,
+                            reinterpret_cast<sockaddr*>(&dest_addr), addr_len);
+    if (bytes_sent == RATS_SOCKET_ERROR) {
+        LOG_SOCKET_ERROR("Failed to send UDP data to " << dest.to_string()
+                         << " (error: " << socket_error_string(get_last_socket_error()) << ")");
+        return -1;
+    }
+    return bytes_sent;
+}
+
+bool set_socket_buffer_sizes(socket_t socket, int recv_bytes, int send_bytes) {
+    bool ok = true;
+    if (recv_bytes > 0 &&
+        setsockopt(socket, SOL_SOCKET, SO_RCVBUF,
+                   reinterpret_cast<const char*>(&recv_bytes), sizeof(recv_bytes)) != 0) {
+        LOG_SOCKET_DEBUG("Could not set SO_RCVBUF to " << recv_bytes);
+        ok = false;
+    }
+    if (send_bytes > 0 &&
+        setsockopt(socket, SOL_SOCKET, SO_SNDBUF,
+                   reinterpret_cast<const char*>(&send_bytes), sizeof(send_bytes)) != 0) {
+        LOG_SOCKET_DEBUG("Could not set SO_SNDBUF to " << send_bytes);
+        ok = false;
+    }
+    return ok;
+}
+
+bool set_tcp_nodelay(socket_t socket) {
+    const int on = 1;
+    if (setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
+                   reinterpret_cast<const char*>(&on), sizeof(on)) != 0) {
+        LOG_SOCKET_DEBUG("Could not disable Nagle on socket " << socket);
+        return false;
+    }
+    return true;
+}
+
+std::ptrdiff_t send_udp_to(socket_t socket, const void* data, size_t len,
+                           const Address& dest, AddressFamily af) {
+    sockaddr_storage dest_addr;
+    socklen_t addr_len;
+    if (!build_udp_dest_addr(dest.ip, dest.port, af, dest_addr, addr_len)) return -1;
+
+    const int sent = sendto(socket, static_cast<const char*>(data), static_cast<int>(len), 0,
+                            reinterpret_cast<sockaddr*>(&dest_addr), addr_len);
+    if (sent != RATS_SOCKET_ERROR) return sent;
+
+    const int error = get_last_socket_error();
+#ifdef _WIN32
+    if (error == WSAEWOULDBLOCK) return 0;
+#else
+    if (error == EAGAIN || error == EWOULDBLOCK || error == ENOBUFS) return 0;
+#endif
+    // A datagram socket reports per-destination problems (ICMP unreachable on a
+    // connected socket, a route that just went away) asynchronously on a later call.
+    // They say nothing about the socket itself, so they are the caller's business,
+    // not a fatal condition — hence a debug log rather than an error.
+    LOG_SOCKET_DEBUG("Failed to send datagram to " << dest.to_string()
+                     << " (error: " << socket_error_string(error) << ")");
+    return -1;
+}
+
+std::ptrdiff_t recv_udp_from(socket_t socket, void* buffer, size_t len, Address& from) {
+    sockaddr_storage sender_addr;
+    socklen_t sender_addr_len = sizeof(sender_addr);
+
+    const int received = recvfrom(socket, static_cast<char*>(buffer), static_cast<int>(len), 0,
+                                  reinterpret_cast<sockaddr*>(&sender_addr), &sender_addr_len);
+    if (received != RATS_SOCKET_ERROR) {
+        extract_sender_peer(sender_addr, from);
+        return received;
+    }
+
+    const int error = get_last_socket_error();
+#ifdef _WIN32
+    if (error == WSAEWOULDBLOCK) return kUdpRecvWouldBlock;
+    // Windows reports an ICMP port-unreachable for a *previous* datagram as an error
+    // on the next recvfrom(). It concerns one destination, not the socket, so keep
+    // draining rather than treating the whole mux as broken.
+    if (error == WSAECONNRESET || error == WSAENETRESET) return kUdpRecvError;
+#else
+    if (error == EAGAIN || error == EWOULDBLOCK) return kUdpRecvWouldBlock;
+    if (error == EINTR || error == ECONNREFUSED) return kUdpRecvError;
+#endif
+    LOG_SOCKET_DEBUG("Failed to receive datagram: " << socket_error_string(error));
+    return kUdpRecvError;
+}
+
+// ── Batched datagram I/O ────────────────────────────────────────────────────
+
+std::ptrdiff_t recv_udp_batch(socket_t socket, UdpBatchSlot* slots, size_t count) {
+    if (count == 0) return kUdpRecvWouldBlock;
+    if (count > kUdpBatchMax) count = kUdpBatchMax;
+
+#ifdef RATS_HAVE_MMSG
+    mmsghdr          msgs[kUdpBatchMax];
+    iovec            iov[kUdpBatchMax];
+    sockaddr_storage addrs[kUdpBatchMax];
+
+    memset(msgs, 0, sizeof(mmsghdr) * count);
+    for (size_t i = 0; i < count; ++i) {
+        iov[i].iov_base             = slots[i].data;
+        iov[i].iov_len              = slots[i].len;
+        msgs[i].msg_hdr.msg_name    = &addrs[i];
+        msgs[i].msg_hdr.msg_namelen = sizeof(sockaddr_storage);
+        msgs[i].msg_hdr.msg_iov     = &iov[i];
+        msgs[i].msg_hdr.msg_iovlen  = 1;
+    }
+
+    // MSG_DONTWAIT matters even on a socket that is already non-blocking: without
+    // it recvmmsg() waits for the *whole* array to fill when no timeout is given.
+    const int n = recvmmsg(socket, msgs, static_cast<unsigned int>(count), MSG_DONTWAIT, nullptr);
+    if (n > 0) {
+        for (int i = 0; i < n; ++i) {
+            slots[i].len = msgs[i].msg_len;
+            extract_sender_peer(addrs[i], slots[i].endpoint);
+        }
+        return n;
+    }
+    if (n == 0) return kUdpRecvWouldBlock;
+
+    const int error = get_last_socket_error();
+    if (error == EAGAIN || error == EWOULDBLOCK) return kUdpRecvWouldBlock;
+    // Only an error on the *first* datagram is reported here; one further in simply
+    // truncates the batch, which is why a short result is not proof of an empty
+    // queue. Either way this concerns one destination, not the socket.
+    if (error == EINTR || error == ECONNREFUSED) return kUdpRecvError;
+    LOG_SOCKET_DEBUG("Failed to receive a datagram batch: " << socket_error_string(error));
+    return kUdpRecvError;
+#else
+    size_t got = 0;
+    for (size_t i = 0; i < count; ++i) {
+        Address from;
+        const std::ptrdiff_t n = recv_udp_from(socket, slots[i].data, slots[i].len, from);
+        if (n == kUdpRecvWouldBlock) break;
+        // Report what has already arrived and let the caller come back for the rest;
+        // only an error on the very first datagram has nothing to report alongside it.
+        if (n == kUdpRecvError) return got > 0 ? static_cast<std::ptrdiff_t>(got) : kUdpRecvError;
+        slots[i].len      = static_cast<size_t>(n);
+        slots[i].endpoint = from;
+        ++got;
+    }
+    return got > 0 ? static_cast<std::ptrdiff_t>(got) : kUdpRecvWouldBlock;
+#endif
+}
+
+size_t send_udp_batch(socket_t socket, const UdpBatchSlot* slots, size_t count, AddressFamily af) {
+    if (count == 0) return 0;
+    if (count > kUdpBatchMax) count = kUdpBatchMax;
+
+#ifdef RATS_HAVE_MMSG
+    mmsghdr          msgs[kUdpBatchMax];
+    iovec            iov[kUdpBatchMax];
+    sockaddr_storage addrs[kUdpBatchMax];
+    socklen_t        addr_lens[kUdpBatchMax];
+
+    memset(msgs, 0, sizeof(mmsghdr) * count);
+    size_t staged = 0;
+    for (size_t i = 0; i < count; ++i) {
+        if (slots[i].len == 0) continue;
+        // An unspecified destination has nowhere to go; skip it rather than letting
+        // one bad slot fail the whole batch.
+        if (!build_udp_dest_addr(slots[i].endpoint.ip, slots[i].endpoint.port, af,
+                                 addrs[staged], addr_lens[staged]))
+            continue;
+
+        iov[staged].iov_base             = const_cast<uint8_t*>(slots[i].data);
+        iov[staged].iov_len              = slots[i].len;
+        msgs[staged].msg_hdr.msg_name    = &addrs[staged];
+        msgs[staged].msg_hdr.msg_namelen = addr_lens[staged];
+        msgs[staged].msg_hdr.msg_iov     = &iov[staged];
+        msgs[staged].msg_hdr.msg_iovlen  = 1;
+        ++staged;
+    }
+    if (staged == 0) return 0;
+
+    const int n = sendmmsg(socket, msgs, static_cast<unsigned int>(staged),
+                           MSG_DONTWAIT | MSG_NOSIGNAL);
+    if (n >= 0) return static_cast<size_t>(n);
+
+    const int error = get_last_socket_error();
+    // A full send buffer drops the batch, exactly as a congested link would drop it.
+    if (error == EAGAIN || error == EWOULDBLOCK || error == ENOBUFS) return 0;
+    LOG_SOCKET_DEBUG("Failed to send a datagram batch (error: "
+                     << socket_error_string(error) << ")");
+    return 0;
+#else
+    size_t sent = 0;
+    for (size_t i = 0; i < count; ++i) {
+        if (slots[i].len == 0) continue;
+        if (send_udp_to(socket, slots[i].data, slots[i].len, slots[i].endpoint, af) > 0) ++sent;
+    }
+    return sent;
+#endif
+}
+
+std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Address& sender_peer,
+                                      int timeout_ms, socket_t interrupt_fd, bool* error_out) {
+    if (error_out) *error_out = false;
+
     // Handle timeout (and optional interrupt socket) using select. When no interrupt
     // fd is supplied this path is identical to the plain timeout behavior.
     const bool have_interrupt = is_valid_socket(interrupt_fd);
@@ -868,19 +1339,29 @@ std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer&
 
         int result = select(static_cast<int>(maxfd) + 1, &read_fds, nullptr, nullptr, ptimeout);
         if (result == 0) {
-            LOG_SOCKET_DEBUG("UDP receive timeout (" << timeout_ms << "ms)");
+            // Timeout with no data — normal control flow for a polling/idle loop, so it's
+            // deliberately not logged (it would spam every idle cycle, e.g. the DHT runner).
             return {};
         } else if (result < 0) {
-            LOG_SOCKET_ERROR("Select error while waiting for UDP data");
-            return {};
-        }
-        // Woken by the interrupt socket (e.g. stop requested): leave the data socket
-        // untouched and report no data so the caller can re-check its stop flag.
-        if (have_interrupt && FD_ISSET(interrupt_fd, &read_fds)) {
+            const int error = get_last_socket_error();
+#ifndef _WIN32
+            // A signal cut the wait short — nothing is wrong with the socket. select()
+            // is never restarted by SA_RESTART, so a host process with a periodic timer
+            // signal (a sampling profiler, say) can hit this on every poll; reporting it
+            // as an error would let a caller that counts consecutive failures give up on
+            // a perfectly healthy socket. Report "no data" and let it poll again.
+            if (error == EINTR) { return {}; }
+#endif
+            LOG_SOCKET_ERROR("Select error while waiting for UDP data: " << socket_error_string(error));
+            if (error_out) *error_out = true;
             return {};
         }
-        // Guard against calling recvfrom on a data socket that isn't actually ready.
+        // Prefer real data: if a datagram arrived alongside a wakeup, read it now rather
+        // than deferring it a loop iteration. The wakeup byte stays buffered and is drained
+        // by the caller right after, so no wakeup is lost by checking data first.
         if (!FD_ISSET(socket, &read_fds)) {
+            // No data — must have been the interrupt socket (e.g. stop/posted work).
+            // Report no data so the caller can re-check its stop flag / run posted tasks.
             return {};
         }
     }
@@ -892,14 +1373,30 @@ std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer&
     int bytes_received = recvfrom(socket, (char*)buffer.data(), buffer_size, 0,
                                  reinterpret_cast<sockaddr*>(&sender_addr), &sender_addr_len);
 
-    if (bytes_received == SOCKET_ERROR_VALUE) {
+    if (bytes_received == RATS_SOCKET_ERROR) {
         int error = get_last_socket_error();
 #ifdef _WIN32
         if (error == WSAEWOULDBLOCK) { return {}; }
+        // Windows reports an ICMP port-unreachable for a *previous* datagram as an error
+        // on the next recvfrom(). It concerns one destination, not the socket, so it is
+        // not a reason to declare the receive path broken. Same classification as
+        // recv_udp_from().
+        if (error == WSAECONNRESET || error == WSAENETRESET) {
+            LOG_SOCKET_DEBUG("Transient UDP receive error: " << socket_error_string(error));
+            return {};
+        }
 #else
         if (error == EAGAIN || error == EWOULDBLOCK) { return {}; }
+        // EINTR is a signal, ECONNREFUSED an asynchronous ICMP unreachable for one
+        // destination — neither says anything about the socket itself. Same
+        // classification as recv_udp_from().
+        if (error == EINTR || error == ECONNREFUSED) {
+            LOG_SOCKET_DEBUG("Transient UDP receive error: " << socket_error_string(error));
+            return {};
+        }
 #endif
         LOG_SOCKET_DEBUG("Failed to receive UDP data: " << socket_error_string(error));
+        if (error_out) *error_out = true;
         return {};
     }
 
@@ -910,7 +1407,7 @@ std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer&
 
     extract_sender_peer(sender_addr, sender_peer);
 
-    LOG_SOCKET_DEBUG("Received " << bytes_received << " bytes from " << sender_peer.ip << ":" << sender_peer.port);
+    LOG_SOCKET_DEBUG("Received " << bytes_received << " bytes from " << sender_peer.to_string());
 
     buffer.resize(bytes_received);
     return buffer;
@@ -937,30 +1434,37 @@ void close_socket(socket_t socket, bool force) {
 #endif
         }
 
-        closesocket(socket);
+#ifdef _WIN32
+        ::closesocket(socket);
+#else
+        ::close(socket);
+#endif
     }
 }
 
 bool is_valid_socket(socket_t socket) {
-    return socket != INVALID_SOCKET_VALUE;
+    return socket != RATS_INVALID_SOCKET;
 }
 
 bool set_socket_nonblocking(socket_t socket) {
 #ifdef _WIN32
     unsigned long mode = 1;
     if (ioctlsocket(socket, FIONBIO, &mode) != 0) {
-        LOG_SOCKET_ERROR("Failed to set socket to non-blocking mode");
+        LOG_SOCKET_ERROR("Failed to set socket to non-blocking mode (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         return false;
     }
 #else
     int flags = fcntl(socket, F_GETFL, 0);
     if (flags == -1) {
-        LOG_SOCKET_ERROR("Failed to get socket flags");
+        LOG_SOCKET_ERROR("Failed to get socket flags (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         return false;
     }
 
     if (fcntl(socket, F_SETFL, flags | O_NONBLOCK) == -1) {
-        LOG_SOCKET_ERROR("Failed to set socket to non-blocking mode");
+        LOG_SOCKET_ERROR("Failed to set socket to non-blocking mode (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         return false;
     }
 #endif
@@ -973,18 +1477,21 @@ bool set_socket_blocking(socket_t socket) {
 #ifdef _WIN32
     unsigned long mode = 0;
     if (ioctlsocket(socket, FIONBIO, &mode) != 0) {
-        LOG_SOCKET_ERROR("Failed to set socket to blocking mode");
+        LOG_SOCKET_ERROR("Failed to set socket to blocking mode (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         return false;
     }
 #else
     int flags = fcntl(socket, F_GETFL, 0);
     if (flags == -1) {
-        LOG_SOCKET_ERROR("Failed to get socket flags");
+        LOG_SOCKET_ERROR("Failed to get socket flags (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         return false;
     }
 
     if (fcntl(socket, F_SETFL, flags & ~O_NONBLOCK) == -1) {
-        LOG_SOCKET_ERROR("Failed to set socket to blocking mode");
+        LOG_SOCKET_ERROR("Failed to set socket to blocking mode (error: "
+                         << socket_error_string(get_last_socket_error()) << ")");
         return false;
     }
 #endif