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 "SocketException.hpp"
#include "common.hpp"
 
namespace jsocketpp
{
 
#if defined(_WIN32) && defined(AF_UNIX) || defined(__unix__) || defined(__APPLE__)

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

    UnixSocket(const UnixSocket&) = delete;

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

    UnixSocket(UnixSocket&& other) noexcept;

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

    ~UnixSocket() noexcept;

    void bind();

    void listen(int backlog = SOMAXCONN) const;

    UnixSocket accept() const;

    void connect();

    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(_sockFd, reinterpret_cast<char*>(&value),
#ifdef _WIN32
                               static_cast<int>(sizeof(T)),
#else
                               sizeof(T),
#endif
                               0);
        if (len == SOCKET_ERROR)
            throw SocketException(GetSocketError(), SocketErrorMessage(GetSocketError()));
        if (len == 0)
            throw SocketException(0, "Connection closed by remote socket.");
        return value;
    }

    void close();

    [[nodiscard]] bool isValid() const { return this->_sockFd != 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);

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

    [[nodiscard]] int getOption(int level, int optName) const;
 
  protected:
    UnixSocket() : _sockFd(INVALID_SOCKET), _socketPath(), _addr(), _buffer(512) {}
 
  private:
    SOCKET _sockFd = INVALID_SOCKET; 
    bool _isListening = false;       
    std::string _socketPath;         
    SOCKADDR_UN _addr{};             
    std::vector<char> _buffer;       
};

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