DatagramSocket.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "DatagramPacket.hpp"
#include "common.hpp"
 
#include <string>
 
namespace jsocketpp
{

class DatagramSocket
{
  public:
    explicit DatagramSocket(Port port, std::size_t bufferSize = 2048);

    DatagramSocket(std::string_view host, Port port, std::size_t bufferSize = 2048);

    ~DatagramSocket() noexcept;

    DatagramSocket(const DatagramSocket&) = delete;

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

    DatagramSocket(DatagramSocket&& other) noexcept
        : _sockFd(other._sockFd), _addrInfoPtr(other._addrInfoPtr), _selectedAddrInfo(other._selectedAddrInfo),
          _localAddr(other._localAddr), _localAddrLen(other._localAddrLen), _buffer(std::move(other._buffer)),
          _port(other._port)
    {
        other._sockFd = INVALID_SOCKET;
        other._addrInfoPtr = nullptr;
        other._selectedAddrInfo = nullptr;
        other._localAddrLen = 0;
        other._port = 0;
    }

    DatagramSocket& operator=(DatagramSocket&& other) noexcept
    {
        if (this != &other)
        {
            close();
            _sockFd = other._sockFd;
            _localAddr = other._localAddr;
            _localAddrLen = other._localAddrLen;
            _addrInfoPtr = other._addrInfoPtr;
            _selectedAddrInfo = other._selectedAddrInfo;
            _buffer = std::move(other._buffer);
            _port = other._port;
 
            other._sockFd = INVALID_SOCKET;
            other._addrInfoPtr = nullptr;
            other._selectedAddrInfo = nullptr;
            other._localAddrLen = 0;
            other._port = 0;
        }
        return *this;
    }

    void bind() const;

    void connect(int timeoutMillis = -1);

    [[nodiscard]] size_t write(const DatagramPacket& packet) const;

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

    [[nodiscard]] size_t write(std::string_view message, std::string_view host, Port port) const;

    [[nodiscard]] size_t read(DatagramPacket& packet, bool resizeBuffer = true) const;

    template <typename T> T read()
    {
        static_assert(std::is_trivially_copyable_v<T>,
                      "DatagramSocket::read<T>() only supports trivially copyable types");
 
        if (!_isConnected)
            throw SocketException(0, "DatagramSocket is not connected.");
 
        T value;
        const int n = ::recv(_sockFd, reinterpret_cast<char*>(&value), sizeof(T), 0);
 
        if (n == SOCKET_ERROR)
            throw SocketException(GetSocketError(), SocketErrorMessage(GetSocketError()));
        if (n == 0)
            throw SocketException(0, "Connection closed by remote host.");
        if (n != sizeof(T))
            throw SocketException(0, "Partial read: did not receive a complete T object.");
        return value;
    }

    template <typename T> T recvFrom(std::string* senderAddr, Port* senderPort)
    {
        static_assert(std::is_trivially_copyable_v<T>, "recvFrom<T>() only supports trivially copyable types");
 
        sockaddr_storage srcAddr{};
        socklen_t srcLen = sizeof(srcAddr);
        T value;
        const auto n = ::recvfrom(_sockFd, reinterpret_cast<char*>(&value), sizeof(T), 0,
                                  reinterpret_cast<sockaddr*>(&srcAddr), &srcLen);
        if (n == SOCKET_ERROR)
            throw SocketException(GetSocketError(), SocketErrorMessage(GetSocketError()));
        if (n == 0)
            throw SocketException(0, "Connection closed by remote host.");
 
        // Get sender's IP:port
        char hostBuf[NI_MAXHOST], portBuf[NI_MAXSERV];
        if (getnameinfo(reinterpret_cast<sockaddr*>(&srcAddr), srcLen, hostBuf, sizeof(hostBuf), portBuf,
                        sizeof(portBuf), NI_NUMERICHOST | NI_NUMERICSERV) == 0)
        {
            if (senderAddr)
                *senderAddr = hostBuf;
            if (senderPort)
                *senderPort = static_cast<Port>(std::stoul(portBuf));
        }
        else
        {
            if (senderAddr)
                senderAddr->clear();
            if (senderPort)
                *senderPort = 0;
        }
 
        return value;
    }

    void close();

    void setNonBlocking(bool nonBlocking) const;

    void setTimeout(int millis) const;

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

    [[nodiscard]] int getOption(int level, int optName) const;

    std::string getLocalSocketAddress() const;

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

    [[nodiscard]] bool isConnected() const { return this->_isConnected; }

    void enableBroadcast(bool enable) const;
 
  protected:
    void cleanupAndThrow(int errorCode);
 
    // Also required for MulticastSocket, hence protected.
    SOCKET _sockFd = INVALID_SOCKET;       
    addrinfo* _addrInfoPtr = nullptr;      
    addrinfo* _selectedAddrInfo = nullptr; 
 
  private:
    sockaddr_storage _localAddr{};       
    mutable socklen_t _localAddrLen = 0; 
    std::vector<char> _buffer;           
    Port _port;                          
    bool _isConnected = false;           
};

template <> inline std::string DatagramSocket::read<std::string>()
{
    if (!_isConnected)
        throw SocketException(0, "DatagramSocket is not connected.");
 
    _buffer.resize(_buffer.size()); // Ensure buffer is sized
    const auto n = ::recv(_sockFd, _buffer.data(),
#ifdef _WIN32
                          static_cast<int>(_buffer.size()),
#else
                          _buffer.size(),
#endif
                          0);
    if (n == SOCKET_ERROR)
        throw SocketException(GetSocketError(), SocketErrorMessage(GetSocketError()));
    if (n == 0)
        throw SocketException(0, "Connection closed by remote host.");
    return {_buffer.data(), static_cast<size_t>(n)};
}

template <> inline std::string DatagramSocket::recvFrom<std::string>(std::string* senderAddr, Port* senderPort)
{
    sockaddr_storage srcAddr{};
    socklen_t srcLen = sizeof(srcAddr);
    const auto n = ::recvfrom(_sockFd, _buffer.data(),
#ifdef _WIN32
                              static_cast<int>(_buffer.size()),
#else
                              _buffer.size(),
#endif
                              0, reinterpret_cast<sockaddr*>(&srcAddr), &srcLen);
    if (n == SOCKET_ERROR)
        throw SocketException(GetSocketError(), SocketErrorMessage(GetSocketError()));
    if (n == 0)
        throw SocketException(0, "Connection closed by remote host.");
 
    // Get sender's IP:port
    char hostBuf[NI_MAXHOST], portBuf[NI_MAXSERV];
    if (getnameinfo(reinterpret_cast<sockaddr*>(&srcAddr), srcLen, hostBuf, sizeof(hostBuf), portBuf, sizeof(portBuf),
                    NI_NUMERICHOST | NI_NUMERICSERV) == 0)
    {
        if (senderAddr)
            *senderAddr = hostBuf;
        if (senderPort)
            *senderPort = static_cast<Port>(std::stoul(portBuf));
    }
    else
    {
        if (senderAddr)
            senderAddr->clear();
        if (senderPort)
            *senderPort = 0;
    }
    return {_buffer.data(), static_cast<size_t>(n)};
}
 
} // namespace jsocketpp