endpoint.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_ENDPOINT_HPP__
#define __JOIN_ENDPOINT_HPP__
 
// libjoin.
#include <join/macaddress.hpp>
 
// C++.
#include <ostream>
#include <sstream>
 
// C.
#include <linux/netfilter/nfnetlink.h>
#include <linux/if_packet.h>
#include <linux/rtnetlink.h>
#include <linux/netlink.h>
#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 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 BasicNetlinkEndpoint : public BasicEndpoint <Protocol>
    {
    public:
        constexpr BasicNetlinkEndpoint () noexcept
        : BasicEndpoint <Protocol> ()
        , _protocol (Protocol ().protocol ())
        {
        }
 
        BasicNetlinkEndpoint (const struct sockaddr* addr, socklen_t len) noexcept
        : BasicEndpoint <Protocol> (addr, len)
        , _protocol (Protocol ().protocol ())
        {
        }
 
        BasicNetlinkEndpoint (const Protocol& protocol, uint32_t pid, uint32_t groups) noexcept
        : BasicEndpoint <Protocol> ()
        , _protocol (protocol.protocol ())
        {
            struct sockaddr_nl* nl = reinterpret_cast <struct sockaddr_nl*> (&this->_addr);
            nl->nl_pid = pid;
            nl->nl_groups = groups;
        }
 
        BasicNetlinkEndpoint (uint32_t pid, uint32_t groups) noexcept
        : BasicNetlinkEndpoint (Protocol (), pid, groups)
        {
        }
 
        BasicNetlinkEndpoint (const Protocol& protocol, uint32_t groups) noexcept
        : BasicNetlinkEndpoint (protocol, getpid (), groups)
        {
        }
 
        BasicNetlinkEndpoint (uint32_t groups) noexcept
        : BasicNetlinkEndpoint (Protocol (), getpid (), groups)
        {
        }
 
        Protocol protocol () const noexcept
        {
            if (_protocol == NETLINK_NETFILTER)
            {
                return Protocol::nf ();
            }
            return Protocol::rt ();
        }
 
        constexpr socklen_t length () const noexcept
        {
            return sizeof (struct sockaddr_nl);
        }
 
        void pid (uint32_t pid) noexcept
        {
            reinterpret_cast <struct sockaddr_nl*> (&this->_addr)->nl_pid = pid;
        }
 
        uint32_t pid () const noexcept
        {
            return reinterpret_cast <const struct sockaddr_nl*> (&this->_addr)->nl_pid;
        }
 
        void groups (uint32_t groups) noexcept
        {
            reinterpret_cast <struct sockaddr_nl*> (&this->_addr)->nl_groups = groups;
        }
 
        uint32_t groups () const noexcept
        {
            return reinterpret_cast <const struct sockaddr_nl*> (&this->_addr)->nl_groups;
        }
 
        std::string device () const
        {
            return std::string ();
        }
 
    protected:
        int _protocol;
    };
 
    template <class Protocol>
    bool operator== (const BasicNetlinkEndpoint <Protocol>& a, const BasicNetlinkEndpoint <Protocol>& b) noexcept
    {
        return a.pid () == b.pid () && a.groups () == b.groups ();
    }
 
    template <class Protocol>
    bool operator!= (const BasicNetlinkEndpoint <Protocol>& a, const BasicNetlinkEndpoint <Protocol>& b) noexcept
    {
        return !(a == b);
    }
 
    template <class Protocol>
    bool operator< (const BasicNetlinkEndpoint <Protocol>& a, const BasicNetlinkEndpoint <Protocol>& b) noexcept
    {
        if (a.pid () != b.pid ())
        {
            return a.pid () < b.pid ();
        }
        return a.groups () < b.groups ();
    }
 
    template <class Protocol>
    bool operator> (const BasicNetlinkEndpoint <Protocol>& a, const BasicNetlinkEndpoint <Protocol>& b) noexcept
    {
        return b < a;
    }
 
    template <class Protocol>
    bool operator<= (const BasicNetlinkEndpoint <Protocol>& a, const BasicNetlinkEndpoint <Protocol>& b) noexcept
    {
        return !(b < a);
    }
 
    template <class Protocol>
    bool operator>= (const BasicNetlinkEndpoint <Protocol>& a, const BasicNetlinkEndpoint <Protocol>& b) noexcept
    {
        return !(a < b);
    }
 
    template <class Protocol>
    std::ostream& operator<< (std::ostream& os, const BasicNetlinkEndpoint <Protocol>& endpoint)
    {
        os << "pid=" << endpoint.pid () << ",groups=" << endpoint.groups ();
        return os;
    }
 
    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;
    }
 
    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