UnixAddress.hxx

#pragma once
 
// Linux
#include <sys/un.h>
 
// C++
#include <string_view>
 
// cosmos
#include <cosmos/dso_export.h>
#include <cosmos/net/SocketAddress.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
 
class COSMOS_API UnixAddress :
                public SocketAddress {
public: // types
 
        using Abstract = NamedBool<struct abstract_address_t, false>;
 
public: // functions
 
        UnixAddress() {
                m_addr.sun_family = to_integral(family());
                m_addr.sun_path[0] = '\0';
        }
 
        explicit UnixAddress(const std::string_view path, const Abstract abstract = Abstract{false}) :
                        UnixAddress{} {
                setPath(path, abstract);
        }
 
        SocketFamily family() const override {
                return SocketFamily::UNIX;
        }
 
        size_t size() const override {
                return BASE_SIZE + m_path_len + 1;
        }
 
        size_t maxSize() const override {
                return sizeof(m_addr);
        }
 
 
        size_t maxPathLen() const {
                return sizeof(m_addr) - BASE_SIZE - 1;
        }
 
 
        void setPath(const std::string_view path, const Abstract abstract = Abstract{false});
 
 
        std::string_view getPath() const {
                if (isAbstract()) {
                        return std::string_view{m_addr.sun_path + 1, m_path_len};
                } else {
                        return std::string_view{m_addr.sun_path, m_path_len};
                }
        }
 
 
        std::string label() const;
 
        bool isAbstract() const {
                return m_path_len > 1 && m_addr.sun_path[0] == '\0';
        }
 
        bool isUnnamed() const {
                return m_path_len == 0;
        }
 
        bool operator==(const UnixAddress &other) const {
                if (m_path_len != other.m_path_len)
                        return false;
                if (m_addr.sun_family != other.m_addr.sun_family)
                        return false;
 
                return std::memcmp(m_addr.sun_path, other.m_addr.sun_path, m_path_len + 1) == 0;
        }
 
        bool operator!=(const UnixAddress &other) const {
                return !(*this == other);
        }
 
protected: // functions
 
        void update(size_t new_length) override;
 
        sockaddr* basePtr() override {
                return reinterpret_cast<sockaddr*>(&m_addr);
        }
 
        const sockaddr* basePtr() const override {
                return reinterpret_cast<const sockaddr*>(&m_addr);
        }
 
protected: // data
 
        static constexpr size_t BASE_SIZE = offsetof(struct sockaddr_un, sun_path);
        sockaddr_un m_addr;
        size_t m_path_len = 0; 
};
 
} // end ns