Add UDP server implementation and related functionalities

- Introduced `ChannelUnixUdpServer` class inheriting from `ChannelUnixSocketServer` to handle UDP-specific operations.
- Implemented methods for creating a UDP server socket, handling incoming datagrams, and sending buffers to clients.
- Added packet size handling logic in `getPacketSize` and `sendBuffer` methods.
- Enhanced error handling for socket operations and added constants for maximum UDP payload size.
- Updated `ChannelUnixSocketServer` to manage client connections and data processing.
- Refactored `ChannelUnixTcpServer` to reduce code duplication by reusing common functionalities from `ChannelUnixSocketServer`.

Author: vshcryabets

cpp/modules/l4/include/Channel.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <expected>
+
 #include "data.h"
 #include "SerializerL4.h"
 

cpp/modules/l4/include/cxx_17/data.h

@@ -16,4 +16,17 @@ namespace styxlib
     };
 
     using SizeResult = ExpectedSizeResult;
+
+    /**
+     * Reads the first X bytes of buffer and interprets them as a packet size.
+     * @param headerSize The size of the packet header (1, 2, or 4 bytes).
+     * @param buffer The buffer to read from.
+     * @param bufferSize The number of valid bytes available in the buffer.
+     * @return The decoded packet payload size, or an ErrorCode if the buffer
+     *         is too small to hold the header.
+     */
+    SizeResult getPacketSize(
+        const PacketHeaderSize &headerSize,
+        const uint8_t *buffer,
+        Size bufferSize);
 }

cpp/modules/l4/include/cxx_23/data.h

@@ -4,4 +4,6 @@
 namespace styxlib
 {
     using SizeResult = std::expected<Size, ErrorCode>;
+
+
 }

cpp/modules/l4/include/data.h

@@ -19,7 +19,8 @@ namespace styxlib
         UnknownClient,
         BufferTooSmall,
         InvalidHeaderSize,
-        NullptrArgument
+        NullptrArgument,
+        SendFailed
     };
 
     enum class PacketHeaderSize : uint8_t
@@ -29,6 +30,29 @@ namespace styxlib
         Size4Bytes = 4
     };
 
+
+
+    // inline uint8_t to_uint8_t(const PacketHeaderSize &headerSize)
+    // {
+    //     return static_cast<uint8_t>(headerSize);
+    // }
+
+    // /**
+    //  * Sets the packet size in the provided buffer according to the specified header size.
+    //  * @param headerSize The size of the packet header (1, 2, or 4 bytes).
+    //  * @param buffer The buffer where the packet size will be set.
+    //  * @param bufferSize The size of the buffer.
+    //  * @param packetSize The size of the packet to set.
+    //  * @return The number of bytes used for the header, or an ErrorCode if an error occurs.
+    //  */
+    // std::expected<uint8_t, ErrorCode> setPacketSize(
+    //     const PacketHeaderSize &headerSize,
+    //     uint8_t *buffer,
+    //     Size bufferSize,
+    //     Size packetSize);
+
+
+
     using StyxString = std::string;
     using StyxDate = uint32_t;
     using StyxBuffer = uint8_t *;
@@ -71,4 +95,20 @@ namespace styxlib
 #else
     // Handle older standards (C++14, C++11, etc.)
     #error "This library requires at least C++17."
-#endif
+#endif
+
+namespace styxlib
+{
+    /**
+     * Reads the first X bytes of buffer and interprets them as a packet size.
+     * @param headerSize The size of the packet header (1, 2, or 4 bytes).
+     * @param buffer The buffer to read from.
+     * @param bufferSize The number of valid bytes available in the buffer.
+     * @return The decoded packet payload size, or an ErrorCode if the buffer
+     *         is too small to hold the header.
+     */
+    SizeResult getPacketSize(
+        const PacketHeaderSize &headerSize,
+        const uint8_t *buffer,
+        Size bufferSize);
+}

cpp/modules/l4/include/impl/ChannelUnixSocket.h

@@ -1,11 +1,18 @@
 #pragma once
 
-#include <optional>
+#include <map>
+#include <thread>
+#include <atomic>
 #include <future>
+#include <optional>
 #include <string>
+#include <poll.h>
 
 #include "Channel.h"
+#include "ChannelTx.h"
+#include "ClientsRepo.h"
 #include "impl/ChannelUnixFile.h"
+#include "impl/ProgressObservableMutexImpl.h"
 
 namespace styxlib
 {
@@ -88,4 +95,130 @@ namespace styxlib
         std::future<void> disconnect();
         bool isConnected() const;
     };
+
+    /**
+     * Common base for socket-based server channels (TCP, UDP).
+     *
+     * Handles the shared lifecycle (start / stop / isStarted), the poll loop,
+     * client bookkeeping, processBuffers, and cleanupClosedSockets.
+     *
+     * Subclasses must implement createServerSocket() to set up the protocol-
+     * specific listen/bind socket.  Subclasses may also override
+     * acceptClients(), readDataFromSocket(), handlePollEvents(),
+     * cleanupClosedSockets(), and sendBuffer() to customise per-protocol
+     * behaviour (e.g. UDP does not call accept() and uses recvfrom/sendto).
+     */
+    class ChannelUnixSocketServer : public ChannelRx, public ChannelTx
+    {
+    public:
+        class Configuration
+        {
+        public:
+            const uint16_t port;
+            const std::shared_ptr<ClientsRepo> clientsRepo{nullptr};
+            const PacketHeaderSize packetSizeHeader{PacketHeaderSize::Size2Bytes};
+            const uint16_t iounit{8192};
+            const DeserializerL4Ptr deserializer{nullptr};
+            const uint16_t maxClients{16};
+
+            Configuration(
+                uint16_t port,
+                std::shared_ptr<ClientsRepo> clientsRepo,
+                PacketHeaderSize packetSizeHeader,
+                uint16_t iounit,
+                DeserializerL4Ptr deserializer,
+                uint8_t maxClients)
+                : port(port),
+                  clientsRepo(clientsRepo),
+                  packetSizeHeader(packetSizeHeader),
+                  iounit(iounit),
+                  deserializer(deserializer),
+                  maxClients(maxClients)
+            {
+            }
+        };
+
+        struct ClientInfo
+        {
+            ClientId id{0};
+            std::string address{""};
+            uint16_t port{0};
+        };
+
+    protected:
+        class ClientFullInfo : public ClientInfo, public ReadBuffer
+        {
+        };
+
+        const Configuration configuration;
+        std::thread serverThread;
+        Socket serverSocketFd{InvalidFileDescriptor};
+
+        // Sockets / pseudo-sockets -> per-client state
+        std::map<Socket, ClientFullInfo> socketToClientInfoMapFull;
+        std::vector<Socket> socketsToClose;
+
+        // Per-client transmit channels (used by connection-oriented protocols)
+        std::map<ClientId, std::shared_ptr<ChannelUnixSocketTx>> clientIdToChannelClient;
+
+        ProgressObservableMutexImpl<std::vector<ClientInfo>> clientsObserver;
+        std::atomic<bool> running{false};
+        std::atomic<bool> stopRequested{false};
+        std::unique_ptr<std::promise<ErrorCode>> startPromise;
+        std::vector<pollfd> pollFds;
+
+        // ── Extension points ─────────────────────────────────────────────────
+        /**
+         * Create, configure and bind (and optionally listen on) the server
+         * socket.  Must return a valid fd on success or set startPromise with
+         * an error code and return InvalidFileDescriptor on failure.
+         */
+        virtual Socket createServerSocket() = 0;
+
+        /** Called when the server-socket poll fd fires with POLLIN.
+         *  Default: calls accept() in a loop until EAGAIN.
+         *  Return true to indicate a new client was accepted (loop continues). */
+        virtual bool acceptClients(Socket serverSocket);
+
+        /** Called when a client-socket poll fd fires with POLLIN.
+         *  Default: reads via recv() into the client's ReadBuffer. */
+        virtual void readDataFromSocket(Socket clientFd);
+
+        /** Dispatch POLLIN / POLLERR / POLLHUP events for all ready fds.
+         *  Default implementation: server fd => acceptClients loop,
+         *                          client fd => readDataFromSocket,
+         *                          POLLERR|POLLHUP => mark socket for closure. */
+        virtual void handlePollEvents(Socket serverSocket, size_t numEvents);
+
+        /** Remove sockets that were queued in socketsToClose.
+         *  Default: calls ::close(), removes from pollFds and maps. */
+        virtual void cleanupClosedSockets();
+
+        /** Process dirty ReadBuffers held in socketToClientInfoMapFull and
+         *  forward complete packets to the deserializer.  Not virtual – the
+         *  framing logic is identical for all transports. */
+        void processBuffers();
+
+        void workThreadFunction();
+
+        /** Helper to rebuild and publish the clients observer vector. */
+        void publishClients();
+
+        /** Called at the end of stop() so subclasses can clean up protocol-
+         *  specific state (e.g. address maps in the UDP server). */
+        virtual void onStop() {}
+
+    public:
+        explicit ChannelUnixSocketServer(const Configuration &config);
+        ~ChannelUnixSocketServer() override;
+
+        SizeResult sendBuffer(ClientId clientId, const StyxBuffer buffer, Size size) override;
+        std::future<ErrorCode> start();
+        std::future<void> stop();
+        bool isStarted() const;
+        ProgressObserver<std::vector<ClientInfo>> &getClientsObserver()
+        {
+            return clientsObserver;
+        }
+    };
 } // namespace styxlib

cpp/modules/l4/include/impl/ChannelUnixTcp.h

@@ -1,11 +1,6 @@
 #pragma once
 
-#include <map>
-#include <thread>
-#include <atomic>
-#include <future>
 #include <optional>
-#include <poll.h>
 
 #include "Channel.h"
 #include "ChannelTx.h"
@@ -44,77 +39,28 @@ namespace styxlib
         std::future<ErrorCode> connect() override;
     };
 
-    class ChannelUnixTcpServer : public ChannelRx, public ChannelTx
+    /**
+     * TCP server channel.
+     * Inherits the common server lifecycle, poll loop, buffer processing and
+     * client bookkeeping from ChannelUnixSocketServer.  Only the TCP-specific
+     * socket setup (SOCK_STREAM / listen) and per-client accept/recv logic
+     * is implemented here.
+     */
+    class ChannelUnixTcpServer : public ChannelUnixSocketServer
     {
     public:
-        class Configuration
-        {
-        public:
-            const uint16_t port;
-            const std::shared_ptr<ClientsRepo> clientsRepo{nullptr};
-            const PacketHeaderSize packetSizeHeader{PacketHeaderSize::Size2Bytes};
-            const uint16_t iounit{8192};
-            const DeserializerL4Ptr deserializer{nullptr};
-            const uint16_t maxClients{16};
+        // Re-export the shared Configuration and ClientInfo types.
+        using Configuration = ChannelUnixSocketServer::Configuration;
+        using ClientInfo    = ChannelUnixSocketServer::ClientInfo;
 
-            Configuration(
-                uint16_t port,
-                std::shared_ptr<ClientsRepo> clientsRepo,
-                PacketHeaderSize packetSizeHeader,
-                uint16_t iounit,
-                DeserializerL4Ptr deserializer,
-                uint8_t maxClients)
-                : port(port),
-                  clientsRepo(clientsRepo),
-                  packetSizeHeader(packetSizeHeader),
-                  iounit(iounit),
-                  deserializer(deserializer),
-                  maxClients(maxClients)
-            {
-            }
-        };
-        struct ClientInfo
-        {
-            ClientId id{0};
-            std::string address{""};
-            uint16_t port{0};
-        };
+        explicit ChannelUnixTcpServer(const Configuration &config);
+        ChannelUnixTcpServer(ChannelUnixTcpServer &&) = delete;
+        ChannelUnixTcpServer &operator=(ChannelUnixTcpServer &&) = delete;
+        ~ChannelUnixTcpServer() override = default;
 
     protected:
-        class ClientFullInfo : public ClientInfo, public ReadBuffer
-        {
-        };
-        const Configuration configuration;
-        std::thread serverThread;
-        // Sockets
-        std::map<Socket, ClientFullInfo> socketToClientInfoMapFull;
-        std::vector<Socket> socketsToClose;
-        // Clients
-        std::map<ClientId, std::shared_ptr<ChannelUnixTcpTx>> clientIdToChannelClient;
-
-        ProgressObservableMutexImpl<std::vector<ClientInfo>> clientsObserver;
-        std::atomic<bool> running{false};
-        std::atomic<bool> stopRequested{false};
-        std::unique_ptr<std::promise<ErrorCode>> startPromise;
-        std::vector<pollfd> pollFds;
-
-        void workThreadFunction();
-        virtual bool acceptClients(Socket serverSocket);
-        virtual void readDataFromSocket(Socket clientFd);
-        void handlePollEvents(Socket serverSocket, size_t numEvents); // Handle poll events
-        void cleanupClosedSockets(); // Clean up sockets marked for closure
-        void processBuffers(); // Check dirty buffers and send data to deserializer
-
-    public:
-        ChannelUnixTcpServer(const Configuration &config);
-        ~ChannelUnixTcpServer() override;
-        SizeResult sendBuffer(ClientId clientId, const StyxBuffer buffer, Size size) override;
-        std::future<ErrorCode> start();
-        std::future<void> stop();
-        ProgressObserver<std::vector<ClientInfo>> &getClientsObserver()
-        {
-            return clientsObserver;
-        }
-        bool isStarted() const;
+        Socket createServerSocket() override;
+        bool   acceptClients(Socket serverSocket) override;
+        void   readDataFromSocket(Socket clientFd) override;
     };
 }