netlink_manager.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_NETLINK_MANAGER_HPP
#define JOIN_FABRIC_NETLINK_MANAGER_HPP
 
// libjoin.
#include <join/netlink_protocol.hpp>
#include <join/datagram_socket.hpp>
#include <join/condition.hpp>
#include <join/function.hpp>
#include <join/reactor.hpp>
 
// C++.
#include <unordered_map>
#include <system_error>
#include <memory>
#include <atomic>
 
// C.
#include <cstdint>
#include <cstddef>
 
namespace join
{
    class NetlinkManager : public EventHandler
    {
    public:
        NetlinkManager (uint32_t groups, Reactor& reactor = ReactorThread::reactor ());
 
        NetlinkManager (const NetlinkManager&) = delete;
 
        NetlinkManager (NetlinkManager&&) = delete;
 
        NetlinkManager& operator= (const NetlinkManager&) = delete;
 
        NetlinkManager& operator= (NetlinkManager&&) = delete;
 
        virtual ~NetlinkManager () = default;
 
        void start ();
 
        void stop ();
 
        Reactor& reactor () const noexcept;
 
    protected:
        int sendRequest (struct nlmsghdr* nlh, bool sync, std::chrono::milliseconds timeout = std::chrono::seconds (5));
 
        virtual void onReadable (int fd) override final;
 
        virtual void onMessage (struct nlmsghdr* nlh) = 0;
 
        void notifyRequest (uint32_t seq, const std::error_code& error = std::error_code ());
 
        void notifyAllRequests (const std::error_code& error);
 
        static void addAttributes (struct nlmsghdr* nlh, int type, const void* data, int alen);
 
        static struct rtattr* startNestedAttributes (struct nlmsghdr* nlh, int type);
 
        static int stopNestedAttributes (struct nlmsghdr* nlh, struct rtattr* nested);
 
        template <typename T, typename Flag>
        static Flag updateValue (T& oldVal, const T& newVal, Flag changed)
        {
            if (oldVal != newVal)
            {
                oldVal = newVal;
                return changed;
            }
            return static_cast<Flag> (0);
        }
 
        Netlink::Socket _socket;
 
        static constexpr int _rcvBufferSize = 1 << 20;
 
        std::unique_ptr<char[]> _buffer;
 
        std::atomic<uint32_t> _seq;
 
        struct PendingRequest
        {
            Condition cond;
            std::error_code error;
            bool done = false;
        };
 
        std::unordered_map<uint32_t, std::unique_ptr<PendingRequest>> _pending;
 
        Mutex _syncMutex;
 
        Reactor& _reactor;
    };
}
 
#endif