route.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_ROUTE_HPP
#define JOIN_FABRIC_ROUTE_HPP
 
// libjoin.
#include <join/ip_address.hpp>
#include <join/mutex.hpp>
 
// C++.
#include <compare>
#include <memory>
#include <vector>
#include <tuple>
 
// C.
#include <linux/rtnetlink.h>
#include <cstdint>
 
namespace join
{
    class RouteManager;
 
    struct RouteKey
    {
        uint32_t _index = 0;
 
        IpAddress _dest;
 
        uint32_t _prefix = 0;
    };
 
    inline bool operator== (const RouteKey& lhs, const RouteKey& rhs) noexcept
    {
        return lhs._index == rhs._index && lhs._dest == rhs._dest && lhs._prefix == rhs._prefix;
    }
 
    inline std::strong_ordering operator<=> (const RouteKey& lhs, const RouteKey& rhs) noexcept
    {
        return std::tie (lhs._index, lhs._dest, lhs._prefix) <=> std::tie (rhs._index, rhs._dest, rhs._prefix);
    }
 
    class Route
    {
    private:
        explicit Route (RouteManager* manager, const RouteKey& key);
 
    public:
        using Ptr = std::shared_ptr<Route>;
 
        Route () = delete;
 
        ~Route () = default;
 
        uint32_t index () const noexcept;
 
        const IpAddress& dest () const noexcept;
 
        uint32_t prefix () const noexcept;
 
        IpAddress gateway () const;
 
        uint32_t metric () const;
 
        uint8_t type () const;
 
        uint8_t scope () const;
 
        uint8_t protocol () const;
 
        bool isUnicast () const noexcept;
 
        bool isBlackhole () const noexcept;
 
        bool isUnreachable () const noexcept;
 
        bool isProhibit () const noexcept;
 
        bool isLocal () const noexcept;
 
        bool isScopeUniverse () const noexcept;
 
        bool isScopeLink () const noexcept;
 
        bool isScopeHost () const noexcept;
 
        bool isStatic () const noexcept;
 
        bool isKernel () const noexcept;
 
        bool isDhcp () const noexcept;
 
        bool isBoot () const noexcept;
 
        int set (const IpAddress& gateway, uint32_t metric = 0, bool sync = false) const;
 
        int remove (bool sync = false) const;
 
    private:
        RouteManager* _manager = nullptr;
 
        uint32_t _index = 0;
 
        IpAddress _dest;
 
        uint32_t _prefix = 0;
 
        IpAddress _gateway;
 
        uint32_t _metric = 0;
 
        uint8_t _type = RTN_UNICAST;
 
        uint8_t _scope = RT_SCOPE_UNIVERSE;
 
        uint8_t _protocol = RTPROT_STATIC;
 
        mutable Mutex _mutex;
 
        // friendship with equal operator.
        friend bool operator== (const Route::Ptr& lhs, const Route::Ptr& rhs) noexcept;
 
        // friendship with three-way comparison operator.
        friend std::strong_ordering operator<=> (const Route::Ptr& lhs, const Route::Ptr& rhs) noexcept;
 
        // friendship with route manager.
        friend class RouteManager;
    };
 
    inline bool operator== (const Route::Ptr& lhs, const Route::Ptr& rhs) noexcept
    {
        if (!lhs && !rhs)
        {
            return true;
        }
        if (!lhs || !rhs)
        {
            return false;
        }
        return lhs->_index == rhs->_index && lhs->_dest == rhs->_dest && lhs->_prefix == rhs->_prefix;
    }
 
    inline std::strong_ordering operator<=> (const Route::Ptr& lhs, const Route::Ptr& rhs) noexcept
    {
        if (!lhs || !rhs)
        {
            return bool (lhs) <=> bool (rhs);
        }
        return std::tie (lhs->_index, lhs->_dest, lhs->_prefix) <=> std::tie (rhs->_index, rhs->_dest, rhs->_prefix);
    }
 
    using RouteList = std::vector<Route::Ptr>;
 
}
 
namespace std
{
    template <>
    struct hash<join::RouteKey>
    {
        size_t operator() (const join::RouteKey& key) const noexcept
        {
            size_t h = std::hash<uint32_t>{}(key._index);
            h ^= std::hash<join::IpAddress>{}(key._dest) + 0x9e3779b9 + (h << 6) + (h >> 2);
            h ^= std::hash<uint32_t>{}(key._prefix) + 0x9e3779b9 + (h << 6) + (h >> 2);
            return h;
        }
    };
}
 
#endif