Align error handling of sync/async socket operations

Currently, if an error occurs on asynchronous operations, the socket is
closed and the error is logged. Do the same for synchronous operations.

Author: trflynn89

fly/net/socket/listen_socket.cpp

@@ -83,7 +83,7 @@ bool ListenSocket<EndpointType>::is_listening() const
 
 //==================================================================================================
 template <typename EndpointType>
-std::optional<TcpSocket<EndpointType>> ListenSocket<EndpointType>::accept() const
+std::optional<TcpSocket<EndpointType>> ListenSocket<EndpointType>::accept()
 {
     EndpointType client_endpoint;
     bool would_block = false;
@@ -94,6 +94,9 @@ std::optional<TcpSocket<EndpointType>> ListenSocket<EndpointType>::accept() cons
         return TcpSocket<EndpointType>(*client, io_mode());
     }
 
+    SLOGW(handle(), "Could not accept new socket, closing");
+    close();
+
     return std::nullopt;
 }
 

fly/net/socket/listen_socket.hpp

@@ -71,18 +71,20 @@ class ListenSocket :
     bool is_listening() const;
 
     /**
-     * Accept an incoming connection on this listening socket.
+     * Accept an incoming connection on this listening socket. If an error occurs on the socket, the
+     * socket will be closed.
      *
      * @return If successful, the accepted socket. Otherwise, an uninitialized value.
      */
-    std::optional<TcpSocket<EndpointType>> accept() const;
+    std::optional<TcpSocket<EndpointType>> accept();
 
     /**
      * Asynchronously accept an incoming connection on this listening socket. May only be used if
      * this socket was created through a socket service.
      *
      * If successful, the provided callback will be invoked with the accepted socket upon
-     * completion. Otherwise, the provided callback will be invoked with a null socket.
+     * completion. Otherwise, the provided callback will be invoked with an uninitialized value, and
+     * the socket will be closed before the invocation.
      *
      * @param callback The callback to invoke when the operation has completed.
      *
@@ -119,7 +121,8 @@ class ListenSocket :
      * When the socket service indicates the socket is available for reading, attempt to accept an
      * incoming connection. If successful, the provided callback will be invoked with the accepted
      * socket. If unsuccessful because the operation would still block, queue another attempt.
-     * Otherwise, the callback will be invoked with a null socket.
+     * Otherwise, the socket will be closed and the callback will be invoked with an uninitialized
+     * value.
      *
      * @param callback The callback to invoke when the operation has completed.
      */

fly/net/socket/tcp_socket.cpp

@@ -226,10 +226,22 @@ bool TcpSocket<EndpointType>::is_connected() const
 
 //==================================================================================================
 template <typename EndpointType>
-std::size_t TcpSocket<EndpointType>::send(std::string_view message) const
+std::size_t TcpSocket<EndpointType>::send(std::string_view message)
 {
     bool would_block = false;
-    return fly::net::detail::send(handle(), std::move(message), would_block);
+    std::size_t bytes_sent = fly::net::detail::send(handle(), std::move(message), would_block);
+
+    if (bytes_sent == 0)
+    {
+        SLOGW(handle(), "Error sending, closing");
+        close();
+    }
+    else
+    {
+        SLOGD(handle(), "Sent {} bytes", bytes_sent);
+    }
+
+    return bytes_sent;
 }
 
 //==================================================================================================
@@ -253,10 +265,22 @@ bool TcpSocket<EndpointType>::send_async(std::string_view message, SendCompletio
 
 //==================================================================================================
 template <typename EndpointType>
-std::string TcpSocket<EndpointType>::receive() const
+std::string TcpSocket<EndpointType>::receive()
 {
     bool would_block = false;
-    return fly::net::detail::recv(handle(), m_packet_size, would_block);
+    const std::string received = fly::net::detail::recv(handle(), m_packet_size, would_block);
+
+    if (received.size() == 0)
+    {
+        SLOGW(handle(), "Error receiving, closing");
+        close();
+    }
+    else
+    {
+        SLOGD(handle(), "Received {} bytes", received.size());
+    }
+
+    return received;
 }
 
 //==================================================================================================

fly/net/socket/tcp_socket.hpp

@@ -149,13 +149,14 @@ class TcpSocket :
     bool is_connected() const;
 
     /**
-     * Transmit a message to the connected remote socket.
+     * Transmit a message to the connected remote socket. If an error occurs on the socket, the
+     * socket will be closed.
      *
      * @param message The message to transmit.
      *
      * @return The number of bytes transmitted.
      */
-    std::size_t send(std::string_view message) const;
+    std::size_t send(std::string_view message);
 
     /**
      * Asynchronously transmit a message to the connected remote socket. May only be used if this
@@ -174,11 +175,12 @@ class TcpSocket :
     bool send_async(std::string_view message, SendCompletion &&callback);
 
     /**
-     * Receive a message from the connected remote socket.
+     * Receive a message from the connected remote socket. If an error occurs on the socket, the
+     * socket will be closed.
      *
      * @return The message received.
      */
-    std::string receive() const;
+    std::string receive();
 
     /**
      * Asynchronously receive a message from the connected remote socket. May only be used if this

fly/net/socket/udp_socket.cpp

@@ -61,23 +61,35 @@ UdpSocket<EndpointType> &UdpSocket<EndpointType>::operator=(UdpSocket &&socket)
 
 //==================================================================================================
 template <typename EndpointType>
-size_t UdpSocket<EndpointType>::send(const EndpointType &endpoint, std::string_view message) const
+size_t UdpSocket<EndpointType>::send(const EndpointType &endpoint, std::string_view message)
 {
     bool would_block = false;
 
-    return fly::net::detail::send_to(
+    std::size_t bytes_sent = fly::net::detail::send_to(
         handle(),
         endpoint,
         std::move(message),
         m_packet_size,
         would_block);
+
+    if (bytes_sent == 0)
+    {
+        SLOGW(handle(), "Error sending to {}, closing", endpoint);
+        close();
+    }
+    else
+    {
+        SLOGD(handle(), "Sent {} bytes to {}", bytes_sent, endpoint);
+    }
+
+    return bytes_sent;
 }
 
 //==================================================================================================
 template <typename EndpointType>
 size_t
 UdpSocket<EndpointType>::send(std::string_view hostname, port_type port, std::string_view message)
-    const
+
 {
     if (auto endpoint = hostname_to_endpoint(std::move(hostname)); endpoint)
     {
@@ -130,12 +142,25 @@ bool UdpSocket<EndpointType>::send_async(
 
 //==================================================================================================
 template <typename EndpointType>
-std::string UdpSocket<EndpointType>::receive() const
+std::string UdpSocket<EndpointType>::receive()
 {
     EndpointType endpoint;
     bool would_block = false;
 
-    return fly::net::detail::recv_from(handle(), endpoint, m_packet_size, would_block);
+    const std::string received =
+        fly::net::detail::recv_from(handle(), endpoint, m_packet_size, would_block);
+
+    if (received.size() == 0)
+    {
+        SLOGW(handle(), "Error receiving, closing");
+        close();
+    }
+    else
+    {
+        SLOGD(handle(), "Received {} bytes from {}", received.size(), endpoint);
+    }
+
+    return received;
 }
 
 //==================================================================================================

fly/net/socket/udp_socket.hpp

@@ -58,25 +58,27 @@ class UdpSocket :
     UdpSocket &operator=(UdpSocket &&socket) noexcept;
 
     /**
-     * Transmit a message to a specific remote endpoint.
+     * Transmit a message to a specific remote endpoint. If an error occurs on the socket, the
+     * socket will be closed.
      *
      * @param endpoint The remote endpoint to transmit to.
      * @param message The message to transmit.
      *
      * @return The number of bytes transmitted.
      */
-    std::size_t send(const EndpointType &endpoint, std::string_view message) const;
+    std::size_t send(const EndpointType &endpoint, std::string_view message);
 
     /**
-     * Transmit a message to a specific remote endpoint.
+     * Transmit a message to a specific remote endpoint. If an error occurs on the socket, the
+     * socket will be closed.
      *
      * @param hostname The hostname or IP address string to transmit to.
      * @param port The port to transmit to.
      * @param message The message to transmit.
      *
      * @return The number of bytes transmitted.
      */
-    std::size_t send(std::string_view hostname, port_type port, std::string_view message) const;
+    std::size_t send(std::string_view hostname, port_type port, std::string_view message);
 
     /**
      * Asynchronously transmit a message to a specific remote endpoint. May only be used if this
@@ -119,11 +121,12 @@ class UdpSocket :
         SendCompletion &&callback);
 
     /**
-     * Receive a message from an unspecified remote endpoint.
+     * Receive a message from an unspecified remote endpoint. If an error occurs on the socket, the
+     * socket will be closed.
      *
      * @return The message received.
      */
-    std::string receive() const;
+    std::string receive();
 
     /**
      * Asynchronously receive a message from an unspecified remote endpoint. May only be used if

test/net/listen_socket.cpp

@@ -169,6 +169,7 @@ CATCH_TEMPLATE_TEST_CASE("ListenSocket", "[net]", fly::net::IPv4Address, fly::ne
         CATCH_REQUIRE(socket);
 
         CATCH_CHECK_FALSE(socket->accept());
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 
 #if defined(FLY_LINUX)
@@ -285,6 +286,7 @@ CATCH_TEMPLATE_TEST_CASE("ListenSocket", "[net]", fly::net::IPv4Address, fly::ne
         CATCH_CHECK(socket->listen());
 
         CATCH_CHECK_FALSE(socket->accept());
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 
 #endif

test/net/tcp_socket.cpp

@@ -150,6 +150,7 @@ CATCH_TEMPLATE_TEST_CASE("TcpSocket", "[net]", fly::net::IPv4Address, fly::net::
         CATCH_REQUIRE(socket);
 
         CATCH_CHECK(socket->send(message) == 0);
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 
     CATCH_SECTION("Disconnected sockets may not receive messages")
@@ -158,6 +159,7 @@ CATCH_TEMPLATE_TEST_CASE("TcpSocket", "[net]", fly::net::IPv4Address, fly::net::
         CATCH_REQUIRE(socket);
 
         CATCH_CHECK(socket->receive().empty());
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 
     CATCH_SECTION("Connected sockets may send and receive messages")
@@ -299,6 +301,7 @@ CATCH_TEMPLATE_TEST_CASE("TcpSocket", "[net]", fly::net::IPv4Address, fly::net::
         CATCH_REQUIRE(socket);
 
         CATCH_CHECK(socket->send(message) == 0);
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 
     CATCH_SECTION("Socket receiving fails due to ::recv() system call")
@@ -309,6 +312,7 @@ CATCH_TEMPLATE_TEST_CASE("TcpSocket", "[net]", fly::net::IPv4Address, fly::net::
         CATCH_REQUIRE(socket);
 
         CATCH_CHECK(socket->receive().empty());
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 
 #endif

test/net/udp_socket.cpp

@@ -237,6 +237,7 @@ CATCH_TEMPLATE_TEST_CASE("UdpSocket", "[net]", fly::net::IPv4Address, fly::net::
         CATCH_REQUIRE(socket);
 
         CATCH_CHECK(socket->send(s_localhost, s_port, message) == 0);
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 
     CATCH_SECTION("Socket receiving fails due to ::recvfrom() system call")
@@ -247,6 +248,7 @@ CATCH_TEMPLATE_TEST_CASE("UdpSocket", "[net]", fly::net::IPv4Address, fly::net::
         CATCH_REQUIRE(socket);
 
         CATCH_CHECK(socket->receive().empty());
+        CATCH_CHECK_FALSE(socket->is_valid());
     }
 #endif
 }