endpoint.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_ENDPOINT_HPP
#define JOIN_CORE_ENDPOINT_HPP
 
// libjoin.
#include <join/mac_address.hpp>
 
// C++.
#include <ostream>
 
// C.
#include <linux/if_packet.h>
#ifdef JOIN_HAS_XDP
#include <linux/if_xdp.h>
#endif
#include <sys/un.h>
#include <cstring>
 
namespace join
{
    template <class Protocol>
    class BasicEndpoint
    {
    public:
        constexpr BasicEndpoint () noexcept
        {
            this->_addr.ss_family = Protocol ().family ();
        }
 
        BasicEndpoint (const struct sockaddr* addr, socklen_t len) noexcept
        {
            memcpy (&this->_addr, addr, len);
        }
 
        struct sockaddr* addr () noexcept
        {
            return reinterpret_cast<struct sockaddr*> (&this->_addr);
        }
 
        const struct sockaddr* addr () const noexcept
        {
            return reinterpret_cast<const struct sockaddr*> (&this->_addr);
        }
 
    protected:
        struct sockaddr_storage _addr = {};
    };
 
    template <class Protocol>
    class BasicLinkLayerEndpoint : public BasicEndpoint<Protocol>
    {
    public:
        BasicLinkLayerEndpoint () noexcept
        : BasicEndpoint<Protocol> ()
        {
            reinterpret_cast<struct sockaddr_ll*> (&this->_addr)->sll_protocol = this->protocol ().protocol ();
        }
 
        BasicLinkLayerEndpoint (const struct sockaddr* addr, socklen_t len) noexcept
        : BasicEndpoint<Protocol> (addr, len)
        {
        }
 
        BasicLinkLayerEndpoint (const char* dev) noexcept
        : BasicEndpoint<Protocol> ()
        {
            reinterpret_cast<struct sockaddr_ll*> (&this->_addr)->sll_ifindex = if_nametoindex (dev);
        }
 
        BasicLinkLayerEndpoint (const std::string& dev) noexcept
        : BasicLinkLayerEndpoint<Protocol> (dev.c_str ())
        {
        }
 
        constexpr Protocol protocol () const noexcept
        {
            return Protocol ();
        }
 
        constexpr socklen_t length () const noexcept
        {
            return sizeof (struct sockaddr_ll);
        }
 
        void device (const std::string& dev) noexcept
        {
            reinterpret_cast<struct sockaddr_ll*> (&this->_addr)->sll_ifindex = if_nametoindex (dev.c_str ());
        }
 
        std::string device () const
        {
            char ifname[IFNAMSIZ];
            if (if_indextoname (reinterpret_cast<const struct sockaddr_ll*> (&this->_addr)->sll_ifindex, ifname))
            {
                return ifname;
            }
            return {};
        }
    };
 
    template <class Protocol>
    bool operator== (const BasicLinkLayerEndpoint<Protocol>& a, const BasicLinkLayerEndpoint<Protocol>& b) noexcept
    {
        return a.device () == b.device ();
    }
 
    template <class Protocol>
    bool operator!= (const BasicLinkLayerEndpoint<Protocol>& a, const BasicLinkLayerEndpoint<Protocol>& b) noexcept
    {
        return !(a == b);
    }
 
    template <class Protocol>
    bool operator< (const BasicLinkLayerEndpoint<Protocol>& a, const BasicLinkLayerEndpoint<Protocol>& b) noexcept
    {
        return a.device () < b.device ();
    }
 
    template <class Protocol>
    bool operator> (const BasicLinkLayerEndpoint<Protocol>& a, const BasicLinkLayerEndpoint<Protocol>& b) noexcept
    {
        return b < a;
    }
 
    template <class Protocol>
    bool operator<= (const BasicLinkLayerEndpoint<Protocol>& a, const BasicLinkLayerEndpoint<Protocol>& b) noexcept
    {
        return !(b < a);
    }
 
    template <class Protocol>
    bool operator>= (const BasicLinkLayerEndpoint<Protocol>& a, const BasicLinkLayerEndpoint<Protocol>& b) noexcept
    {
        return !(a < b);
    }
 
    template <class Protocol>
    std::ostream& operator<< (std::ostream& os, const BasicLinkLayerEndpoint<Protocol>& endpoint)
    {
        os << endpoint.device ();
        return os;
    }
 
#ifdef JOIN_HAS_XDP
    template <class Protocol>
    class BasicXdpEndpoint : public BasicEndpoint<Protocol>
    {
    public:
        BasicXdpEndpoint () noexcept
        : BasicEndpoint<Protocol> ()
        {
        }
 
        BasicXdpEndpoint (const struct sockaddr* addr, socklen_t len) noexcept
        : BasicEndpoint<Protocol> (addr, len)
        {
        }
 
        BasicXdpEndpoint (const char* dev, uint32_t queue = 0) noexcept
        : BasicXdpEndpoint ()
        {
            struct sockaddr_xdp* sa = reinterpret_cast<struct sockaddr_xdp*> (&this->_addr);
            sa->sxdp_ifindex = if_nametoindex (dev);
            sa->sxdp_queue_id = queue;
        }
 
        BasicXdpEndpoint (const std::string& dev, uint32_t queue = 0) noexcept
        : BasicXdpEndpoint<Protocol> (dev.c_str (), queue)
        {
        }
 
        constexpr Protocol protocol () const noexcept
        {
            return Protocol ();
        }
 
        constexpr socklen_t length () const noexcept
        {
            return sizeof (struct sockaddr_xdp);
        }
 
        void device (const std::string& dev) noexcept
        {
            reinterpret_cast<struct sockaddr_xdp*> (&this->_addr)->sxdp_ifindex = if_nametoindex (dev.c_str ());
        }
 
        std::string device () const
        {
            char ifname[IFNAMSIZ];
            if (if_indextoname (reinterpret_cast<const struct sockaddr_xdp*> (&this->_addr)->sxdp_ifindex, ifname))
            {
                return ifname;
            }
            return {};
        }
 
        void queue (uint32_t queue) noexcept
        {
            reinterpret_cast<struct sockaddr_xdp*> (&this->_addr)->sxdp_queue_id = queue;
        }
 
        uint32_t queue () const noexcept
        {
            return reinterpret_cast<const struct sockaddr_xdp*> (&this->_addr)->sxdp_queue_id;
        }
    };
 
    template <class Protocol>
    bool operator== (const BasicXdpEndpoint<Protocol>& a, const BasicXdpEndpoint<Protocol>& b) noexcept
    {
        return a.device () == b.device () && a.queue () == b.queue ();
    }
 
    template <class Protocol>
    bool operator!= (const BasicXdpEndpoint<Protocol>& a, const BasicXdpEndpoint<Protocol>& b) noexcept
    {
        return !(a == b);
    }
 
    template <class Protocol>
    bool operator< (const BasicXdpEndpoint<Protocol>& a, const BasicXdpEndpoint<Protocol>& b) noexcept
    {
        return std::make_tuple (a.device (), a.queue ()) < std::make_tuple (b.device (), b.queue ());
    }
 
    template <class Protocol>
    bool operator> (const BasicXdpEndpoint<Protocol>& a, const BasicXdpEndpoint<Protocol>& b) noexcept
    {
        return b < a;
    }
 
    template <class Protocol>
    bool operator<= (const BasicXdpEndpoint<Protocol>& a, const BasicXdpEndpoint<Protocol>& b) noexcept
    {
        return !(b < a);
    }
 
    template <class Protocol>
    bool operator>= (const BasicXdpEndpoint<Protocol>& a, const BasicXdpEndpoint<Protocol>& b) noexcept
    {
        return !(a < b);
    }
 
    template <class Protocol>
    std::ostream& operator<< (std::ostream& os, const BasicXdpEndpoint<Protocol>& endpoint)
    {
        os << endpoint.device () << ":" << endpoint.queue ();
        return os;
    }
#endif
 
    template <class Protocol>
    class BasicUnixEndpoint : public BasicEndpoint<Protocol>
    {
    public:
        constexpr BasicUnixEndpoint () noexcept
        : BasicEndpoint<Protocol> ()
        {
        }
 
        BasicUnixEndpoint (const struct sockaddr* addr, socklen_t len) noexcept
        : BasicEndpoint<Protocol> (addr, len)
        {
        }
 
        BasicUnixEndpoint (const char* dev) noexcept
        : BasicUnixEndpoint ()
        {
            struct sockaddr_un* sa = reinterpret_cast<struct sockaddr_un*> (&this->_addr);
            strncpy (sa->sun_path, dev, sizeof (sa->sun_path) - 1);
        }
 
        BasicUnixEndpoint (const std::string& dev) noexcept
        : BasicUnixEndpoint<Protocol> (dev.c_str ())
        {
        }
 
        constexpr Protocol protocol () const noexcept
        {
            return Protocol ();
        }
 
        constexpr socklen_t length () const noexcept
        {
            return sizeof (struct sockaddr_un);
        }
 
        void device (const std::string& dev) noexcept
        {
            struct sockaddr_un* sa = reinterpret_cast<struct sockaddr_un*> (&this->_addr);
            strncpy (sa->sun_path, dev.c_str (), sizeof (sa->sun_path) - 1);
        }
 
        std::string device () const
        {
            return reinterpret_cast<const struct sockaddr_un*> (&this->_addr)->sun_path;
        }
    };
 
    template <class Protocol>
    bool operator== (const BasicUnixEndpoint<Protocol>& a, const BasicUnixEndpoint<Protocol>& b) noexcept
    {
        return a.device () == b.device ();
    }
 
    template <class Protocol>
    bool operator!= (const BasicUnixEndpoint<Protocol>& a, const BasicUnixEndpoint<Protocol>& b) noexcept
    {
        return !(a == b);
    }
 
    template <class Protocol>
    bool operator< (const BasicUnixEndpoint<Protocol>& a, const BasicUnixEndpoint<Protocol>& b) noexcept
    {
        return a.device () < b.device ();
    }
 
    template <class Protocol>
    bool operator> (const BasicUnixEndpoint<Protocol>& a, const BasicUnixEndpoint<Protocol>& b) noexcept
    {
        return b < a;
    }
 
    template <class Protocol>
    bool operator<= (const BasicUnixEndpoint<Protocol>& a, const BasicUnixEndpoint<Protocol>& b) noexcept
    {
        return !(b < a);
    }
 
    template <class Protocol>
    bool operator>= (const BasicUnixEndpoint<Protocol>& a, const BasicUnixEndpoint<Protocol>& b) noexcept
    {
        return !(a < b);
    }
 
    template <class Protocol>
    std::ostream& operator<< (std::ostream& os, const BasicUnixEndpoint<Protocol>& endpoint)
    {
        os << endpoint.device ();
        return os;
    }
 
    template <class Protocol>
    class BasicInternetEndpoint : public BasicEndpoint<Protocol>
    {
    public:
        constexpr BasicInternetEndpoint () noexcept
        : BasicEndpoint<Protocol> ()
        {
        }
 
        BasicInternetEndpoint (const struct sockaddr* addr, socklen_t len) noexcept
        : BasicEndpoint<Protocol> (addr, len)
        {
        }
 
        BasicInternetEndpoint (const IpAddress& ip, uint16_t port = 0) noexcept
        : BasicEndpoint<Protocol> ()
        {
            if (ip.family () == AF_INET6)
            {
                struct sockaddr_in6* sa = reinterpret_cast<struct sockaddr_in6*> (&this->_addr);
                sa->sin6_family = AF_INET6;
                sa->sin6_port = htons (port);
                memcpy (&sa->sin6_addr, ip.addr (), ip.length ());
                sa->sin6_scope_id = ip.scope ();
            }
            else
            {
                struct sockaddr_in* sa = reinterpret_cast<struct sockaddr_in*> (&this->_addr);
                sa->sin_family = AF_INET;
                sa->sin_port = htons (port);
                memcpy (&sa->sin_addr, ip.addr (), ip.length ());
            }
        }
 
        BasicInternetEndpoint (const std::string& ip, uint16_t port = 0)
        : BasicInternetEndpoint<Protocol> (IpAddress (ip), port)
        {
        }
 
        BasicInternetEndpoint (const char* ip, uint16_t port = 0)
        : BasicInternetEndpoint<Protocol> (IpAddress (ip), port)
        {
        }
 
        BasicInternetEndpoint (const Protocol& protocol, uint16_t port = 0) noexcept
        : BasicEndpoint<Protocol> ()
        {
            if (protocol.family () == AF_INET6)
            {
                struct sockaddr_in6* sa = reinterpret_cast<struct sockaddr_in6*> (&this->_addr);
                sa->sin6_family = AF_INET6;
                sa->sin6_port = htons (port);
            }
            else
            {
                struct sockaddr_in* sa = reinterpret_cast<struct sockaddr_in*> (&this->_addr);
                sa->sin_family = AF_INET;
                sa->sin_port = htons (port);
            }
        }
 
        void hostname (const std::string& hostname) noexcept
        {
            _hostname = hostname;
        }
 
        const std::string& hostname () const noexcept
        {
            return _hostname;
        }
 
        void ip (const IpAddress& ip) noexcept
        {
            if (ip.family () == AF_INET6)
            {
                struct sockaddr_in6* sa = reinterpret_cast<struct sockaddr_in6*> (&this->_addr);
                sa->sin6_family = AF_INET6;
                memcpy (&sa->sin6_addr, ip.addr (), ip.length ());
                sa->sin6_scope_id = ip.scope ();
            }
            else
            {
                struct sockaddr_in* sa = reinterpret_cast<struct sockaddr_in*> (&this->_addr);
                sa->sin_family = AF_INET;
                memcpy (&sa->sin_addr, ip.addr (), ip.length ());
            }
        }
 
        IpAddress ip () const noexcept
        {
            return *reinterpret_cast<const struct sockaddr*> (&this->_addr);
        }
 
        void port (uint16_t p) noexcept
        {
            if (this->_addr.ss_family == AF_INET6)
            {
                reinterpret_cast<struct sockaddr_in6*> (&this->_addr)->sin6_port = htons (p);
            }
            else
            {
                reinterpret_cast<struct sockaddr_in*> (&this->_addr)->sin_port = htons (p);
            }
        }
 
        uint16_t port () const noexcept
        {
            if (this->_addr.ss_family == AF_INET6)
            {
                return ntohs (reinterpret_cast<const struct sockaddr_in6*> (&this->_addr)->sin6_port);
            }
            else
            {
                return ntohs (reinterpret_cast<const struct sockaddr_in*> (&this->_addr)->sin_port);
            }
        }
 
        Protocol protocol () const noexcept
        {
            if (this->_addr.ss_family == AF_INET)
            {
                return Protocol::v4 ();
            }
            return Protocol::v6 ();
        }
 
        socklen_t length () const noexcept
        {
            if (this->_addr.ss_family == AF_INET)
            {
                return sizeof (struct sockaddr_in);
            }
            return sizeof (struct sockaddr_in6);
        }
 
        void device (const std::string& dev) noexcept
        {
            if (this->_addr.ss_family == AF_INET6)
            {
                reinterpret_cast<struct sockaddr_in6*> (&this->_addr)->sin6_scope_id = if_nametoindex (dev.c_str ());
            }
        }
 
        std::string device () const
        {
            if (this->_addr.ss_family == AF_INET6)
            {
                char ifname[IFNAMSIZ];
                if (if_indextoname (reinterpret_cast<const struct sockaddr_in6*> (&this->_addr)->sin6_scope_id, ifname))
                {
                    return ifname;
                }
            }
            return {};
        }
 
    protected:
        std::string _hostname;
    };
 
    template <class Protocol>
    bool operator== (const BasicInternetEndpoint<Protocol>& a, const BasicInternetEndpoint<Protocol>& b) noexcept
    {
        return a.ip () == b.ip () && a.port () == b.port ();
    }
 
    template <class Protocol>
    bool operator!= (const BasicInternetEndpoint<Protocol>& a, const BasicInternetEndpoint<Protocol>& b) noexcept
    {
        return !(a == b);
    }
 
    template <class Protocol>
    bool operator< (const BasicInternetEndpoint<Protocol>& a, const BasicInternetEndpoint<Protocol>& b) noexcept
    {
        return std::tie (a.ip (), a.port ()) < std::tie (b.ip (), b.port ());
    }
 
    template <class Protocol>
    bool operator> (const BasicInternetEndpoint<Protocol>& a, const BasicInternetEndpoint<Protocol>& b) noexcept
    {
        return b < a;
    }
 
    template <class Protocol>
    bool operator<= (const BasicInternetEndpoint<Protocol>& a, const BasicInternetEndpoint<Protocol>& b) noexcept
    {
        return !(b < a);
    }
 
    template <class Protocol>
    bool operator>= (const BasicInternetEndpoint<Protocol>& a, const BasicInternetEndpoint<Protocol>& b) noexcept
    {
        return !(a < b);
    }
 
    template <class Protocol>
    std::ostream& operator<< (std::ostream& os, const BasicInternetEndpoint<Protocol>& endpoint)
    {
        if (endpoint.protocol () == Protocol::v6 ())
            os << "[" << endpoint.ip () << "]";
        else
            os << endpoint.ip ();
        if (endpoint.port ())
            os << ":" << endpoint.port ();
        return os;
    }
}
 
#endif