Handshake.h

#ifndef XRPL_OVERLAY_HANDSHAKE_H_INCLUDED
#define XRPL_OVERLAY_HANDSHAKE_H_INCLUDED
 
#include <xrpld/app/main/Application.h>
#include <xrpld/overlay/detail/ProtocolVersion.h>
 
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/protocol/BuildInfo.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 <optional>
#include <utility>
 
namespace ripple {
 
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 public_ip,
    beast::IP::Address remote_ip,
    Application& app);
 
PublicKey
verifyHandshake(
    boost::beast::http::fields const& headers,
    uint256 const& sharedValue,
    std::optional<std::uint32_t> networkID,
    beast::IP::Address public_ip,
    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 public_ip,
    beast::IP::Address remote_ip,
    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 FEATURE_COMPR[] = "compr";
// validation/proposal reduce-relay base squelch feature
static constexpr char FEATURE_VPRR[] = "vprr";
// transaction reduce-relay feature
static constexpr char FEATURE_TXRR[] = "txrr";
// ledger replay
static constexpr char FEATURE_LEDGER_REPLAY[] = "ledgerreplay";
static constexpr char DELIM_FEATURE[] = ";";
static constexpr char DELIM_VALUE[] = ",";
 
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 ripple
 
#endif