Handshake.h

#pragma once
 
#include <xrpld/app/main/Application.h>
#include <xrpld/overlay/detail/ProtocolVersion.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/net/IPAddress.h>
#include <xrpl/beast/utility/Journal.h>
 
#include <boost/asio/ssl.hpp>
#include <boost/beast/core/tcp_stream.hpp>
#include <boost/beast/http/dynamic_body.hpp>
#include <boost/beast/http/empty_body.hpp>
#include <boost/beast/http/fields.hpp>
#include <boost/beast/ssl/ssl_stream.hpp>
 
#include <cstdint>
#include <optional>
#include <string>
 
namespace xrpl {
 
using socket_type = boost::beast::tcp_stream;
using stream_type = boost::beast::ssl_stream<socket_type>;
using request_type = boost::beast::http::request<boost::beast::http::empty_body>;
using http_request_type = boost::beast::http::request<boost::beast::http::dynamic_body>;
using http_response_type = boost::beast::http::response<boost::beast::http::dynamic_body>;

std::optional<uint256>
makeSharedValue(stream_type& ssl, beast::Journal journal);

void
buildHandshake(
    boost::beast::http::fields& h,
    uint256 const& sharedValue,
    std::optional<std::uint32_t> networkID,
    beast::ip::Address publicIp,
    beast::ip::Address remoteIp,
    Application& app);

PublicKey
verifyHandshake(
    boost::beast::http::fields const& headers,
    uint256 const& sharedValue,
    std::optional<std::uint32_t> networkID,
    beast::ip::Address publicIp,
    beast::ip::Address remote,
    Application& app);

request_type
makeRequest(
    bool crawlPublic,
    bool comprEnabled,
    bool ledgerReplayEnabled,
    bool txReduceRelayEnabled,
    bool vpReduceRelayEnabled);

http_response_type
makeResponse(
    bool crawlPublic,
    http_request_type const& req,
    beast::ip::Address publicIp,
    beast::ip::Address remoteIp,
    uint256 const& sharedValue,
    std::optional<std::uint32_t> networkID,
    ProtocolVersion version,
    Application& app);
 
// Protocol features negotiated via HTTP handshake.
// The format is:
// X-Protocol-Ctl: feature1=value1[,value2]*[\s*;\s*feature2=value1[,value2]*]*
// value: \S+
 
// compression feature
static constexpr char kFeatureCompr[] = "compr";
// validation/proposal reduce-relay base squelch feature
static constexpr char kFeatureVprr[] = "vprr";
// transaction reduce-relay feature
static constexpr char kFeatureTxrr[] = "txrr";
// ledger replay
static constexpr char kFeatureLedgerReplay[] = "ledgerreplay";
static constexpr char kDelimFeature[] = ";";
static constexpr char kDelimValue[] = ",";

std::optional<std::string>
getFeatureValue(boost::beast::http::fields const& headers, std::string const& feature);

bool
isFeatureValue(
    boost::beast::http::fields const& headers,
    std::string const& feature,
    std::string const& value);

bool
featureEnabled(boost::beast::http::fields const& headers, std::string const& feature);

template <typename Headers>
bool
peerFeatureEnabled(
    Headers const& request,
    std::string const& feature,
    std::string value,
    bool config)
{
    return config && isFeatureValue(request, feature, value);
}

template <typename Headers>
bool
peerFeatureEnabled(Headers const& request, std::string const& feature, bool config)
{
    return config && peerFeatureEnabled(request, feature, "1", config);
}

std::string
makeFeaturesRequestHeader(
    bool comprEnabled,
    bool ledgerReplayEnabled,
    bool txReduceRelayEnabled,
    bool vpReduceRelayEnabled);

std::string
makeFeaturesResponseHeader(
    http_request_type const& headers,
    bool comprEnabled,
    bool ledgerReplayEnabled,
    bool txReduceRelayEnabled,
    bool vpReduceRelayEnabled);
 
}  // namespace xrpl