netlink_endpoint.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_NETLINK_ENDPOINT_HPP
#define JOIN_FABRIC_NETLINK_ENDPOINT_HPP
 
// libjoin.
#include <join/endpoint.hpp>
 
// C.
#include <linux/netfilter/nfnetlink.h>
#include <linux/rtnetlink.h>
#include <linux/netlink.h>
 
namespace join
{
    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, 0, groups)
        {
        }
 
        BasicNetlinkEndpoint (uint32_t groups) noexcept
        : BasicNetlinkEndpoint (Protocol (), 0, 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>
    std::strong_ordering operator<=> (const BasicNetlinkEndpoint<Protocol>& a,
                                      const BasicNetlinkEndpoint<Protocol>& b) noexcept
    {
        if (auto cmp = a.pid () <=> b.pid (); cmp != 0)
        {
            return cmp;
        }
        return a.groups () <=> b.groups ();
    }
 
    template <class Protocol>
    std::ostream& operator<< (std::ostream& os, const BasicNetlinkEndpoint<Protocol>& endpoint)
    {
        os << "pid=" << endpoint.pid () << ",groups=" << endpoint.groups ();
        return os;
    }
}
 
#endif