interface.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_INTERFACE_HPP
#define JOIN_FABRIC_INTERFACE_HPP
 
// libjoin.
#include <join/mac_address.hpp>
#include <join/ip_address.hpp>
#include <join/mutex.hpp>
 
// C++.
#include <compare>
#include <string>
#include <memory>
#include <vector>
 
// C.
#include <cstdint>
 
namespace join
{
    class InterfaceManager;
 
    class Interface
    {
    private:
        explicit Interface (InterfaceManager* manager, uint32_t index);
 
    public:
        using Ptr = std::shared_ptr<Interface>;
 
        struct Address
        {
            IpAddress ip;        
            uint32_t prefix = 0; 
            IpAddress broadcast; 
        };
 
        using AddressList = std::vector<Address>;
 
        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 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;
 
        mutable Mutex _mutex;
 
        // friendship with equal operator.
        friend bool operator== (const Interface::Ptr& lhs, const Interface::Ptr& rhs) noexcept;
 
        // friendship with three-way comparison operator.
        friend std::strong_ordering 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 std::strong_ordering operator<=> (const Interface::Ptr& lhs, const Interface::Ptr& rhs) noexcept
    {
        if (!lhs || !rhs)
        {
            return bool (lhs) <=> bool (rhs);
        }
        return lhs->_index <=> rhs->_index;
    }
 
    using InterfaceList = std::vector<Interface::Ptr>;
}
 
#endif