// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2021 The Bitcoin Core developers

// Copyright (c) 2014-2025 The Dash Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#if defined(HAVE_CONFIG_H)

#include <config/bitcoin-config.h>

#endif

#include <net.h>

#include <netmessagemaker.h>

#include <addrdb.h>

#include <addrman.h>

#include <banman.h>

#include <clientversion.h>

#include <compat/compat.h>

#include <consensus/consensus.h>

#include <crypto/sha256.h>

#include <node/eviction.h>

#include <fs.h>

#include <i2p.h>

#include <key.h>

#include <memusage.h>

#include <net_permissions.h>

#include <netaddress.h>

#include <netbase.h>

#include <node/interface_ui.h>

#include <protocol.h>

#include <random.h>

#include <scheduler.h>

#include <util/sock.h>

#include <util/strencodings.h>

#include <util/system.h>

#include <util/thread.h>

#include <util/threadinterrupt.h>

#include <util/time.h>

#include <util/trace.h>

#include <util/translation.h>

#include <evo/deterministicmns.h>

#include <masternode/meta.h>

#include <masternode/sync.h>

#include <stats/client.h>

#include <util/std23.h>

#include <util/vector.h>

#include <util/wpipe.h>

#ifdef WIN32

#include <string.h>

#endif

#if HAVE_DECL_GETIFADDRS && HAVE_DECL_FREEIFADDRS

#include <ifaddrs.h>

#endif

#include <algorithm>

#include <array>

#include <cstdint>

#include <functional>

#include <unordered_map>

#include <math.h>

/** Maximum number of block-relay-only anchor connections */

static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2;

static_assert (MAX_BLOCK_RELAY_ONLY_ANCHORS <= static_cast<size_t>(MAX_BLOCK_RELAY_ONLY_CONNECTIONS), "MAX_BLOCK_RELAY_ONLY_ANCHORS must not exceed MAX_BLOCK_RELAY_ONLY_CONNECTIONS.");

/** Anchor IP address database file name */

const char* const ANCHORS_DATABASE_FILENAME = "anchors.dat";

// How often to dump addresses to peers.dat

static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15};

/** Number of DNS seeds to query when the number of connections is low. */

static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE = 3;

/** How long to delay before querying DNS seeds

*

* If we have more than THRESHOLD entries in addrman, then it's likely

* that we got those addresses from having previously connected to the P2P

* network, and that we'll be able to successfully reconnect to the P2P

* network via contacting one of them. So if that's the case, spend a

* little longer trying to connect to known peers before querying the

* DNS seeds.

*/

static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS{11};

static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS{5};

static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD = 1000; // "many" vs "few" peers

/** The default timeframe for -maxuploadtarget. 1 day. */

static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME{60 * 60 * 24};

// A random time period (0 to 1 seconds) is added to feeler connections to prevent synchronization.

static constexpr auto FEELER_SLEEP_WINDOW{1s};

/** Frequency to attempt extra connections to reachable networks we're not connected to yet **/

static constexpr auto EXTRA_NETWORK_PEER_INTERVAL{5min};

/** Used to pass flags to the Bind() function */

enum BindFlags {

BF_NONE = 0,

BF_REPORT_ERROR = (1U << 0),

/**

* Do not call AddLocal() for our special addresses, e.g., for incoming

* Tor connections, to prevent gossiping them over the network.

*/

BF_DONT_ADVERTISE = (1U << 1),

};

#ifndef USE_WAKEUP_PIPE

// The set of sockets cannot be modified while waiting

// The sleep time needs to be small to avoid new sockets stalling

static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 50;

#else

// select() is woken up through the wakeup pipe whenever a new node is added, so we can wait much longer.

// We are however still somewhat limited in how long we can sleep as there is periodic work (cleanup) to be done in

// the socket handler thread

static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 500;

#endif /* USE_WAKEUP_PIPE */

const std::string NET_MESSAGE_TYPE_OTHER = "*other*";

static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL; // SHA256("netgroup")[0:8]

static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL; // SHA256("localhostnonce")[0:8]

static const uint64_t RANDOMIZER_ID_ADDRCACHE = 0x1cf2e4ddd306dda9ULL; // SHA256("addrcache")[0:8]

//

// Global state variables

//

bool fDiscover = true;

bool fListen = true;

GlobalMutex g_maplocalhost_mutex;

std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(g_maplocalhost_mutex);

std::string strSubVersion;

size_t CSerializedNetMsg::GetMemoryUsage() const noexcept

{

// Don't count the dynamic memory used for the m_type string, by assuming it fits in the

// "small string" optimization area (which stores data inside the object itself, up to some

// size; 15 bytes in modern libstdc++).

return sizeof(*this) + memusage::DynamicUsage(data);

}

void CConnman::AddAddrFetch(const std::string& strDest)

{

LOCK(m_addr_fetches_mutex);

m_addr_fetches.push_back(strDest);

}

uint16_t GetListenPort()

{

// If -bind= is provided with ":port" part, use that (first one if multiple are provided).

for (const std::string& bind_arg : gArgs.GetArgs("-bind")) {

constexpr uint16_t dummy_port = 0;

const std::optional<CService> bind_addr{Lookup(bind_arg, dummy_port, /*fAllowLookup=*/false)};

if (bind_addr.has_value() && bind_addr->GetPort() != dummy_port) return bind_addr->GetPort();

}

// Otherwise, if -whitebind= without NetPermissionFlags::NoBan is provided, use that

// (-whitebind= is required to have ":port").

for (const std::string& whitebind_arg : gArgs.GetArgs("-whitebind")) {

NetWhitebindPermissions whitebind;

bilingual_str error;

if (NetWhitebindPermissions::TryParse(whitebind_arg, whitebind, error)) {

if (!NetPermissions::HasFlag(whitebind.m_flags, NetPermissionFlags::NoBan)) {

return whitebind.m_service.GetPort();

}

}

}

// Otherwise, if -port= is provided, use that. Otherwise use the default port.

return static_cast<uint16_t>(gArgs.GetIntArg("-port", Params().GetDefaultPort()));

}

// Determine the "best" local address for a particular peer.

[[nodiscard]] static std::optional<CService> GetLocal(const CNode& peer)

{

if (!fListen) return std::nullopt;

std::optional<CService> addr;

int nBestScore = -1;

int nBestReachability = -1;

{

LOCK(g_maplocalhost_mutex);

for (const auto& [local_addr, local_service_info] : mapLocalHost) {

// For privacy reasons, don't advertise our privacy-network address

// to other networks and don't advertise our other-network address

// to privacy networks.

if (local_addr.GetNetwork() != peer.ConnectedThroughNetwork()

&& (local_addr.IsPrivacyNet() || peer.IsConnectedThroughPrivacyNet())) {

continue;

}

const int nScore{local_service_info.nScore};

const int nReachability{local_addr.GetReachabilityFrom(peer.addr)};

if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore)) {

addr.emplace(CService{local_addr, local_service_info.nPort});

nBestReachability = nReachability;

nBestScore = nScore;

}

}

}

return addr;

}

//! Convert the serialized seeds into usable address objects.

static std::vector<CAddress> ConvertSeeds(const std::vector<uint8_t> &vSeedsIn)

{

// It'll only connect to one or two seed nodes because once it connects,

// it'll get a pile of addresses with newer timestamps.

// Seed nodes are given a random 'last seen time' of between one and two

// weeks ago.

const auto one_week{7 * 24h};

std::vector<CAddress> vSeedsOut;

FastRandomContext rng;

CDataStream s(vSeedsIn, SER_NETWORK, PROTOCOL_VERSION | ADDRV2_FORMAT);

while (!s.eof()) {

CService endpoint;

s >> endpoint;

CAddress addr{endpoint, GetDesirableServiceFlags(NODE_NONE)};

addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - one_week, -one_week);

LogPrint(BCLog::NET, "Added hardcoded seed: %s\n", addr.ToStringAddrPort());

vSeedsOut.push_back(addr);

}

return vSeedsOut;

}

// Determine the "best" local address for a particular peer.

// If none, return the unroutable 0.0.0.0 but filled in with

// the normal parameters, since the IP may be changed to a useful

// one by discovery.

CService GetLocalAddress(const CNode& peer)

{

return GetLocal(peer).value_or(CService{CNetAddr(), GetListenPort()});

}

static int GetnScore(const CService& addr)

{

LOCK(g_maplocalhost_mutex);

const auto it = mapLocalHost.find(addr);

return (it != mapLocalHost.end()) ? it->second.nScore : 0;

}

// Is our peer's addrLocal potentially useful as an external IP source?

[[nodiscard]] static bool IsPeerAddrLocalGood(CNode *pnode)

{

CService addrLocal = pnode->GetAddrLocal();

return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&

g_reachable_nets.Contains(addrLocal);

}

std::optional<CService> GetLocalAddrForPeer(CNode& node)

{

CService addrLocal{GetLocalAddress(node)};

// If discovery is enabled, sometimes give our peer the address it

// tells us that it sees us as in case it has a better idea of our

// address than we do.

FastRandomContext rng;

if (IsPeerAddrLocalGood(&node) && (!addrLocal.IsRoutable() ||

rng.randbits((GetnScore(addrLocal) > LOCAL_MANUAL) ? 3 : 1) == 0))

{

if (node.IsInboundConn()) {

// For inbound connections, assume both the address and the port

// as seen from the peer.

addrLocal = CService{node.GetAddrLocal()};

} else {

// For outbound connections, assume just the address as seen from

// the peer and leave the port in `addrLocal` as returned by

// `GetLocalAddress()` above. The peer has no way to observe our

// listening port when we have initiated the connection.

addrLocal.SetIP(node.GetAddrLocal());

}

}

if (addrLocal.IsRoutable())

{

LogPrint(BCLog::NET, "Advertising address %s to peer=%d\n", addrLocal.ToStringAddrPort(), node.GetId());

return addrLocal;

}

// Address is unroutable. Don't advertise.

return std::nullopt;

}

// learn a new local address

bool AddLocal(const CService& addr_, int nScore)

{

CService addr{MaybeFlipIPv6toCJDNS(addr_)};

if (!addr.IsRoutable() && Params().RequireRoutableExternalIP())

return false;

if (!fDiscover && nScore < LOCAL_MANUAL)

return false;

if (!g_reachable_nets.Contains(addr))

return false;

LogPrintf("AddLocal(%s,%i)\n", addr.ToStringAddrPort(), nScore);

{

LOCK(g_maplocalhost_mutex);

const auto [it, is_newly_added] = mapLocalHost.emplace(addr, LocalServiceInfo());

LocalServiceInfo &info = it->second;

if (is_newly_added || nScore >= info.nScore) {

info.nScore = nScore + (is_newly_added ? 0 : 1);

info.nPort = addr.GetPort();

}

}

return true;

}

bool AddLocal(const CNetAddr &addr, int nScore)

{

return AddLocal(CService(addr, GetListenPort()), nScore);

}

void RemoveLocal(const CService& addr)

{

LOCK(g_maplocalhost_mutex);

LogPrintf("RemoveLocal(%s)\n", addr.ToStringAddrPort());

mapLocalHost.erase(addr);

}

/** vote for a local address */

bool SeenLocal(const CService& addr)

{

LOCK(g_maplocalhost_mutex);

const auto it = mapLocalHost.find(addr);

if (it == mapLocalHost.end()) return false;

++it->second.nScore;

return true;

}

/** check whether a given address is potentially local */

bool IsLocal(const CService& addr)

{

LOCK(g_maplocalhost_mutex);

return mapLocalHost.count(addr) > 0;

}

bool CConnman::AlreadyConnectedToAddress(const CAddress& addr) const

{

READ_LOCK(m_nodes_mutex);

return FindNode(static_cast<CService>(addr)) != nullptr;

}

bool CConnman::CheckIncomingNonce(uint64_t nonce) const

{

READ_LOCK(m_nodes_mutex);

for (const CNode* pnode : m_nodes) {

if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() && pnode->GetLocalNonce() == nonce)

return false;

}

return true;

}

/** Get the bind address for a socket as CAddress */

static CAddress GetBindAddress(const Sock& sock)

{

CAddress addr_bind;

struct sockaddr_storage sockaddr_bind;

socklen_t sockaddr_bind_len = sizeof(sockaddr_bind);

if (!sock.GetSockName((struct sockaddr*)&sockaddr_bind, &sockaddr_bind_len)) {

addr_bind.SetSockAddr((const struct sockaddr*)&sockaddr_bind);

} else {

LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "getsockname failed\n");

}

return addr_bind;

}

CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport)

{

AssertLockNotHeld(m_unused_i2p_sessions_mutex);

assert(conn_type != ConnectionType::INBOUND);

if (pszDest == nullptr) {

if (addrConnect.GetPort() == GetListenPort() && IsLocal(addrConnect)) {

return nullptr;

}

// Look for an existing connection

if (ExistsNode(static_cast<CService>(addrConnect))) {

LogPrintf("Failed to open new connection, already connected\n");

return nullptr;

}

}

/// debug print

if (fLogIPs) {

LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "trying %s connection %s lastseen=%.1fhrs\n",

use_v2transport ? "v2" : "v1",

pszDest ? pszDest : addrConnect.ToStringAddrPort(),

Ticks<HoursDouble>(pszDest ? 0h : Now<NodeSeconds>() - addrConnect.nTime));

} else {

LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "trying %s connection lastseen=%.1fhrs\n",

use_v2transport ? "v2" : "v1",

Ticks<HoursDouble>(pszDest ? 0h : Now<NodeSeconds>() - addrConnect.nTime));

}

// Resolve

const uint16_t default_port{pszDest != nullptr ? Params().GetDefaultPort(pszDest) :

Params().GetDefaultPort()};

if (pszDest) {

std::vector<CService> resolved{Lookup(pszDest, default_port, fNameLookup && !HaveNameProxy(), 256)};

if (!resolved.empty()) {

Shuffle(resolved.begin(), resolved.end(), FastRandomContext());

// If the connection is made by name, it can be the case that the name resolves to more than one address.

// We don't want to connect any more of them if we are already connected to one

for (const auto& r : resolved) {

addrConnect = CAddress{MaybeFlipIPv6toCJDNS(r), NODE_NONE};

if (!addrConnect.IsValid()) {

LogPrint(BCLog::NET, "Resolver returned invalid address %s for %s\n", addrConnect.ToStringAddrPort(), pszDest);

return nullptr;

}

// It is possible that we already have a connection to the IP/port pszDest resolved to.

// In that case, drop the connection that was just created.

if (ExistsNode(static_cast<CService>(addrConnect))) {

LogPrintf("Not opening a connection to %s, already connected to %s\n", pszDest, addrConnect.ToStringAddrPort());

return nullptr;

}

}

}

}

// Connect

std::unique_ptr<Sock> sock;

Proxy proxy;

CAddress addr_bind;

assert(!addr_bind.IsValid());

std::unique_ptr<i2p::sam::Session> i2p_transient_session;

if (addrConnect.IsValid()) {

const bool use_proxy{GetProxy(addrConnect.GetNetwork(), proxy)};

bool proxyConnectionFailed = false;

if (addrConnect.IsI2P() && use_proxy) {

i2p::Connection conn;

bool connected{false};

if (m_i2p_sam_session) {

connected = m_i2p_sam_session->Connect(addrConnect, conn, proxyConnectionFailed);

} else {

{

LOCK(m_unused_i2p_sessions_mutex);

if (m_unused_i2p_sessions.empty()) {

i2p_transient_session =

std::make_unique<i2p::sam::Session>(proxy, &interruptNet);

} else {

i2p_transient_session.swap(m_unused_i2p_sessions.front());

m_unused_i2p_sessions.pop();

}

}

connected = i2p_transient_session->Connect(addrConnect, conn, proxyConnectionFailed);

if (!connected) {

LOCK(m_unused_i2p_sessions_mutex);

if (m_unused_i2p_sessions.size() < MAX_UNUSED_I2P_SESSIONS_SIZE) {

m_unused_i2p_sessions.emplace(i2p_transient_session.release());

}

}

}

if (connected) {

sock = std::move(conn.sock);

addr_bind = CAddress{conn.me, NODE_NONE};

}

} else if (use_proxy) {

LogPrintLevel(BCLog::PROXY, BCLog::Level::Debug, "Using proxy: %s to connect to %s:%s\n", proxy.ToString(), addrConnect.ToStringAddr(), addrConnect.GetPort());

sock = ConnectThroughProxy(proxy, addrConnect.ToStringAddr(), addrConnect.GetPort(), proxyConnectionFailed);

} else {

// no proxy needed (none set for target network)

sock = ConnectDirectly(addrConnect, conn_type == ConnectionType::MANUAL);

}

if (!proxyConnectionFailed) {

// If a connection to the node was attempted, and failure (if any) is not caused by a problem connecting to

// the proxy, mark this as an attempt.

addrman.Attempt(addrConnect, fCountFailure);

}

} else if (pszDest && GetNameProxy(proxy)) {

std::string host;

uint16_t port{default_port};

SplitHostPort(std::string(pszDest), port, host);

bool proxyConnectionFailed;

sock = ConnectThroughProxy(proxy, host, port, proxyConnectionFailed);

}

if (!sock) {

return nullptr;

}

// Add node

NodeId id = GetNewNodeId();

uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();

if (!addr_bind.IsValid()) {

addr_bind = GetBindAddress(*sock);

}

CNode* pnode = new CNode(id,

std::move(sock),

addrConnect,

CalculateKeyedNetGroup(addrConnect),

nonce,

addr_bind,

pszDest ? pszDest : "",

conn_type,

/*inbound_onion=*/false,

CNodeOptions{

.i2p_sam_session = std::move(i2p_transient_session),

.recv_flood_size = nReceiveFloodSize,

.use_v2transport = use_v2transport,

});

pnode->AddRef();

::g_stats_client->inc("peers.connect", 1.0f);

// We're making a new connection, harvest entropy from the time (and our peer count)

RandAddEvent((uint32_t)id);

return pnode;

}

void CNode::CloseSocketDisconnect(CConnman* connman)

{

fDisconnect = true;

LOCK2(connman->cs_mapSocketToNode, m_sock_mutex);

if (!m_sock) {

return;

}

fHasRecvData = false;

fCanSendData = false;

connman->mapSocketToNode.erase(m_sock->Get());

{

LOCK(connman->cs_sendable_receivable_nodes);

connman->mapReceivableNodes.erase(GetId());

connman->mapSendableNodes.erase(GetId());

}

if (connman->m_edge_trig_events) {

connman->m_edge_trig_events->UnregisterEvents(m_sock->Get());

}

LogPrint(BCLog::NET, "disconnecting peer=%d\n", id);

m_sock.reset();

m_i2p_sam_session.reset();

::g_stats_client->inc("peers.disconnect", 1.0f);

}

void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr) const {

for (const auto& subnet : vWhitelistedRange) {

if (subnet.m_subnet.Match(addr)) NetPermissions::AddFlag(flags, subnet.m_flags);

}

}

bool CNode::IsBlockRelayOnly() const {

bool ignores_incoming_txs{gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)};

// Stop processing non-block data early if

// 1) We are in blocks only mode and peer has no relay permission

// 2) This peer is a block-relay-only peer

return (ignores_incoming_txs && !HasPermission(NetPermissionFlags::Relay)) || IsBlockOnlyConn();

}

CService CNode::GetAddrLocal() const

{

AssertLockNotHeld(m_addr_local_mutex);

LOCK(m_addr_local_mutex);

return addrLocal;

}

void CNode::SetAddrLocal(const CService& addrLocalIn) {

AssertLockNotHeld(m_addr_local_mutex);

LOCK(m_addr_local_mutex);

if (addrLocal.IsValid()) {

error("Addr local already set for node: %i. Refusing to change from %s to %s", id, addrLocal.ToStringAddrPort(), addrLocalIn.ToStringAddrPort());

} else {

addrLocal = addrLocalIn;

}

}

std::string CNode::GetLogString() const

{

return fLogIPs ? addr.ToStringAddrPort() : strprintf("%d", id);

}

Network CNode::ConnectedThroughNetwork() const

{

return m_inbound_onion ? NET_ONION : addr.GetNetClass();

}

bool CNode::IsConnectedThroughPrivacyNet() const

{

return m_inbound_onion || addr.IsPrivacyNet();

}

#undef X

#define X(name) stats.name = name

void CNode::CopyStats(CNodeStats& stats) const

{

stats.nodeid = this->GetId();

X(addr);

X(addrBind);

stats.m_network = ConnectedThroughNetwork();

X(m_last_send);

X(m_last_recv);

X(m_last_tx_time);

X(m_last_block_time);

X(m_connected);

X(nTimeOffset);

X(m_addr_name);

X(nVersion);

{

LOCK(m_subver_mutex);

X(cleanSubVer);

}

stats.fInbound = IsInboundConn();

X(m_bip152_highbandwidth_to);

X(m_bip152_highbandwidth_from);

{

LOCK(cs_vSend);

X(mapSendBytesPerMsgType);

X(nSendBytes);

}

{

LOCK(cs_vRecv);

X(mapRecvBytesPerMsgType);

X(nRecvBytes);

Transport::Info info = m_transport->GetInfo();

stats.m_transport_type = info.transport_type;

if (info.session_id) stats.m_session_id = HexStr(*info.session_id);

}

X(m_permission_flags);

X(m_last_ping_time);

X(m_min_ping_time);

// Leave string empty if addrLocal invalid (not filled in yet)

CService addrLocalUnlocked = GetAddrLocal();

stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToStringAddrPort() : "";

{

LOCK(cs_mnauth);

X(verifiedProRegTxHash);

X(verifiedPubKeyHash);

}

X(m_masternode_connection);

X(m_conn_type);

}

#undef X

bool CNode::ReceiveMsgBytes(Span<const uint8_t> msg_bytes, bool& complete)

{

complete = false;

const auto time = GetTime<std::chrono::microseconds>();

LOCK(cs_vRecv);

m_last_recv = std::chrono::duration_cast<std::chrono::seconds>(time);

nRecvBytes += msg_bytes.size();

while (msg_bytes.size() > 0) {

// absorb network data

if (!m_transport->ReceivedBytes(msg_bytes)) {

// Serious transport problem, disconnect from the peer.

return false;

}

if (m_transport->ReceivedMessageComplete()) {

// decompose a transport agnostic CNetMessage from the deserializer

bool reject_message{false};

CNetMessage msg = m_transport->GetReceivedMessage(time, reject_message);

if (reject_message) {

// Message deserialization failed. Drop the message but don't disconnect the peer.

// store the size of the corrupt message

mapRecvBytesPerMsgType.at(NET_MESSAGE_TYPE_OTHER) += msg.m_raw_message_size;

continue;

}

// Store received bytes per message type.

// To prevent a memory DOS, only allow known message types.

auto i = mapRecvBytesPerMsgType.find(msg.m_type);

if (i == mapRecvBytesPerMsgType.end()) {

i = mapRecvBytesPerMsgType.find(NET_MESSAGE_TYPE_OTHER);

}

assert(i != mapRecvBytesPerMsgType.end());

i->second += msg.m_raw_message_size;

::g_stats_client->count("bandwidth.message." + std::string(msg.m_type) + ".bytesReceived", msg.m_raw_message_size, 1.0f);

// push the message to the process queue,

vRecvMsg.push_back(std::move(msg));

complete = true;

}

}

return true;

}

V1Transport::V1Transport(const NodeId node_id, int nTypeIn, int nVersionIn) noexcept :

m_node_id(node_id), hdrbuf(nTypeIn, nVersionIn), vRecv(nTypeIn, nVersionIn)

{

assert(std::size(Params().MessageStart()) == std::size(m_magic_bytes));

std::copy(std::begin(Params().MessageStart()), std::end(Params().MessageStart()), m_magic_bytes);

LOCK(m_recv_mutex);

Reset();

}

Transport::Info V1Transport::GetInfo() const noexcept

{

return {.transport_type = TransportProtocolType::V1, .session_id = {}};

}

int V1Transport::readHeader(Span<const uint8_t> msg_bytes)

{

AssertLockHeld(m_recv_mutex);

// copy data to temporary parsing buffer

unsigned int nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos;

unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());

memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy);

nHdrPos += nCopy;

// if header incomplete, exit

if (nHdrPos < CMessageHeader::HEADER_SIZE)

return nCopy;

// deserialize to CMessageHeader

try {

hdrbuf >> hdr;

}

catch (const std::exception&) {

LogPrint(BCLog::NET, "Header error: Unable to deserialize, peer=%d\n", m_node_id);

return -1;

}

// Check start string, network magic

if (memcmp(hdr.pchMessageStart, m_magic_bytes, CMessageHeader::MESSAGE_START_SIZE) != 0) {

LogPrint(BCLog::NET, "Header error: Wrong MessageStart %s received, peer=%d\n", HexStr(hdr.pchMessageStart), m_node_id);

return -1;

}

// reject messages larger than MAX_SIZE or MAX_PROTOCOL_MESSAGE_LENGTH

if (hdr.nMessageSize > MAX_SIZE || hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {

LogPrint(BCLog::NET, "Header error: Size too large (%s, %u bytes), peer=%d\n", SanitizeString(hdr.GetCommand()), hdr.nMessageSize, m_node_id);

return -1;

}

// switch state to reading message data

in_data = true;

return nCopy;

}

int V1Transport::readData(Span<const uint8_t> msg_bytes)

{

AssertLockHeld(m_recv_mutex);

unsigned int nRemaining = hdr.nMessageSize - nDataPos;

unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());

if (vRecv.size() < nDataPos + nCopy) {

// Allocate up to 256 KiB ahead, but never more than the total message size.

vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));

}

hasher.Write(msg_bytes.first(nCopy));

memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);

nDataPos += nCopy;

return nCopy;

}

const uint256& V1Transport::GetMessageHash() const

{

AssertLockHeld(m_recv_mutex);

assert(CompleteInternal());

if (data_hash.IsNull())

hasher.Finalize(data_hash);

return data_hash;

}

CNetMessage V1Transport::GetReceivedMessage(const std::chrono::microseconds time, bool& reject_message)

{

AssertLockNotHeld(m_recv_mutex);

// Initialize out parameter

reject_message = false;

// decompose a single CNetMessage from the TransportDeserializer

LOCK(m_recv_mutex);

CNetMessage msg(std::move(vRecv));

// store message type string, time, and sizes

msg.m_type = hdr.GetCommand();

msg.m_time = time;

msg.m_message_size = hdr.nMessageSize;

msg.m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE;

uint256 hash = GetMessageHash();

// We just received a message off the wire, harvest entropy from the time (and the message checksum)

RandAddEvent(ReadLE32(hash.begin()));

// Check checksum and header message type string

if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0) {

LogPrint(BCLog::NET, "Header error: Wrong checksum (%s, %u bytes), expected %s was %s, peer=%d\n",

SanitizeString(msg.m_type), msg.m_message_size,

HexStr(Span{hash}.first(CMessageHeader::CHECKSUM_SIZE)),

HexStr(hdr.pchChecksum),

m_node_id);

reject_message = true;

} else if (!hdr.IsCommandValid()) {

LogPrint(BCLog::NET, "Header error: Invalid message type (%s, %u bytes), peer=%d\n",

SanitizeString(hdr.GetCommand()), msg.m_message_size, m_node_id);

reject_message = true;

}

// Always reset the network deserializer (prepare for the next message)

Reset();

return msg;

}

bool V1Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept

{

AssertLockNotHeld(m_send_mutex);

// Determine whether a new message can be set.

LOCK(m_send_mutex);

if (m_sending_header || m_bytes_sent < m_message_to_send.data.size()) return false;

// create dbl-sha256 checksum

uint256 hash = Hash(msg.data);

// create header

CMessageHeader hdr(m_magic_bytes, msg.m_type.c_str(), msg.data.size());

memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);

// serialize header

m_header_to_send.clear();

CVectorWriter{SER_NETWORK, INIT_PROTO_VERSION, m_header_to_send, 0, hdr};

// update state

m_message_to_send = std::move(msg);

m_sending_header = true;

m_bytes_sent = 0;

return true;

}

Transport::BytesToSend V1Transport::GetBytesToSend(bool have_next_message) const noexcept

{

AssertLockNotHeld(m_send_mutex);

LOCK(m_send_mutex);

if (m_sending_header) {

return {Span{m_header_to_send}.subspan(m_bytes_sent),

// We have more to send after the header if the message has payload, or if there

// is a next message after that.

have_next_message || !m_message_to_send.data.empty(),

m_message_to_send.m_type

};

} else {

return {Span{m_message_to_send.data}.subspan(m_bytes_sent),

// We only have more to send after this message's payload if there is another

// message.

have_next_message,

m_message_to_send.m_type

};

}

}

void V1Transport::MarkBytesSent(size_t bytes_sent) noexcept

{

AssertLockNotHeld(m_send_mutex);

LOCK(m_send_mutex);

m_bytes_sent += bytes_sent;

if (m_sending_header && m_bytes_sent == m_header_to_send.size()) {

// We're done sending a message's header. Switch to sending its data bytes.

m_sending_header = false;

m_bytes_sent = 0;

} else if (!m_sending_header && m_bytes_sent == m_message_to_send.data.size()) {

// We're done sending a message's data. Wipe the data vector to reduce memory consumption.

ClearShrink(m_message_to_send.data);

m_bytes_sent = 0;

}

}

size_t V1Transport::GetSendMemoryUsage() const noexcept

{

AssertLockNotHeld(m_send_mutex);

LOCK(m_send_mutex);

// Don't count sending-side fields besides m_message_to_send, as they're all small and bounded.

return m_message_to_send.GetMemoryUsage();

}

namespace {

/** List of short messages as defined in BIP324, in order.

*

* Only message types that are actually implemented in this codebase need to be listed, as other

* messages get ignored anyway - whether we know how to decode them or not.

*/

const std::array<std::string, 33> V2_BITCOIN_IDS = {

"", // 12 bytes follow encoding the message type like in V1

NetMsgType::ADDR,

NetMsgType::BLOCK,

NetMsgType::BLOCKTXN,

NetMsgType::CMPCTBLOCK,

"", /* FEEFILTER is not implemented in Dash */

NetMsgType::FILTERADD,

NetMsgType::FILTERCLEAR,

NetMsgType::FILTERLOAD,

NetMsgType::GETBLOCKS,

NetMsgType::GETBLOCKTXN,

NetMsgType::GETDATA,

NetMsgType::GETHEADERS,

NetMsgType::HEADERS,

NetMsgType::INV,

NetMsgType::MEMPOOL,

NetMsgType::MERKLEBLOCK,

NetMsgType::NOTFOUND,

NetMsgType::PING,

NetMsgType::PONG,

NetMsgType::SENDCMPCT,

NetMsgType::TX,

NetMsgType::GETCFILTERS,

NetMsgType::CFILTER,

NetMsgType::GETCFHEADERS,

NetMsgType::CFHEADERS,

NetMsgType::GETCFCHECKPT,

NetMsgType::CFCHECKPT,

NetMsgType::ADDRV2,

// Unimplemented message types that are assigned in BIP324:

"",

"",

"",

""

};

/** List of short messages allocated in Dash's reserved namespace, in order.

*

* Slots should not be reused unless the switchover has already been done

* by a protocol upgrade, the old message is no longer supported by the client

* and a new slot wasn't already allotted for the message.

*/

const std::array<std::string, 41> V2_DASH_IDS = {

NetMsgType::SPORK,

NetMsgType::GETSPORKS,

NetMsgType::SENDDSQUEUE,

NetMsgType::DSACCEPT,

NetMsgType::DSVIN,

NetMsgType::DSFINALTX,

NetMsgType::DSSIGNFINALTX,

NetMsgType::DSCOMPLETE,

NetMsgType::DSSTATUSUPDATE,

NetMsgType::DSTX,

NetMsgType::DSQUEUE,

NetMsgType::SYNCSTATUSCOUNT,

NetMsgType::MNGOVERNANCESYNC,

NetMsgType::MNGOVERNANCEOBJECT,

NetMsgType::MNGOVERNANCEOBJECTVOTE,

NetMsgType::GETMNLISTDIFF,

NetMsgType::MNLISTDIFF,

NetMsgType::QSENDRECSIGS,

NetMsgType::QFCOMMITMENT,

NetMsgType::QCONTRIB,

NetMsgType::QCOMPLAINT,

NetMsgType::QJUSTIFICATION,

NetMsgType::QPCOMMITMENT,

NetMsgType::QWATCH,

NetMsgType::QSIGSESANN,

NetMsgType::QSIGSHARESINV,

NetMsgType::QGETSIGSHARES,

NetMsgType::QBSIGSHARES,

NetMsgType::QSIGREC,

NetMsgType::QSIGSHARE,

NetMsgType::QGETDATA,

NetMsgType::QDATA,

NetMsgType::CLSIG,

NetMsgType::ISDLOCK,

NetMsgType::MNAUTH,

NetMsgType::GETHEADERS2,

NetMsgType::SENDHEADERS2,

NetMsgType::HEADERS2,

NetMsgType::GETQUORUMROTATIONINFO,

NetMsgType::QUORUMROTATIONINFO,

NetMsgType::PLATFORMBAN

};

/** Explicit version requirements for Dash v2 short IDs added after baseline.

*

* Maps message type to the minimum protocol version required to use its short ID.

* Only contains messages that were added AFTER the initial v2 implementation.

* Messages not in this map are baseline messages available at BIP324_DASH_BASELINE_VERSION.

*

* IMPORTANT:

* - Never remove entries (historical compatibility)

* - Add new messages as they are introduced

*/

static const std::map<std::string, int> V2_NEW_SHORT_ID_VERSIONS = {

{NetMsgType::PLATFORMBAN, PLATFORMBAN_V2_SHORT_ID_VERSION},

};

/** Get the minimum protocol version required for a message's short ID.

*

* @param message_type The message type to check

* @return Minimum protocol version required

*/

int GetMessageMinVersion(const std::string& message_type)

{

auto it = V2_NEW_SHORT_ID_VERSIONS.find(message_type);