ServerSocket.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "Socket.hpp"
#include "common.hpp"
 
#include <exception>
#include <functional>
#include <future>
#include <optional>
 
using jsocketpp::DefaultBufferSize;
 
namespace jsocketpp
{

class ServerSocket
{
 
  public:
    explicit ServerSocket(Port port, std::string_view localAddress = {}, bool autoBindListen = true,
                          bool reuseAddress = true, int soTimeoutMillis = -1, bool dualStack = true);

    [[nodiscard]] std::string getInetAddress() const;

    [[nodiscard]] Port getLocalPort() const;

    [[nodiscard]] std::string getLocalSocketAddress() const;

    ServerSocket(const ServerSocket& rhs) = delete; //-Weffc++

    ServerSocket& operator=(const ServerSocket& rhs) = delete; //-Weffc++

    ServerSocket(ServerSocket&& rhs) noexcept
        : _serverSocket(rhs._serverSocket), _srvAddrInfo(rhs._srvAddrInfo), _selectedAddrInfo(rhs._selectedAddrInfo),
          _port(rhs._port), _isBound(rhs._isBound), _isListening(rhs._isListening),
          _soTimeoutMillis(rhs._soTimeoutMillis), _defaultReceiveBufferSize(rhs._defaultReceiveBufferSize)
    {
        rhs._serverSocket = INVALID_SOCKET;
        rhs._srvAddrInfo = nullptr;
        rhs._selectedAddrInfo = nullptr;
        rhs._isBound = false;
        rhs._isListening = false;
    }

    ServerSocket& operator=(ServerSocket&& rhs) noexcept
    {
        if (this != &rhs)
        {
            try
            {
                close(); // Clean up existing resources
            }
            catch (...)
            {
            }
            _serverSocket = rhs._serverSocket;
            _srvAddrInfo = rhs._srvAddrInfo;
            _selectedAddrInfo = rhs._selectedAddrInfo;
            _port = rhs._port;
            _isBound = rhs._isBound;
            _isListening = rhs._isListening;
            _soTimeoutMillis = rhs._soTimeoutMillis;
            _defaultReceiveBufferSize = rhs._defaultReceiveBufferSize;
 
            rhs._serverSocket = INVALID_SOCKET;
            rhs._srvAddrInfo = nullptr;
            rhs._selectedAddrInfo = nullptr;
            rhs._isBound = false;
            rhs._isListening = false;
        }
        return *this;
    }

    ~ServerSocket() noexcept;

    void bind();

    [[nodiscard]] bool isBound() const noexcept { return _isBound; }

    void listen(int backlog = 128);

    [[nodiscard]] bool isListening() const noexcept { return _isListening; }

    [[nodiscard]] Socket accept(std::optional<std::size_t> recvBufferSize = std::nullopt,
                                std::optional<std::size_t> sendBufferSize = std::nullopt,
                                std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    [[nodiscard]] Socket accept(int timeoutMillis, std::optional<std::size_t> recvBufferSize = std::nullopt,
                                std::optional<std::size_t> sendBufferSize = std::nullopt,
                                std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    [[nodiscard]] std::optional<Socket> tryAccept(std::optional<std::size_t> recvBufferSize = std::nullopt,
                                                  std::optional<std::size_t> sendBufferSize = std::nullopt,
                                                  std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    [[nodiscard]] std::optional<Socket> tryAccept(int timeoutMillis,
                                                  std::optional<std::size_t> recvBufferSize = std::nullopt,
                                                  std::optional<std::size_t> sendBufferSize = std::nullopt,
                                                  std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    [[nodiscard]] Socket acceptBlocking(std::optional<std::size_t> recvBufferSize = std::nullopt,
                                        std::optional<std::size_t> sendBufferSize = std::nullopt,
                                        std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    [[nodiscard]] std::optional<Socket>
    acceptNonBlocking(std::optional<std::size_t> recvBufferSize = std::nullopt,
                      std::optional<std::size_t> sendBufferSize = std::nullopt,
                      std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    [[nodiscard]] std::future<Socket> acceptAsync(std::optional<std::size_t> recvBufferSize = std::nullopt,
                                                  std::optional<std::size_t> sendBufferSize = std::nullopt,
                                                  std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    void acceptAsync(std::function<void(std::optional<Socket>, std::exception_ptr)> callback,
                     std::optional<std::size_t> recvBufferSize = std::nullopt,
                     std::optional<std::size_t> sendBufferSize = std::nullopt,
                     std::optional<std::size_t> internalBufferSize = std::nullopt) const;

    void close();

    [[nodiscard]] bool isValid() const noexcept { return this->_serverSocket != INVALID_SOCKET; }

    [[nodiscard]] bool isClosed() const noexcept { return this->_serverSocket == INVALID_SOCKET; }

    void setOption(int level, int optName, int value);

    [[nodiscard]] int getOption(int level, int optName) const;

    [[nodiscard]] static int getSocketReuseOption();

    void setReuseAddress(bool enable);

    [[nodiscard]] bool getReuseAddress() const;

    void setNonBlocking(bool nonBlocking);

    [[nodiscard]] bool getNonBlocking() const;

    [[nodiscard]] bool waitReady(std::optional<int> timeoutMillis = std::nullopt) const;

    void setSoTimeout(const int timeoutMillis) { _soTimeoutMillis = timeoutMillis; }

    [[nodiscard]] int getSoTimeout() const noexcept { return _soTimeoutMillis; }
 
#if defined(IPV6_V6ONLY)
    void setIPv6Only(bool enable);

    [[nodiscard]] bool getIPv6Only() const;
#endif

    void setDefaultReceiveBufferSize(const std::size_t size) { _defaultReceiveBufferSize = size; }

    [[nodiscard]] std::size_t getDefaultReceiveBufferSize() const noexcept { return _defaultReceiveBufferSize; }

    void setDefaultSendBufferSize(const std::size_t size) { _defaultSendBufferSize = size; }

    [[nodiscard]] std::size_t getDefaultSendBufferSize() const noexcept { return _defaultSendBufferSize; }

    void setDefaultInternalBufferSize(const std::size_t size) { _defaultInternalBufferSize = size; }

    [[nodiscard]] std::size_t getDefaultInternalBufferSize() const noexcept { return _defaultInternalBufferSize; }
 
#if defined(SO_REUSEPORT)
    void setReusePort(bool enable);

    [[nodiscard]] bool getReusePort() const;
#endif

    [[nodiscard]] SOCKET getHandle() const { return _serverSocket; }
 
  protected:
    void cleanupAndThrow(int errorCode);
 
  private:
    [[nodiscard]] std::size_t getEffectiveReceiveBufferSize(const std::optional<std::size_t> recvBufferSize) const
    {
        return recvBufferSize.value_or(_defaultReceiveBufferSize);
    }

    [[nodiscard]] std::size_t getEffectiveSendBufferSize(std::optional<std::size_t> sendBufferSize) const
    {
        return sendBufferSize.value_or(_defaultSendBufferSize);
    }

    [[nodiscard]] std::size_t getEffectiveInternalBufferSize(std::optional<std::size_t> internalBufferSize) const
    {
        return internalBufferSize.value_or(_defaultInternalBufferSize);
    }

    [[nodiscard]] std::tuple<std::size_t, std::size_t, std::size_t>
    resolveBuffers(const std::optional<std::size_t> recv, const std::optional<std::size_t> send,
                   const std::optional<std::size_t> internal) const
    {
        return {getEffectiveReceiveBufferSize(recv), getEffectiveSendBufferSize(send),
                getEffectiveInternalBufferSize(internal)};
    }
 
    SOCKET _serverSocket = INVALID_SOCKET; 
    addrinfo* _srvAddrInfo = nullptr;      
    addrinfo* _selectedAddrInfo = nullptr; 
    Port _port;                            
    bool _isBound = false;                 
    bool _isListening = false;             
    int _soTimeoutMillis = -1; 
    std::size_t _defaultReceiveBufferSize =
        DefaultBufferSize; 
    std::size_t _defaultSendBufferSize = DefaultBufferSize; 
    std::size_t _defaultInternalBufferSize =
        DefaultBufferSize; 
};
 
} // namespace jsocketpp