UnixSocket.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "common.hpp"
 
#include <string_view>
 
// Enable AF_UNIX support on Windows 10+ (version 1803, build 17134) only
#if defined(_MSC_VER) && (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
// https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/
#include <afunix.h> // Windows 10+ AF_UNIX support
#define AF_UNIX 1
#endif
 
#include "common.hpp"
#include "SocketException.hpp"
#include "SocketOptions.hpp"
 
namespace jsocketpp
{
 
#if defined(_WIN32) && defined(AF_UNIX) || defined(__unix__) || defined(__APPLE__)

class UnixSocket : SocketOptions
{
  public:
    explicit UnixSocket(std::string_view path, std::size_t bufferSize = 512);

    UnixSocket(const UnixSocket&) = delete;

    UnixSocket& operator=(const UnixSocket&) = delete;

    UnixSocket(UnixSocket&& rhs) noexcept;

    UnixSocket& operator=(UnixSocket&& rhs) noexcept;

    ~UnixSocket() noexcept override;

    void bind();

    void listen(int backlog = SOMAXCONN) const;

    [[nodiscard]] UnixSocket accept() const;

    void connect();

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

    size_t read(char* buffer, std::size_t len) const;

    template <typename T> T read()
    {
        static_assert(std::is_trivially_copyable_v<T>, "UnixSocket::read<T>() only supports trivially copyable types");
        T value;
        const int len = ::recv(getSocketFd(), reinterpret_cast<char*>(&value),
#ifdef _WIN32
                               static_cast<int>(sizeof(T)),
#else
                               sizeof(T),
#endif
                               0);
        if (len == SOCKET_ERROR)
        {
            const int error = GetSocketError();
            throw SocketException(error, SocketErrorMessage(error));
        }
        if (len == 0)
            throw SocketException("Connection closed by remote socket.");
        return value;
    }

    void close();

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

    [[nodiscard]] std::string getSocketPath() const { return this->_socketPath; }

    void setNonBlocking(bool nonBlocking) const;

    void setTimeout(int millis) const;

    static bool isPathInUse(std::string_view path);
 
  protected:
    UnixSocket() : SocketOptions(INVALID_SOCKET), _internalBuffer(512) {}
 
  private:
    bool _isListening = false;         
    std::string _socketPath{};         
    SOCKADDR_UN _addr{};               
    std::vector<char> _internalBuffer; 
};

template <> inline std::string UnixSocket::read()
{
    const auto len = static_cast<int>(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 socket.");
    return {_internalBuffer.data(), static_cast<size_t>(len)};
}
 
#endif
 
} // namespace jsocketpp