Socket.hpp

Go to the documentation of this file.

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

class Socket
{
    friend class ServerSocket;
 
  protected:
    Socket(SOCKET client, const sockaddr_storage& addr, socklen_t len, std::size_t recvBufferSize,
           std::size_t sendBufferSize, std::size_t internalBufferSize);
 
  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);

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

    Socket(Socket&& rhs) noexcept
        : _sockFd(rhs._sockFd), _remoteAddr(rhs._remoteAddr), _remoteAddrLen(rhs._remoteAddrLen),
          _cliAddrInfo(rhs._cliAddrInfo), _selectedAddrInfo(rhs._selectedAddrInfo),
          _internalBuffer(std::move(rhs._internalBuffer))
    {
        rhs._sockFd = INVALID_SOCKET;
        rhs._cliAddrInfo = nullptr;
        rhs._selectedAddrInfo = nullptr;
    }

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

    Socket& operator=(Socket&& rhs) noexcept
    {
        if (this != &rhs)
        {
            if (this->_sockFd != INVALID_SOCKET)
            {
                if (CloseSocket(this->_sockFd))
                    std::cerr << "closesocket() failed: " << SocketErrorMessage(GetSocketError()) << ": "
                              << GetSocketError() << std::endl;
            }
            if (_cliAddrInfo)
            {
                freeaddrinfo(_cliAddrInfo);
                _cliAddrInfo = nullptr;
            }
            _sockFd = rhs._sockFd;
            _remoteAddr = rhs._remoteAddr;
            _remoteAddrLen = rhs._remoteAddrLen;
            _cliAddrInfo = rhs._cliAddrInfo;
            _selectedAddrInfo = rhs._selectedAddrInfo;
            _internalBuffer = std::move(rhs._internalBuffer);
            rhs._sockFd = INVALID_SOCKET;
            rhs._cliAddrInfo = nullptr;
            rhs._selectedAddrInfo = nullptr;
        }
        return *this;
    }

    ~Socket() noexcept;

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

    void connect(int timeoutMillis = -1) const;

    template <typename T> T read()
    {
        static_assert(std::is_trivially_copyable_v<T>, "Socket::read<T>() only supports trivially copyable types");
        T r;
        std::array<char, sizeof(T)> buffer;
        size_t totalRead = 0;
        size_t remaining = sizeof(T);
 
        while (remaining > 0)
        {
            const auto len = recv(this->_sockFd, buffer.data() + totalRead,
#ifdef _WIN32
                                  static_cast<int>(remaining),
#else
                                  remaining,
#endif
                                  0);
            if (len == SOCKET_ERROR)
                throw SocketException(GetSocketError(), SocketErrorMessage(GetSocketError()));
            if (len == 0)
                throw SocketException(0, "Connection closed by remote host.");
 
            totalRead += len;
            remaining -= len;
        }
        std::memcpy(&r, buffer.data(), sizeof(T));
        return r;
    }

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

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

    std::string readLine(const std::size_t maxLen = 8192, const bool includeDelimiter = true) const
    {
        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_trivially_copyable_v<T>,
                      "Prefix type must be a trivially copyable 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(0, "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]] size_t write(std::string_view message) const;

    size_t writeAll(std::string_view message) const;

    template <typename T> std::size_t writePrefixed(const std::string& 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();
 
        // 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(0, "writePrefixed: Payload size " + std::to_string(payloadSize) +
                                         " exceeds maximum encodable size for prefix type");
        }
 
        T len = net::toNetwork(static_cast<T>(payloadSize));
 
        // Write the length prefix
        const std::size_t prefixSent = writeAll(std::string_view(reinterpret_cast<const char*>(&len), sizeof(T)));
 
        // 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");
 
        if (!data && len > 0)
            throw SocketException(0, "writePrefixed: Null data pointer with non-zero length");
 
        if (len > static_cast<std::size_t>((std::numeric_limits<T>::max)()))
        {
            throw SocketException(0, "writePrefixed: Payload length exceeds capacity of prefix type");
        }
 
        T prefix = net::toNetwork(static_cast<T>(len));
 
        // Send prefix
        writeAll(std::string_view(reinterpret_cast<const char*>(&prefix), sizeof(T)));
 
        // Send payload
        if (len > 0)
        {
            writeAll(std::string_view(static_cast<const char*>(data), len));
        }
 
        return sizeof(T) + len;
    }

    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 setReceiveBufferSize(std::size_t size);

    void setSendBufferSize(std::size_t size);

    [[nodiscard]] int getReceiveBufferSize() const;

    [[nodiscard]] int getSendBufferSize() const;

    void setInternalBufferSize(std::size_t newLen);

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

    void setNonBlocking(bool nonBlocking) const;

    [[nodiscard]] bool getNonBlocking() const;

    void setSoTimeout(int millis, bool forRead = true, bool forWrite = true);

    bool waitReady(bool forWrite, int timeoutMillis) const;

    bool isConnected() const;

    void enableNoDelay(bool enable);

    void enableKeepAlive(bool enable);

    static std::string addressToString(const sockaddr_storage& addr);

    static void stringToAddress(const std::string& str, sockaddr_storage& addr);

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

    [[nodiscard]] int getOption(int level, int optName) const;
 
  protected:
    std::size_t readIntoInternal(void* buffer, std::size_t len, bool exact = false) const;

    void cleanupAndThrow(int errorCode);
 
  private:
    SOCKET _sockFd = INVALID_SOCKET; 
    sockaddr_storage _remoteAddr;    
    mutable socklen_t _remoteAddrLen = 0;  
    addrinfo* _cliAddrInfo = nullptr;      
    addrinfo* _selectedAddrInfo = nullptr; 
    std::vector<char> _internalBuffer;     
};

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