ServerSocket.hpp

Go to the documentation of this file.

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

class ServerSocket : public SocketOptions
{
  public:
    ServerSocket() = delete;

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

    [[nodiscard]] std::string getLocalIp(bool convertIPv4Mapped = true) 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
        : SocketOptions(rhs.getSocketFd()), _srvAddrInfo(std::move(rhs._srvAddrInfo)),
          _selectedAddrInfo(rhs._selectedAddrInfo), _port(rhs._port), _isBound(rhs._isBound),
          _isListening(rhs._isListening), _soTimeoutMillis(rhs._soTimeoutMillis),
          _defaultReceiveBufferSize(rhs._defaultReceiveBufferSize)
    {
        rhs.setSocketFd(INVALID_SOCKET);
        rhs._selectedAddrInfo = nullptr;
        rhs._isBound = false;
        rhs._isListening = false;
    }

    ServerSocket& operator=(ServerSocket&& rhs) noexcept
    {
        if (this != &rhs)
        {
            // Clean up current socket
            try
            {
                close(); // Clean up existing resources
            }
            catch (...)
            {
            }
 
            // Transfer ownership
            setSocketFd(rhs.getSocketFd());
            _srvAddrInfo = std::move(rhs._srvAddrInfo);
            _selectedAddrInfo = rhs._selectedAddrInfo;
            _port = rhs._port;
            _isBound = rhs._isBound;
            _isListening = rhs._isListening;
            _soTimeoutMillis = rhs._soTimeoutMillis;
            _defaultReceiveBufferSize = rhs._defaultReceiveBufferSize;
 
            // Reset source;
            rhs.setSocketFd(INVALID_SOCKET);
            rhs._selectedAddrInfo = nullptr;
            rhs._isBound = false;
            rhs._isListening = false;
        }
        return *this;
    }

    ~ServerSocket() noexcept override;

    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,
                                int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1, bool tcpNoDelay = true,
                                bool keepAlive = false, bool nonBlocking = false) 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,
                                int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1, bool tcpNoDelay = true,
                                bool keepAlive = false, bool nonBlocking = false) 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,
                                                  int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1,
                                                  bool tcpNoDelay = true, bool keepAlive = false,
                                                  bool nonBlocking = false) 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,
                                                  int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1,
                                                  bool tcpNoDelay = true, bool keepAlive = false,
                                                  bool nonBlocking = false) 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,
                                        int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1,
                                        bool tcpNoDelay = true, bool keepAlive = false, bool nonBlocking = false) 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,
                                                          int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1,
                                                          bool tcpNoDelay = true, bool keepAlive = false,
                                                          bool nonBlocking = false) 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,
                                                  int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1,
                                                  bool tcpNoDelay = true, bool keepAlive = false,
                                                  bool nonBlocking = false) 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, int soRecvTimeoutMillis = -1,
                     int soSendTimeoutMillis = -1, bool tcpNoDelay = true, bool keepAlive = false,
                     bool nonBlocking = false) const;

    void close();

    [[nodiscard]] bool isValid() const noexcept { return getSocketFd() != INVALID_SOCKET; }

    [[nodiscard]] bool isClosed() const noexcept { return getSocketFd() == INVALID_SOCKET; }

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

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

    [[nodiscard]] int getSoTimeout() const noexcept { return _soTimeoutMillis; }

    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; }
 
  protected:
    void cleanup();

    void cleanupAndThrow(int errorCode);

    void cleanupAndRethrow();

    [[nodiscard]] bool isPassiveSocket() const noexcept override { return true; }
 
  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(const 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)};
    }
 
    internal::AddrinfoPtr _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