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 <memory>
#include <vector>
 
// 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 bool operator< (const RouteKey& lhs, const RouteKey& rhs) noexcept
    {
        if (lhs._index != rhs._index)
        {
            return lhs._index < rhs._index;
        }
        if (lhs._dest != rhs._dest)
        {
            return lhs._dest < rhs._dest;
        }
        return lhs._prefix < 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 less operator.
        friend bool 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 bool operator< (const Route::Ptr& lhs, const Route::Ptr& rhs) noexcept
    {
        if (!lhs)
        {
            return true;
        }
        if (!rhs)
        {
            return false;
        }
        if (lhs->_index != rhs->_index)
        {
            return lhs->_index < rhs->_index;
        }
        if (lhs->_dest != rhs->_dest)
        {
            return lhs->_dest < rhs->_dest;
        }
        return lhs->_prefix < 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