interfacemanager.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_INTERFACEMANAGER_HPP
#define JOIN_FABRIC_INTERFACEMANAGER_HPP
 
// libjoin.
#include <join/netlinkmanager.hpp>
#include <join/macaddress.hpp>
#include <join/ipaddress.hpp>
#include <join/interface.hpp>
 
// C++.
#include <functional>
#include <string>
 
namespace join
{
    enum class InterfaceChangeType : uint32_t
    {
        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 InterfaceChangeType operator& (InterfaceChangeType a, InterfaceChangeType b)
    {
        return InterfaceChangeType (static_cast<uint32_t> (a) & static_cast<uint32_t> (b));
    }
 
    inline InterfaceChangeType operator| (InterfaceChangeType a, InterfaceChangeType b)
    {
        return InterfaceChangeType (static_cast<uint32_t> (a) | static_cast<uint32_t> (b));
    }
 
    inline InterfaceChangeType operator^ (InterfaceChangeType a, InterfaceChangeType b)
    {
        return InterfaceChangeType (static_cast<uint32_t> (a) ^ static_cast<uint32_t> (b));
    }
 
    inline InterfaceChangeType operator~(InterfaceChangeType a)
    {
        return InterfaceChangeType (~static_cast<uint32_t> (a));
    }
 
    inline const InterfaceChangeType& operator&= (InterfaceChangeType& a, InterfaceChangeType b)
    {
        return a = a & b;
    }
 
    inline const InterfaceChangeType& operator|= (InterfaceChangeType& a, InterfaceChangeType b)
    {
        return a = a | b;
    }
 
    inline const InterfaceChangeType& operator^= (InterfaceChangeType& a, InterfaceChangeType b)
    {
        return a = a ^ b;
    }
 
    struct LinkInfo
    {
        Interface::Ptr interface;  
        InterfaceChangeType flags; 
    };
 
    struct AddressInfo : public LinkInfo
    {
        Interface::Address address; 
    };
 
    struct RouteInfo : public LinkInfo
    {
        Interface::Route route; 
    };
 
    class InterfaceManager : public NetlinkManager
    {
    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 (Reactor* reactor = nullptr);
 
        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 ();
 
        uint64_t addLinkListener (const LinkNotify& cb);
 
        void removeLinkListener (uint64_t id);
 
        uint64_t addAddressListener (const AddressNotify& cb);
 
        void removeAddressListener (uint64_t id);
 
        uint64_t addRouteListener (const RouteNotify& cb);
 
        void removeRouteListener (uint64_t id);
 
        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:
        static 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);
 
        void onMessage (struct nlmsghdr* nlh) override;
 
        void onLinkMessage (struct nlmsghdr* nlh);
 
        void onLinkInfoMessage (Interface::Ptr& iface, struct rtattr* rta, InterfaceChangeType& flags);
 
        void onAddressMessage (struct nlmsghdr* nlh);
 
        void onRouteMessage (struct nlmsghdr* nlh);
 
        void notifyLinkUpdate (const LinkInfo& info);
 
        void notifyAddressUpdate (const AddressInfo& info);
 
        void notifyRouteUpdate (const RouteInfo& info);
 
        Interface::Ptr acquire (uint32_t index, LinkInfo& info);
 
        static constexpr uint16_t reservedVlanId = 0;
 
        static constexpr uint16_t maxVlanId = 4094;
 
        std::unordered_map<uint32_t, Interface::Ptr> _interfaces;
 
        Mutex _ifMutex;
 
        std::unordered_map<uint64_t, LinkNotify> _linkListeners;
 
        std::unordered_map<uint64_t, AddressNotify> _addressListeners;
 
        std::unordered_map<uint64_t, RouteNotify> _routeListeners;
 
        uint64_t _listenerCounter = 0;
 
        Mutex _listenerMutex;
 
        // friendship with interface.
        friend class Interface;
    };
}
 
#endif