interface.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_INTERFACE_HPP
#define JOIN_FABRIC_INTERFACE_HPP
 
// libjoin.
#include <join/macaddress.hpp>
#include <join/ipaddress.hpp>
 
// C++.
#include <string>
#include <memory>
#include <vector>
#include <tuple>
 
// C.
#include <cstdint>
 
namespace join
{
    class InterfaceManager;
 
    class Interface
    {
    private:
        explicit Interface (InterfaceManager* manager, uint32_t index);
 
    public:
        using Ptr         = std::shared_ptr<Interface>;
        using Address     = std::tuple<IpAddress, uint32_t, IpAddress>;
        using AddressList = std::vector<Address>;
        using Route       = std::tuple<IpAddress, uint32_t, IpAddress, uint32_t>;
        using RouteList   = std::vector<Route>;
 
        Interface () = delete;
 
        ~Interface () = default;
 
        uint32_t index () const noexcept;
 
        uint32_t master () const;
 
        std::string name () const;
 
        int mtu (uint32_t mtuBytes, bool sync = false) const;
 
        uint32_t mtu () const;
 
        std::string kind () const;
 
        int mac (const MacAddress& macAddress, bool sync = false) const;
 
        MacAddress mac () const;
 
        int addAddress (const IpAddress& ipAddress, uint32_t prefix, const IpAddress& broadcast = {},
                        bool sync = false) const;
 
        int addAddress (const Address& address, bool sync = false) const;
 
        int removeAddress (const IpAddress& ipAddress, uint32_t prefix, const IpAddress& broadcast = {},
                           bool sync = false) const;
 
        int removeAddress (const Address& address, bool sync = false) const;
 
        AddressList addressList () const;
 
        bool hasAddress (const IpAddress& ipAddress) const;
 
        bool hasLocalAddress () const;
 
        int addRoute (const IpAddress& dest, uint32_t prefix, const IpAddress& gateway = {}, uint32_t metric = 0,
                      bool sync = false) const;
 
        int addRoute (const Route& route, bool sync = false) const;
 
        int removeRoute (const IpAddress& dest, uint32_t prefix, const IpAddress& gateway = {}, uint32_t metric = 0,
                         bool sync = false) const;
 
        int removeRoute (const Route& route, bool sync = false) const;
 
        RouteList routeList () const;
 
        bool hasRoute (const IpAddress& dest, uint32_t prefix, const IpAddress& gateway, uint32_t metric) const;
 
        bool hasRoute (const Route& route) const;
 
        int addToBridge (uint32_t masterIndex, bool sync = false) const;
 
        int addToBridge (const std::string& masterName, bool sync = false) const;
 
        int removeFromBridge (bool sync = false) const;
 
        uint32_t flags () const;
 
        int enable (bool enabled = true, bool sync = false) const;
 
        bool isEnabled () const;
 
        bool isRunning () const;
 
        bool isLoopback () const;
 
        bool isPointToPoint () const;
 
        bool isDummy () const;
 
        bool isBridge () const;
 
        bool isVlan () const;
 
        bool isVeth () const;
 
        bool isGre () const;
 
        bool isTun () const;
 
        bool supportsBroadcast () const;
 
        bool supportsMulticast () const;
 
        bool supportsIpv4 () const;
 
        bool supportsIpv6 () const;
 
    private:
        InterfaceManager* _manager = nullptr;
 
        uint32_t _index = 0;
 
        uint32_t _master = 0;
 
        std::string _name;
 
        std::string _kind;
 
        uint32_t _mtu = 0;
 
        uint32_t _flags = 0;
 
        MacAddress _mac;
 
        AddressList _addresses;
 
        RouteList _routes;
 
        mutable Mutex _mutex;
 
        // friendship with equal operator.
        friend bool operator== (const Interface::Ptr& lhs, const Interface::Ptr& rhs) noexcept;
 
        // friendship with less operator.
        friend bool operator< (const Interface::Ptr& lhs, const Interface::Ptr& rhs) noexcept;
 
        // friendship with interface manager.
        friend class InterfaceManager;
    };
 
    inline bool operator== (const Interface::Ptr& lhs, const Interface::Ptr& rhs) noexcept
    {
        if (!lhs && !rhs)
        {
            return true;
        }
        if (!lhs || !rhs)
        {
            return false;
        }
        return lhs->_index == rhs->_index;
    }
 
    inline bool operator< (const Interface::Ptr& lhs, const Interface::Ptr& rhs) noexcept
    {
        if (!lhs)
        {
            return true;
        }
        if (!rhs)
        {
            return false;
        }
        return lhs->_index < rhs->_index;
    }
 
    using InterfaceList = std::vector<Interface::Ptr>;
}
 
#endif