interfacemanager.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_INTERFACE_MANAGER_HPP__
#define __JOIN_INTERFACE_MANAGER_HPP__
 
// libjoin.
#include <join/macaddress.hpp>
#include <join/ipaddress.hpp>
#include <join/condition.hpp>
#include <join/interface.hpp>
#include <join/socket.hpp>
 
// C++.
#include <functional>
#include <string>
#include <memory>
#include <atomic>
#include <map>
 
// C.
#include <linux/rtnetlink.h>
#include <linux/netlink.h>
#include <cstdint>
#include <cstddef>
 
namespace join
{
    enum ChangeType
    {
        Added               = 1L << 0,
        Deleted             = 1L << 1,
        Modified            = 1L << 2,
        AdminStateChanged   = 1L << 3,
        OperStateChanged    = 1L << 4,
        MacChanged          = 1L << 5,
        NameChanged         = 1L << 6,
        MtuChanged          = 1L << 7,
        KindChanged         = 1L << 8,
        MasterChanged       = 1L << 9,
    };
 
    __inline__ ChangeType operator& (ChangeType __a, ChangeType __b)
    { return ChangeType (static_cast <int> (__a) & static_cast <int> (__b)); }
 
    __inline__ ChangeType operator| (ChangeType __a, ChangeType __b)
    { return ChangeType (static_cast <int> (__a) | static_cast <int> (__b)); }
 
    __inline__ ChangeType operator^ (ChangeType __a, ChangeType __b)
    { return ChangeType (static_cast <int> (__a) ^ static_cast <int> (__b)); }
 
    __inline__ ChangeType operator~ (ChangeType __a)
    { return ChangeType (~static_cast <int> (__a)); }
 
    __inline__ const ChangeType& operator&= (ChangeType& __a, ChangeType __b)
    { return __a = __a & __b; }
 
    __inline__ const ChangeType& operator|= (ChangeType& __a, ChangeType __b)
    { return __a = __a | __b; }
 
    __inline__ const ChangeType& operator^= (ChangeType& __a, ChangeType __b)
    { return __a = __a ^ __b; }
 
    struct LinkInfo
    {
        uint32_t index;                 
        ChangeType flags;               
    };
 
    struct AddressInfo : public LinkInfo
    {
        Interface::Address address;     
    };
 
    struct RouteInfo : public LinkInfo
    {
         Interface::Route route;        
    };
 
    class InterfaceManager : private Netlink::Socket
    {
    private:
        InterfaceManager ();
 
    public:
        using LinkNotify    = std::function <void (const LinkInfo& info)>;
        using AddressNotify = std::function <void (const AddressInfo& info)>;
        using RouteNotify   = std::function <void (const RouteInfo& info)>;
 
        InterfaceManager (const InterfaceManager& other) = delete;
 
        InterfaceManager (InterfaceManager&& other) = delete;
 
        InterfaceManager& operator= (const InterfaceManager& other) = delete;
 
        InterfaceManager& operator= (InterfaceManager&& other) = delete;
 
        ~InterfaceManager ();
 
        static InterfaceManager* instance ();
 
        Interface::Ptr findByIndex (uint32_t interfaceIndex);
 
        Interface::Ptr findByName (const std::string& interfaceName);
 
        InterfaceList enumerate ();
 
        int refresh (bool sync = true);
 
        void addLinkListener (const LinkNotify& cb);
 
        void removeLinkListener (const LinkNotify& cb);
 
        void addAddressListener (const AddressNotify& cb);
 
        void removeAddressListener (const AddressNotify& cb);
 
        void addRouteListener (const RouteNotify& cb);
 
        void removeRouteListener (const RouteNotify& cb);
 
        int createDummyInterface (const std::string& interfaceName, bool sync = false);
 
        int createBridgeInterface (const std::string& interfaceName, bool sync = false);
 
        int createVlanInterface (const std::string& interfaceName, uint32_t parentIndex, uint16_t id, uint16_t proto = ETH_P_8021Q, bool sync = false);
 
        int createVlanInterface (const std::string& interfaceName, const std::string& parentName, uint16_t id, uint16_t proto = ETH_P_8021Q, bool sync = false);
 
        int createVethInterface (const std::string& hostName, const std::string& peerName, pid_t* pid = nullptr, bool sync = false);
 
        int createGreInterface (const std::string& tunnelName, uint32_t parentIndex,
                                const IpAddress& localAddress, const IpAddress& remoteAddress,
                                const uint32_t* ikey = nullptr, const uint32_t* okey = nullptr, uint8_t ttl = 64, bool sync = false);
 
        int createGreInterface (const std::string& tunnelName, const std::string& parentName,
                                const IpAddress& localAddress, const IpAddress& remoteAddress,
                                const uint32_t* ikey = nullptr, const uint32_t* okey = nullptr, uint8_t ttl = 64, bool sync = false);
 
        int removeInterface (uint32_t interfaceIndex, bool sync = false);
 
        int removeInterface (const std::string& interfaceName, bool sync = false);
 
    private:
        template <typename T>
        ChangeType updateValue (T& oldVal, const T& newVal, ChangeType changed) const
        {
            if (oldVal != newVal)
            {
                oldVal = newVal;
                return changed;
            }
            return static_cast <ChangeType> (0);
        }
 
        void addAttributes (struct nlmsghdr *nlh, int type, const void *data, int alen);
 
        struct rtattr* startNestedAttributes (struct nlmsghdr *nlh, int type);
 
        int stopNestedAttributes (struct nlmsghdr *nlh, struct rtattr *nested);
 
        void addPeerInfoData (struct nlmsghdr *nlh, const std::string& peerName);
 
        int mtu (uint32_t interfaceIndex, uint32_t mtuBytes, bool sync = false);
 
        int mac (uint32_t interfaceIndex, const MacAddress& macAddress, bool sync = false);
 
        int addToBridge (uint32_t interfaceIndex, uint32_t masterIndex, bool sync = false);
 
        int removeFromBridge (uint32_t interfaceIndex, bool sync = false);
 
        int enable (uint32_t interfaceIndex, bool enabled = true, bool sync = false);
 
        int addAddress (uint32_t interfaceIndex, const IpAddress& ipAddress, uint32_t prefix, const IpAddress& broadcast = {}, bool sync = false);
 
        int removeAddress (uint32_t interfaceIndex, const IpAddress& ipAddress, uint32_t prefix, const IpAddress& broadcast = {}, bool sync = false);
 
        int addRoute (uint32_t interfaceIndex, const IpAddress& dest, uint32_t prefix, const IpAddress& gateway, uint32_t* metric = nullptr, bool sync = false);
 
        int removeRoute (uint32_t interfaceIndex, const IpAddress& dest, uint32_t prefix, const IpAddress& gateway, uint32_t* metric = nullptr, bool sync = false);
 
        int dumpLink (bool sync = false);
 
        int dumpAddress (bool sync = false);
 
        int dumpRoute (bool sync = false);
 
        int sendRequest (struct nlmsghdr* nlh, bool sync);
 
        int waitResponse (ScopedLock <Mutex>& lock, uint32_t seq, uint32_t timeout = 5000);
 
        virtual void onReceive () override;
 
        void onLinkMessage (struct nlmsghdr* nlh);
 
        void onLinkInfoMessage (Interface::Ptr& iface, struct rtattr* rta, ChangeType& flags);
 
        void onAddressMessage (struct nlmsghdr* nlh);
 
        void onRouteMessage (struct nlmsghdr* nlh);
 
        void notifyRequest (uint32_t seq, int error = 0);
 
        void notifyLinkUpdate (const LinkInfo& info);
 
        void notifyAddressUpdate (const AddressInfo& info);
 
        void notifyRouteUpdate (const RouteInfo& info);
 
        Interface::Ptr acquire (LinkInfo& info);
 
        static constexpr size_t _bufferSize = 4096;
 
        std::unique_ptr <char []> _buffer;
 
        static constexpr uint16_t reservedVlanId = 0;
 
        static constexpr uint16_t maxVlanId = 4094;
 
        std::map <uint32_t, Interface::Ptr> _interfaces;
 
        Mutex _ifMutex;
 
        std::atomic<uint32_t> _seq;
 
        struct PendingRequest
        {
            Condition cond;
            int error = 0;
        };
 
        std::map <uint32_t, std::shared_ptr <PendingRequest>> _pending;
 
        Mutex _syncMutex;
 
        std::vector <LinkNotify> _linkListeners;
 
        Mutex _linkMutex;
 
        std::vector <AddressNotify> _addressListeners;
 
        Mutex _addressMutex;
 
        std::vector <RouteNotify> _routeListeners;
 
        Mutex _routeMutex;
 
        // friendship with interface.
        friend class Interface;
    };
}
 
#endif