interface.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_INTERFACE_HPP__
#define __JOIN_INTERFACE_HPP__
 
// libjoin.
#include <join/macaddress.hpp>
#include <join/ipaddress.hpp>
 
// C++.
#include <string>
#include <memory>
#include <vector>
#include <tuple>
#include <set>
 
// 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 noexcept;
 
        const std::string& name () const noexcept;
 
        int mtu (uint32_t mtuBytes, bool sync = false);
 
        uint32_t mtu () const noexcept;
 
        const std::string& kind () const noexcept;
 
        int mac (const MacAddress& macAddress, bool sync = false);
 
        const MacAddress& mac () const noexcept;
 
        int addAddress (const IpAddress& ipAddress, uint32_t prefix, const IpAddress& broadcast = {}, bool sync = false);
 
        int addAddress (const Address& address, bool sync = false);
 
        int removeAddress (const IpAddress& ipAddress, uint32_t prefix, const IpAddress& broadcast = {}, bool sync = false);
 
        int removeAddress (const Address& address, bool sync = false);
 
        const AddressList& addressList () const noexcept;
 
        bool hasAddress (const IpAddress& ipAddress);
 
        bool hasLocalAddress ();
 
        int addRoute (const IpAddress& dest, uint32_t prefix, const IpAddress& gateway = {}, uint32_t metric = 0, bool sync = false);
 
        int addRoute (const Route& route, bool sync = false);
 
        int removeRoute (const IpAddress& dest, uint32_t prefix, const IpAddress& gateway = {}, uint32_t metric = 0, bool sync = false);
 
        int removeRoute (const Route& route, bool sync = false);
 
        const RouteList& routeList () const noexcept;
 
        bool hasRoute (const IpAddress& dest, uint32_t prefix, const IpAddress& gateway, uint32_t metric);
 
        bool hasRoute (const Route& route);
 
        int addToBridge (uint32_t masterIndex, bool sync = false);
 
        int addToBridge (const std::string& masterName, bool sync = false);
 
        int removeFromBridge (bool sync = false);
 
        uint32_t flags () const noexcept;
 
        int enable (bool enabled = true, bool sync = false);
 
        bool isEnabled () const noexcept;
 
        bool isRunning () const noexcept;
 
        bool isLoopback () const noexcept;
 
        bool isPointToPoint () const noexcept;
 
        bool isDummy () const noexcept;
 
        bool isBridge () const noexcept;
 
        bool isVlan () const noexcept;
 
        bool isVeth () const noexcept;
 
        bool isGre () const noexcept;
 
        bool isTun () const noexcept;
 
        bool supportsBroadcast () const noexcept;
 
        bool supportsMulticast () const noexcept;
 
        bool supportsIpv4 ();
 
        bool supportsIpv6 ();
 
    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;
 
        Mutex _mutex;
 
        // friendship with equal operator.
        friend bool operator== (const Interface::Ptr& lhs, const Interface::Ptr& rhs);
 
        // friendship with not equal operator.
        friend bool operator< (const Interface::Ptr& lhs, const Interface::Ptr& rhs);
 
        // friendship with interface manager.
        friend class InterfaceManager;
    };
 
    inline bool operator== (const Interface::Ptr& lhs, const Interface::Ptr& rhs)
    {
        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)
    {
        if (!lhs)
        {
            return true;
        }
        if (!rhs)
        {
            return false;
        }
        return lhs->_index < rhs->_index;
    }
 
    using InterfaceList = std::set <Interface::Ptr>;
}
 
#endif