libxrpl/peerfinder/Config.cpp

#include <xrpl/peerfinder/Config.h>
 
#include <xrpl/beast/utility/PropertyStream.h>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <stdexcept>
 
namespace xrpl::peer_finder {
 
std::size_t
Config::calcOutPeers() const
{
    return std::max(
        ((maxPeers * tuning::kOutPercent) + 50) / 100, std::size_t(tuning::kMinOutCount));
}
 
void
Config::applyTuning()
{
    if (ipLimit == 0)
    {
        // Unless a limit is explicitly set, we allow between
        // 2 and 5 connections from non RFC-1918 "private"
        // IP addresses.
        ipLimit = 2;
 
        if (inPeers > tuning::kDefaultMaxPeers)
            ipLimit += std::min(5, static_cast<int>(inPeers / tuning::kDefaultMaxPeers));
    }
 
    // We don't allow a single IP to consume all incoming slots,
    // unless we only have one incoming slot available.
    ipLimit = std::max(1, std::min(ipLimit, static_cast<int>(inPeers / 2)));
}
 
void
Config::onWrite(beast::PropertyStream::Map& map) const
{
    map["max_peers"] = maxPeers;
    map["out_peers"] = outPeers;
    map["want_incoming"] = wantIncoming;
    map["auto_connect"] = autoConnect;
    map["port"] = listeningPort;
    map["features"] = features;
    map["ip_limit"] = ipLimit;
    map["verify_endpoints"] = verifyEndpoints;
}
 
Config
Config::makeConfig(
    bool peerPrivate,
    bool standalone,
    PeerLimitConfig const& limits,
    std::uint16_t port,
    bool validationPublicKey,
    int ipLimit,
    bool verifyEndpoints)
{
    peer_finder::Config config;
 
    if (!limits.maxPeers)
    {
        if (limits.inPeers && !limits.outPeers)
            throw std::runtime_error("Both inbound and outbound peer limits must be configured");
 
        if (limits.outPeers && !limits.inPeers)
            throw std::runtime_error("Both inbound and outbound peer limits must be configured");
 
        if (limits.inPeers && *limits.inPeers > 1000)
            throw std::runtime_error("Inbound peer limit must be less than or equal to 1000");
 
        if (limits.outPeers && (*limits.outPeers < 10 || *limits.outPeers > 1000))
            throw std::runtime_error("Outbound peer limit must be in the range 10-1000");
    }
 
    config.peerPrivate = peerPrivate;
 
    // Servers with peer privacy don't want to allow incoming connections
    config.wantIncoming = (!config.peerPrivate) && (port != 0);
 
    if (limits.maxPeers || (!limits.inPeers && !limits.outPeers))
    {
        if (limits.maxPeers && *limits.maxPeers != 0)
            config.maxPeers = *limits.maxPeers;
 
        config.maxPeers = std::max<std::size_t>(config.maxPeers, tuning::kMinOutCount);
        config.outPeers = config.calcOutPeers();
 
        // Calculate the number of outbound peers we want. If we dont want
        // or can't accept incoming, this will simply be equal to maxPeers.
        if (!config.wantIncoming)
            config.outPeers = config.maxPeers;
 
        // Calculate the largest number of inbound connections we could
        // take.
        if (config.maxPeers >= config.outPeers)
        {
            config.inPeers = config.maxPeers - config.outPeers;
        }
        else
        {
            config.inPeers = 0;
        }
    }
    else
    {
        config.outPeers = *limits.outPeers;
        config.inPeers = *limits.inPeers;
        config.maxPeers = 0;
    }
 
    // This will cause servers configured as validators to request that
    // peers they connect to never report their IP address. We set this
    // after we set the 'wantIncoming' because we want a "soft" version
    // of peer privacy unless the operator explicitly asks for it.
    if (validationPublicKey)
        config.peerPrivate = true;
 
    // if it's a private peer or we are running as standalone
    // automatic connections would defeat the purpose.
    config.autoConnect = !standalone && !peerPrivate;
    config.listeningPort = port;
    config.features = "";
    config.ipLimit = ipLimit;
    config.verifyEndpoints = verifyEndpoints;
 
    // Enforce business rules
    config.applyTuning();
 
    return config;
}
 
}  // namespace xrpl::peer_finder