Socket.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "BufferView.hpp"
#include "common.hpp"
#include "SocketException.hpp"
#include "SocketOptions.hpp"
 
#include <array>
#include <bit>
#include <limits>
#include <optional>
#include <span>
#include <string_view>
#include <type_traits>
#include <vector>
 
using jsocketpp::DefaultBufferSize;
 
namespace jsocketpp
{

class Socket : public SocketOptions
{
    friend class ServerSocket;
 
  protected:
    Socket(SOCKET client, const sockaddr_storage& addr, socklen_t len, std::size_t recvBufferSize = DefaultBufferSize,
           std::size_t sendBufferSize = DefaultBufferSize, std::size_t internalBufferSize = DefaultBufferSize,
           int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1, bool tcpNoDelay = true, bool keepAlive = false,
           bool nonBlocking = false);
 
  public:
    Socket() = delete;

    Socket(std::string_view host, Port port, std::optional<std::size_t> recvBufferSize = std::nullopt,
           std::optional<std::size_t> sendBufferSize = std::nullopt,
           std::optional<std::size_t> internalBufferSize = std::nullopt, bool reuseAddress = true,
           int soRecvTimeoutMillis = -1, int soSendTimeoutMillis = -1, bool dualStack = true, bool tcpNoDelay = true,
           bool keepAlive = false, bool nonBlocking = false, bool autoConnect = true, bool autoBind = false,
           std::string_view localAddress = "", Port localPort = 0);

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

    Socket(Socket&& rhs) noexcept
        : SocketOptions(rhs.getSocketFd()), _remoteAddr(rhs._remoteAddr), _remoteAddrLen(rhs._remoteAddrLen),
          _cliAddrInfo(std::move(rhs._cliAddrInfo)), _selectedAddrInfo(rhs._selectedAddrInfo),
          _internalBuffer(std::move(rhs._internalBuffer)), _isBound(rhs._isBound), _isConnected(rhs._isConnected),
          _inputShutdown(rhs._inputShutdown), _outputShutdown(rhs._outputShutdown)
    {
        rhs.setSocketFd(INVALID_SOCKET);
        rhs._selectedAddrInfo = nullptr;
        rhs._isBound = false;
        rhs._isConnected = false;
        rhs.resetShutdownFlags();
    }

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

    Socket& operator=(Socket&& rhs) noexcept
    {
        if (this != &rhs)
        {
            // Clean up current socket
            try
            {
                close(); // Clean up existing resources
            }
            catch (...)
            {
            }
 
            // Transfer ownership
            setSocketFd(rhs.getSocketFd());
            _remoteAddr = rhs._remoteAddr;
            _remoteAddrLen = rhs._remoteAddrLen;
            _cliAddrInfo = std::move(rhs._cliAddrInfo);
            _selectedAddrInfo = rhs._selectedAddrInfo;
            _internalBuffer = std::move(rhs._internalBuffer);
            _isBound = rhs._isBound;
            _isConnected = rhs._isConnected;
            _inputShutdown = rhs._inputShutdown;
            _outputShutdown = rhs._outputShutdown;
 
            // Reset source
            rhs.setSocketFd(INVALID_SOCKET);
            rhs._selectedAddrInfo = nullptr;
            rhs._isBound = false;
            rhs._isConnected = false;
            rhs.resetShutdownFlags();
        }
        return *this;
    }

    ~Socket() noexcept override;

    void bind(std::string_view localHost, Port port);

    void bind(Port port);

    void bind();

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

    [[nodiscard]] bool isConnected() const noexcept { return _isConnected; }

    [[nodiscard]] std::string getLocalIp(bool convertIPv4Mapped = true) const;

    [[nodiscard]] Port getLocalPort() const;

    [[nodiscard]] std::string getLocalSocketAddress(bool convertIPv4Mapped = true) const;

    [[nodiscard]] std::string getRemoteIp(bool convertIPv4Mapped = true) const;

    [[nodiscard]] Port getRemotePort() const;

    [[nodiscard]] std::string getRemoteSocketAddress(bool convertIPv4Mapped = true) const;

    void connect(int timeoutMillis = -1);

    template <typename T> [[nodiscard]] T read()
    {
        static_assert(std::is_trivially_copyable_v<T>, "Socket::read<T>() requires a trivially copyable type");
        static_assert(std::is_standard_layout_v<T>, "Socket::read<T>() requires a standard layout type");
 
        std::array<std::byte, sizeof(T)> buffer{};
        std::size_t totalRead = 0;
        std::size_t remaining = sizeof(T);
 
        while (remaining > 0)
        {
            const auto len = ::recv(getSocketFd(), reinterpret_cast<char*>(buffer.data()) + totalRead,
#ifdef _WIN32
                                    static_cast<int>(remaining),
#else
                                    remaining,
#endif
                                    0);
 
            if (len == SOCKET_ERROR)
            {
                const int error = GetSocketError();
                throw SocketException(error, SocketErrorMessage(error));
            }
 
            if (len == 0)
                throw SocketException("Connection closed by remote host before full object was received.");
 
            totalRead += static_cast<std::size_t>(len);
            remaining -= static_cast<std::size_t>(len);
        }
 
        return std::bit_cast<T>(buffer);
    }

    std::string readExact(std::size_t n) const;

    std::string readUntil(char delimiter, std::size_t maxLen = 8192, bool includeDelimiter = true);

    std::string readLine(const std::size_t maxLen = 8192, const bool includeDelimiter = true)
    {
        return readUntil('\n', maxLen, includeDelimiter);
    }

    std::string readAtMost(std::size_t n) const;

    std::size_t readInto(void* buffer, const std::size_t len) const { return readIntoInternal(buffer, len, false); }

    std::size_t readIntoExact(void* buffer, const std::size_t len) const { return readIntoInternal(buffer, len, true); }

    std::string readAtMostWithTimeout(std::size_t n, int timeoutMillis) const;

    template <typename T> std::string readPrefixed()
    {
        static_assert(std::is_integral_v<T> && std::is_unsigned_v<T> && std::is_trivially_copyable_v<T>,
                      "Prefix type must be a trivially copyable unsigned integral type");
 
        T netLen = read<T>();
        T length = net::fromNetwork(netLen);
        return readExact(static_cast<std::size_t>(length));
    }

    template <typename T> std::string readPrefixed(const std::size_t maxPayloadLen)
    {
        static_assert(std::is_integral_v<T> && std::is_trivially_copyable_v<T>,
                      "Prefix type must be a trivially copyable integral type");
 
        T netLen = read<T>();
        T length = net::fromNetwork(netLen);
 
        const auto payloadLen = static_cast<std::size_t>(length);
        if (payloadLen > maxPayloadLen)
        {
            throw SocketException("readPrefixed: Prefix length " + std::to_string(payloadLen) +
                                  " exceeds maximum allowed payload length of " + std::to_string(maxPayloadLen));
        }
 
        return readExact(payloadLen);
    }

    std::string readAvailable() const;

    std::size_t readIntoAvailable(void* buffer, std::size_t bufferSize) const;

    std::size_t readv(std::span<BufferView> buffers) const;

    std::size_t readvAll(std::span<BufferView> buffers) const;

    std::size_t readvAllWithTotalTimeout(std::span<BufferView> buffers, int timeoutMillis) const;

    std::size_t readvAtMostWithTimeout(std::span<BufferView> buffers, int timeoutMillis) const;

    std::string peek(std::size_t n) const;

    void discard(std::size_t n, std::size_t chunkSize = 1024) const;

    void close();

    void shutdown(ShutdownMode how) const;

    [[nodiscard]] std::size_t write(std::string_view message) const;

    std::size_t writeAll(std::string_view message) const;

    template <typename T> std::size_t writePrefixed(const std::string_view payload)
    {
        static_assert(std::is_integral_v<T> && std::is_trivially_copyable_v<T>,
                      "Prefix type must be a trivially copyable integral type");
 
        const std::size_t payloadSize = payload.size();
 
        // Guard against overflows: ensure payload fits in the prefix type
        // Note: Put parentheses around the `max` function name due to a collision with
        // a macro defined in windows.h. See:
        // https://stackoverflow.com/a/13420838/3049315
        // Another alternative would be to define `NOMINMAX` before including windows.h
        // such as in CMake when compiling the target library
        if (payloadSize > static_cast<std::size_t>((std::numeric_limits<T>::max)()))
        {
            throw SocketException("writePrefixed: Payload size " + std::to_string(payloadSize) +
                                  " exceeds maximum encodable size for prefix type");
        }
 
        // Convert the length to network byte order
        T len = net::toNetwork(static_cast<T>(payloadSize));
 
        // Copy the prefix value into a properly aligned buffer to avoid UB
        std::array<char, sizeof(T)> prefixBuffer{};
        std::memcpy(prefixBuffer.data(), &len, sizeof(T));
        const std::string_view prefixView(prefixBuffer.data(), sizeof(T));
 
        // Write the length prefix
        const std::size_t prefixSent = writeAll(prefixView);
 
        // Then write the payload
        const std::size_t dataSent = writeAll(payload);
 
        return prefixSent + dataSent;
    }

    template <typename T> std::size_t writePrefixed(const void* data, std::size_t len) const
    {
        static_assert(std::is_integral_v<T> && std::is_trivially_copyable_v<T>,
                      "Prefix type must be a trivially copyable integral type");
 
        // Check for null pointer with non-zero length
        if (!data && len > 0)
        {
            throw SocketException("writePrefixed: Null data pointer with non-zero length");
        }
 
        // Ensure the payload length fits in the prefix type
        if (len > static_cast<std::size_t>((std::numeric_limits<T>::max)()))
        {
            throw SocketException("writePrefixed: Payload length " + std::to_string(len) +
                                  " exceeds capacity of prefix type (" +
                                  std::to_string((std::numeric_limits<T>::max)()) + ")");
        }
 
        // Encode prefix in network byte order
        T prefix = net::toNetwork(static_cast<T>(len));
 
        // Use aligned buffer to avoid undefined behavior when casting to char*
        std::array<char, sizeof(T)> prefixBuffer{};
        std::memcpy(prefixBuffer.data(), &prefix, sizeof(T));
        const std::string_view prefixView(prefixBuffer.data(), sizeof(T));
 
        // Send prefix
        const std::size_t prefixSent = writeAll(prefixView);
 
        // Send payload if any
        std::size_t payloadSent = 0;
        if (len > 0)
        {
            payloadSent = writeAll(std::string_view(static_cast<const char*>(data), len));
        }
 
        return prefixSent + payloadSent;
    }

    std::size_t writev(std::span<const std::string_view> buffers) const;

    std::size_t writevAll(std::span<const std::string_view> buffers) const;

    std::size_t writeAtMostWithTimeout(std::string_view data, int timeoutMillis) const;

    std::size_t writeFrom(const void* data, std::size_t len) const;

    std::size_t writeFromAll(const void* data, std::size_t len) const;

    std::size_t writeWithTotalTimeout(std::string_view data, int timeoutMillis) const;

    std::size_t writevWithTotalTimeout(std::span<const std::string_view> buffers, int timeoutMillis) const;

    std::size_t writevFrom(std::span<const BufferView> buffers) const;

    std::size_t writevFromAll(std::span<BufferView> buffers) const;

    std::size_t writevFromWithTotalTimeout(std::span<BufferView> buffers, int timeoutMillis) const;

    void setInternalBufferSize(std::size_t newLen);

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

    bool waitReady(bool forWrite, int timeoutMillis) const;

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

    [[nodiscard]] bool isInputShutdown() const noexcept { return _inputShutdown; }

    [[nodiscard]] bool isOutputShutdown() const noexcept { return _outputShutdown; }
 
  protected:
    std::size_t readIntoInternal(void* buffer, std::size_t len, bool exact = false) const;

    void cleanup();

    void cleanupAndThrow(int errorCode);

    void cleanupAndRethrow();

    void resetShutdownFlags() noexcept
    {
        _inputShutdown = false;
        _outputShutdown = false;
    }
 
  private:
    sockaddr_storage _remoteAddr; 
    mutable socklen_t _remoteAddrLen = 0;         
    internal::AddrinfoPtr _cliAddrInfo = nullptr; 
    addrinfo* _selectedAddrInfo = nullptr;        
    std::vector<char> _internalBuffer;            
    bool _isBound = false;                        
    bool _isConnected = false;                    
    bool _inputShutdown = false;                  
    bool _outputShutdown = false;                 
};

template <> inline std::string Socket::read()
{
    const auto len = recv(getSocketFd(), _internalBuffer.data(),
#ifdef _WIN32
                          static_cast<int>(_internalBuffer.size()),
#else
                          _internalBuffer.size(),
#endif
                          0);
    if (len == SOCKET_ERROR)
    {
        const int error = GetSocketError();
        throw SocketException(error, SocketErrorMessage(error));
    }
 
    if (len == 0)
        throw SocketException("Connection closed by remote host.");
    return {_internalBuffer.data(), static_cast<size_t>(len)};
}
 
} // namespace jsocketpp