neighbor.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_NEIGHBOR_HPP
#define JOIN_FABRIC_NEIGHBOR_HPP
 
// libjoin.
#include <join/mac_address.hpp>
#include <join/ip_address.hpp>
#include <join/mutex.hpp>
 
// C++.
#include <compare>
#include <memory>
#include <vector>
#include <tuple>
 
// C.
#include <linux/neighbour.h>
#include <cstdint>
 
namespace join
{
    class NeighborManager;
 
    struct NeighborKey
    {
        uint32_t _index = 0;
 
        IpAddress _ip;
    };
 
    inline bool operator== (const NeighborKey& lhs, const NeighborKey& rhs) noexcept
    {
        return lhs._index == rhs._index && lhs._ip == rhs._ip;
    }
 
    inline std::strong_ordering operator<=> (const NeighborKey& lhs, const NeighborKey& rhs) noexcept
    {
        return std::tie (lhs._index, lhs._ip) <=> std::tie (rhs._index, rhs._ip);
    }
 
    class Neighbor
    {
    private:
        explicit Neighbor (NeighborManager* manager, const NeighborKey& key);
 
    public:
        using Ptr = std::shared_ptr<Neighbor>;
 
        Neighbor () = delete;
 
        ~Neighbor () = default;
 
        uint32_t index () const noexcept;
 
        const IpAddress& ip () const noexcept;
 
        MacAddress mac () const;
 
        uint16_t state () const;
 
        bool isReachable () const noexcept;
 
        bool isStale () const noexcept;
 
        bool isPermanent () const noexcept;
 
        bool isIncomplete () const noexcept;
 
        bool isFailed () const noexcept;
 
        int set (const MacAddress& macAddress, uint16_t state = NUD_PERMANENT, bool sync = false) const;
 
        int remove (bool sync = false) const;
 
    private:
        NeighborManager* _manager = nullptr;
 
        uint32_t _index = 0;
 
        IpAddress _ip;
 
        MacAddress _mac;
 
        uint16_t _state = NUD_NONE;
 
        mutable Mutex _mutex;
 
        // friendship with equal operator.
        friend bool operator== (const Neighbor::Ptr& lhs, const Neighbor::Ptr& rhs) noexcept;
 
        // friendship with three-way comparison operator.
        friend std::strong_ordering operator<=> (const Neighbor::Ptr& lhs, const Neighbor::Ptr& rhs) noexcept;
 
        // friendship with neighbor manager.
        friend class NeighborManager;
    };
 
    inline bool operator== (const Neighbor::Ptr& lhs, const Neighbor::Ptr& rhs) noexcept
    {
        if (!lhs && !rhs)
        {
            return true;
        }
        if (!lhs || !rhs)
        {
            return false;
        }
        return lhs->_index == rhs->_index && lhs->_ip == rhs->_ip;
    }
 
    inline std::strong_ordering operator<=> (const Neighbor::Ptr& lhs, const Neighbor::Ptr& rhs) noexcept
    {
        if (!lhs || !rhs)
        {
            return bool (lhs) <=> bool (rhs);
        }
        return std::tie (lhs->_index, lhs->_ip) <=> std::tie (rhs->_index, rhs->_ip);
    }
 
    using NeighborList = std::vector<Neighbor::Ptr>;
};
 
namespace std
{
    template <>
    struct hash<join::NeighborKey>
    {
        size_t operator() (const join::NeighborKey& key) const noexcept
        {
            size_t h = std::hash<uint32_t>{}(key._index);
            h ^= std::hash<join::IpAddress>{}(key._ip) + 0x9e3779b9 + (h << 6) + (h >> 2);
            return h;
        }
    };
}
 
#endif