CSocketAddress.hpp

Go to the documentation of this file.

#ifndef LIBS_COMM_CSOCKETADDRESS_HPP_
#define LIBS_COMM_CSOCKETADDRESS_HPP_
 
#include "comms/socket/ENetPort.hpp"
#include "core/defines.hpp"
 
#include <cstring>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <sys/un.h>
 
namespace iv::comms::socket
{
 
template<typename T>
class SocketAddress
{
protected:
    std::unique_ptr<T> m_sockaddr;
    sa_family_t m_family;
    std::string m_address;
    uint16_t m_port;
 
public:
    SocketAddress(std::string_view address, uint16_t port)
    {
        m_sockaddr = std::make_unique<T>();
        m_address = address;
        m_port = port;
 
        if constexpr (std::is_same<T, sockaddr_in>::value)
        {
            m_sockaddr->sin_family = AF_INET;
            m_sockaddr->sin_port = htons(port);
            if (inet_pton(AF_INET, address, &m_sockaddr->sin_addr) <= 0)
            {
                throw std::runtime_error("Invalid address");
            }
        }
        else if constexpr (std::is_same<T, sockaddr_in6>::value)
        {
            m_sockaddr->sin6_family = AF_INET6;
            m_sockaddr->sin6_port = htons(port);
            if (inet_pton(AF_INET6, address, &m_sockaddr->sin6_addr) <= 0)
            {
                throw std::runtime_error("Invalid address");
            }
        }
        else
        {
            throw std::runtime_error("Invalid address family");
        }
    }
 
    ~SocketAddress() = default;
 
    [[nodiscard]] sockaddr *getSocketAddress() const
    {
        return reinterpret_cast<sockaddr *>(m_sockaddr.get());
    }
 
    [[nodiscard]] std::string getAdresss() const
    {
        return m_address;
    }
 
    [[nodiscard]] uint16_t getPort() const
    {
        return m_port;
    }
 
    [[nodiscard]] socklen_t size() const
    {
        return sizeof(*m_sockaddr);
    }
 
    [[nodiscard]] sa_family_t getFamily() const
    {
        return m_family;
    }
};
 
using IPv4Address = SocketAddress<sockaddr_in>;
using IPv6Address = SocketAddress<sockaddr_in6>;
 
}// namespace iv::comms::socket
 
// TODO: Rename to AbstractSocketAddress
class CSocketAddress
{
public:
    virtual ~CSocketAddress() = default;
    [[nodiscard]] virtual socklen_t size() const = 0;
 
    virtual sockaddr *getSocketAddress() = 0;
    [[nodiscard]] const virtual sockaddr *getSocketAddress() const = 0;
 
    [[nodiscard]] virtual sa_family_t getFamily() const
    {
        auto p = getSocketAddress();
        return p ? p->sa_family : AF_UNSPEC;
    }
};
 
class CSocketAddressAny : public CSocketAddress
{
public:
    CSocketAddressAny() = default;
 
    CSocketAddressAny(const sockaddr *address, socklen_t size)
    {
        if (size > kPrvMaxSize)
        {
            throw std::length_error("Address length out of range");
        }
 
        std::memcpy(&m_address, address, m_size = size);
    }
 
    CSocketAddressAny(const sockaddr_storage &address, socklen_t size)
    {
        if (size > kPrvMaxSize)
        {
            throw std::length_error("Address length out of range");
        }
 
        std::memcpy(&m_address, &address, m_size = size);
    }
 
    [[nodiscard]] socklen_t size() const override
    {
        return m_size;
    }
 
    sockaddr *getSocketAddress() override
    {
        return reinterpret_cast<sockaddr *>(&m_address);
    }
 
    [[nodiscard]] const sockaddr *getSocketAddress() const override
    {
        return reinterpret_cast<const sockaddr *>(&m_address);
    }
 
private:
    sockaddr_storage m_address {};
    socklen_t m_size {kPrvMaxSize};
 
    static constexpr size_t kPrvMaxSize = sizeof(sockaddr_storage);
};
 
class CIpV4Address final : public CSocketAddress
{
public:
    static constexpr sa_family_t ADDRESS_FAMILY = AF_INET;
 
    CIpV4Address() = default;
 
    explicit CIpV4Address(in_port_t port)
    {
        create(in_addr_t(INADDR_ANY), port);
    }
 
    CIpV4Address(in_addr_t address, in_port_t port)
    {
        create(address, port);
    }
 
    CIpV4Address(const iv::types::ipAddress &address, in_port_t port)
    {
        create(address, port);
    }
 
    explicit CIpV4Address(const sockaddr &address)
    {
        std::memcpy(&m_address, &address, kSizeAddressStruct);
    }
 
    explicit CIpV4Address(const CSocketAddress &address)
    {
        std::memcpy(&m_address, address.getSocketAddress(), kSizeAddressStruct);
    }
 
    explicit CIpV4Address(const sockaddr_in &address) : m_address(address)
    {
    }
 
    CIpV4Address(const CIpV4Address &address) : m_address(address.m_address)
    {
    }
 
    uint8_t operator[](int32_t i) const
    {
        in_addr_t addr = getAddress();
 
        return ((const uint8_t *) &addr)[i];
    }
 
    void create(in_addr_t address, in_port_t port);
    void create(const iv::types::ipAddress &address, in_port_t port);
 
    [[nodiscard]] std::string ip() const
    {
        return inet_ntoa(m_address.sin_addr);
    }
 
    static in_addr_t resolveName(const iv::types::ipAddress &address);
    [[nodiscard]] std::string toString() const;
 
    [[nodiscard]] in_addr_t getAddress() const
    {
        return ntohl(m_address.sin_addr.s_addr);
    }
 
    [[nodiscard]] in_port_t getPort() const
    {
        return ntohs(m_address.sin_port);
    }
 
    [[nodiscard]] socklen_t size() const override
    {
        return socklen_t(kSizeAddressStruct);
    }
 
    sockaddr *getSocketAddress() override
    {
        return reinterpret_cast<sockaddr *>(&m_address);
    }
 
    [[nodiscard]] const sockaddr *getSocketAddress() const override
    {
        return reinterpret_cast<const sockaddr *>(&m_address);
    }
 
    sockaddr_in *getSocketAddressIn()
    {
        return static_cast<sockaddr_in *>(&m_address);
    }
 
    [[nodiscard]] const sockaddr_in *getSocketAddressIn() const
    {
        return static_cast<const sockaddr_in *>(&m_address);
    }
 
    [[nodiscard]] bool isSet() const;
 
private:
    sockaddr_in m_address {};
 
    static constexpr size_t kSizeAddressStruct = sizeof(sockaddr_in);
};
 
class CIpV6Address : public CSocketAddress
{
public:
    static constexpr sa_family_t ADDRESS_FAMILY = AF_INET6;
 
    CIpV6Address() : m_address()
    {
    }
 
    explicit CIpV6Address(in_port_t port)
    {
        const in6_addr ANY IN6ADDR_ANY_INIT;
 
        create(ANY, port);
    }
 
    CIpV6Address(const std::string &address, in_port_t port)
    {
        create(address, port);
    }
 
    explicit CIpV6Address(const sockaddr_storage &address)
    {
        std::memcpy(&m_address, &address, kSizeAddressStruct);
    }
 
    explicit CIpV6Address(const CSocketAddress &address)
    {
        std::memcpy(&m_address, address.getSocketAddress(), kSizeAddressStruct);
    }
 
    explicit CIpV6Address(const sockaddr_in6 &address)
    {
        std::memcpy(&m_address, &address, kSizeAddressStruct);
    }
 
    CIpV6Address(const CIpV6Address &address) : m_address(address.m_address)
    {
    }
 
    uint8_t operator[](int32_t i) const
    {
        return m_address.sin6_addr.s6_addr[i];
    }
 
    void create(const in6_addr &address, in_port_t port);
    void create(const std::string &address, in_port_t port);
 
    static CIpV6Address loopBack(in_port_t port)
    {
        const in6_addr LOOPBACK IN6ADDR_LOOPBACK_INIT;
        CIpV6Address addr;
 
        addr.create(LOOPBACK, port);
 
        return addr;
    }
 
    static in6_addr resolveName(const std::string &address);
 
    [[nodiscard]] std::string toString() const;
 
    [[nodiscard]] in6_addr getAddress() const
    {
        return m_address.sin6_addr;
    }
 
    [[nodiscard]] in_port_t getPort() const
    {
        return ntohs(m_address.sin6_port);
    }
 
    [[nodiscard]] socklen_t size() const override
    {
        return socklen_t(kSizeAddressStruct);
    }
 
    [[nodiscard]] const sockaddr *getSocketAddress() const override
    {
        return reinterpret_cast<const sockaddr *>(&m_address);
    }
 
    sockaddr *getSocketAddress() override
    {
        return reinterpret_cast<sockaddr *>(&m_address);
    }
 
    [[nodiscard]] const sockaddr_in6 *getSocketAddressIn6() const
    {
        return &m_address;
    }
 
    sockaddr_in6 *getSocketAddressIn6()
    {
        return &m_address;
    }
 
    [[nodiscard]] bool isSet() const;
 
private:
    sockaddr_in6 m_address {};
 
    static constexpr size_t kSizeAddressStruct = sizeof(sockaddr_in6);
};
 
std::ostream &operator<<(std::ostream &os, const CIpV4Address &address);
std::ostream &operator<<(std::ostream &os, const CIpV6Address &address);
 
#endif /* LIBS_COMM_CSOCKETADDRESS_HPP_ */