SlotImp.h

#pragma once
 
#include <xrpl/beast/container/aged_unordered_map.h>
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/peerfinder/Slot.h>
#include <xrpl/peerfinder/Types.h>
#include <xrpl/protocol/PublicKey.h>
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
 
namespace xrpl::peer_finder {
 
class SlotImp : public Slot
{
public:
    using ptr = std::shared_ptr<SlotImp>;
 
    // inbound
    SlotImp(
        beast::ip::Endpoint const& localEndpoint,
        beast::ip::Endpoint remoteEndpoint,
        bool fixed,
        clock_type& clock);
 
    // outbound
    SlotImp(beast::ip::Endpoint remoteEndpoint, bool fixed, clock_type& clock);
 
    bool
    inbound() const override
    {
        return inbound_;
    }
 
    bool
    fixed() const override
    {
        return fixed_;
    }
 
    bool
    reserved() const override
    {
        return reserved_;
    }
 
    State
    state() const override
    {
        return state_;
    }
 
    beast::ip::Endpoint const&
    remoteEndpoint() const override
    {
        return remoteEndpoint_;
    }
 
    std::optional<beast::ip::Endpoint> const&
    localEndpoint() const override
    {
        return localEndpoint_;
    }
 
    std::optional<PublicKey> const&
    publicKey() const override
    {
        return publicKey_;
    }
 
    std::string
    prefix() const
    {
        return "[" + getFingerprint(remoteEndpoint(), publicKey()) + "] ";
    }
 
    std::optional<std::uint16_t>
    listeningPort() const override
    {
        std::uint32_t const value = listeningPort_;
        if (value == kUnknownPort)
            return std::nullopt;
        return value;
    }
 
    void
    setListeningPort(std::uint16_t port)
    {
        listeningPort_ = port;
    }
 
    void
    localEndpoint(beast::ip::Endpoint const& endpoint)
    {
        localEndpoint_ = endpoint;
    }
 
    void
    remoteEndpoint(beast::ip::Endpoint const& endpoint)
    {
        remoteEndpoint_ = endpoint;
    }
 
    void
    publicKey(PublicKey const& key)
    {
        publicKey_ = key;
    }
 
    void
    reserved(bool reserved)
    {
        reserved_ = reserved;
    }
 
    //--------------------------------------------------------------------------
 
    void
    state(State state);
 
    void
    activate(clock_type::time_point const& now);
 
    // "Memberspace"
    //
    // The set of all recent addresses that we have seen from this peer.
    // We try to avoid sending a peer the same addresses they gave us.
    //
    class RecentT
    {
    public:
        explicit RecentT(clock_type& clock);

        void
        insert(beast::ip::Endpoint const& ep, std::uint32_t hops);

        bool
        filter(beast::ip::Endpoint const& ep, std::uint32_t hops);
 
    private:
        void
        expire();
 
        friend class SlotImp;
        beast::aged_unordered_map<beast::ip::Endpoint, std::uint32_t> cache_;
    } recent;
 
    void
    expire()
    {
        recent.expire();
    }
 
private:
    bool const inbound_;
    bool const fixed_;
    bool reserved_;
    State state_;
    beast::ip::Endpoint remoteEndpoint_;
    std::optional<beast::ip::Endpoint> localEndpoint_;
    std::optional<PublicKey> publicKey_;
 
    static std::int32_t constexpr kUnknownPort = -1;
    std::atomic<std::int32_t> listeningPort_;
 
public:
    // DEPRECATED public data members
 
    // Tells us if we checked the connection. Outbound connections
    // are always considered checked since we successfully connected.
    bool checked;
 
    // Set to indicate if the connection can receive incoming at the
    // address advertised in mtENDPOINTS. Only valid if checked is true.
    bool canAccept;
 
    // Set to indicate that a connection check for this peer is in
    // progress. Valid always.
    bool connectivityCheckInProgress;
 
    // The time after which we will accept mtENDPOINTS from the peer
    // This is to prevent flooding or spamming. Receipt of mtENDPOINTS
    // sooner than the allotted time should impose a load charge.
    //
    clock_type::time_point whenAcceptEndpoints;
};
 
}  // namespace xrpl::peer_finder