← Watch feed
scripted-diff: Use references when nullptr is not possible
Public commit record
83/100 · Strong
What the developer wrote
Authored by MarcoFalke
scripted-diff: Use references when nullptr is not possible
This allows to skip nullptr checks later in the code, both mentally and literally.
This can be reviewed via the git option:
--word-diff-regex=.
-BEGIN VERIFY SCRIPT-
sed --regexp-extended --in-place '
/^bool PeerManagerImpl::SendMessages\(/,/^}$/ {
s/auto& peer\{maybe_peer\}; .. alias cleaned up .*/Peer\& peer{*maybe_peer};/;
s/peer->/peer./g;
s/\*peer\>/peer/g;
/CNode\* pto\{&node\}; .. alias removed .*/d;
s/pto->/node./g;
s/\*pto\>/node/g;
}
' src/net_processing.cpp
sed --regexp-extended --in-place '
/^void PeerManagerImpl::ProcessMessage\(/,/^}$/ {
/Peer\* peer\{&peer_alias_removed_in_later_commit};/d;
s/peer_alias_removed_in_later_commit/peer/;
s/peer->/peer./g;
s/\*peer\>/peer/g;
}
' src/net_processing.cpp
sed --regexp-extended --in-place '
/^bool PeerManagerImpl::ProcessMessages\(/,/^}$/ {
s/auto& peer\{maybe_peer\}; .. alias cleaned up .*/Peer\& peer{*maybe_peer};/;
s/peer->/peer./g;
s/\*peer\>/peer/g;
/CNode\* pfrom\{&node\}; .. alias removed .*/d;
s/pfrom->/node./g;
s/\*pfrom\>/node/g;
}
' src/net_processing.cpp
-END VERIFY SCRIPT-
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
What changed, and why it matters
This is a routine code-cleanup change in Bitcoin Core. It replaces some pointer variables with reference variables in the peer-to-peer networking code where the value can never be null. The behavior of the program is unchanged; it just removes unnecessary null checks and makes the code easier to read.
Recommended action
No security action needed. Treat as normal code-quality/maintenance review.
Security signals we found
No strong security signals were identified.
Evidence from the diff
The commit is a scripted refactor in src/net_processing.cpp. It removes temporary pointer aliases (peer, pto, pfrom) and uses direct references (Peer&, CNode&) because the underlying objects are already guaranteed to exist at those points. All pointer dereferences (peer->, pto->, pfrom->) are converted to reference accesses (.), and a few explicit null checks are dropped where they were redundant. The diff is purely syntactic; no logic, ordering, or security checks are altered.
Changed components
src/net_processing.cppPeerManagerImpl::ProcessMessagePeerManagerImpl::ProcessMessagesPeerManagerImpl::SendMessagesInspect captured patch +193 / −196
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index ebf5dcbc..4d4b7c11 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -3544,7 +3544,7 @@ void PeerManagerImpl::PushPrivateBroadcastTx(CNode& node)
MakeAndPushMessage(node, NetMsgType::INV, std::vector<CInv>{{CInv{MSG_TX, tx->GetHash().ToUint256()}}});
}
-void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, CNode& pfrom, const std::string& msg_type, DataStream& vRecv,
+void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string& msg_type, DataStream& vRecv,
const std::chrono::microseconds time_received,
const std::atomic<bool>& interruptMsgProc)
{
@@ -3552,7 +3552,6 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
LogDebug(BCLog::NET, "received: %s (%u bytes) peer=%d\n", SanitizeString(msg_type), vRecv.size(), pfrom.GetId());
- Peer* peer{&peer_alias_removed_in_later_commit};
if (msg_type == NetMsgType::VERSION) {
if (pfrom.nVersion != 0) {
@@ -3633,7 +3632,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Inbound peers send us their version message when they connect.
// We send our version message in response.
if (pfrom.IsInboundConn()) {
- PushNodeVersion(pfrom, *peer);
+ PushNodeVersion(pfrom, peer);
}
// Change version
@@ -3642,13 +3641,13 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
pfrom.nVersion = nVersion;
pfrom.m_has_all_wanted_services = HasAllDesirableServiceFlags(nServices);
- peer->m_their_services = nServices;
+ peer.m_their_services = nServices;
pfrom.SetAddrLocal(addrMe);
{
LOCK(pfrom.m_subver_mutex);
pfrom.cleanSubVer = cleanSubVer;
}
- peer->m_starting_height = starting_height;
+ peer.m_starting_height = starting_height;
// Only initialize the Peer::TxRelay m_relay_txs data structure if:
// - this isn't an outbound block-relay-only connection, and
@@ -3658,8 +3657,8 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// the peer may turn on transaction relay later.
if (!pfrom.IsBlockOnlyConn() &&
!pfrom.IsFeelerConn() &&
- (fRelay || (peer->m_our_services & NODE_BLOOM))) {
- auto* const tx_relay = peer->SetTxRelay();
+ (fRelay || (peer.m_our_services & NODE_BLOOM))) {
+ auto* const tx_relay = peer.SetTxRelay();
{
LOCK(tx_relay->m_bloom_filter_mutex);
tx_relay->m_relay_txs = fRelay; // set to true after we get the first filter* message
@@ -3670,7 +3669,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
const auto mapped_as{m_connman.GetMappedAS(pfrom.addr)};
LogDebug(BCLog::NET, "receive version message: %s: version %d, blocks=%d, us=%s, txrelay=%d, peer=%d%s%s\n",
cleanSubVer, pfrom.nVersion,
- peer->m_starting_height, addrMe.ToStringAddrPort(), fRelay, pfrom.GetId(),
+ peer.m_starting_height, addrMe.ToStringAddrPort(), fRelay, pfrom.GetId(),
pfrom.LogIP(fLogIPs), (mapped_as ? strprintf(", mapped_as=%d", mapped_as) : ""));
if (pfrom.IsPrivateBroadcastConn()) {
@@ -3704,7 +3703,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// - this is not a block-relay-only connection and not a feeler
// - this is not an addr fetch connection;
// - we are not in -blocksonly mode.
- const auto* tx_relay = peer->GetTxRelay();
+ const auto* tx_relay = peer.GetTxRelay();
if (tx_relay && WITH_LOCK(tx_relay->m_bloom_filter_mutex, return tx_relay->m_relay_txs) &&
!pfrom.IsAddrFetchConn() && !m_opts.ignore_incoming_txs) {
const uint64_t recon_salt = m_txreconciliation->PreRegisterPeer(pfrom.GetId());
@@ -3719,7 +3718,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
{
LOCK(cs_main);
CNodeState* state = State(pfrom.GetId());
- state->fPreferredDownload = (!pfrom.IsInboundConn() || pfrom.HasPermission(NetPermissionFlags::NoBan)) && !pfrom.IsAddrFetchConn() && CanServeBlocks(*peer);
+ state->fPreferredDownload = (!pfrom.IsInboundConn() || pfrom.HasPermission(NetPermissionFlags::NoBan)) && !pfrom.IsAddrFetchConn() && CanServeBlocks(peer);
m_num_preferred_download_peers += state->fPreferredDownload;
}
@@ -3728,7 +3727,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// inbound or outbound block-relay-only peers.
bool send_getaddr{false};
if (!pfrom.IsInboundConn()) {
- send_getaddr = SetupAddressRelay(pfrom, *peer);
+ send_getaddr = SetupAddressRelay(pfrom, peer);
}
if (send_getaddr) {
// Do a one-time address fetch to help populate/update our addrman.
@@ -3738,10 +3737,10 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// potentially leaking addr information and we do not want to
// indicate to the peer that we will participate in addr relay.
MakeAndPushMessage(pfrom, NetMsgType::GETADDR);
- peer->m_getaddr_sent = true;
+ peer.m_getaddr_sent = true;
// When requesting a getaddr, accept an additional MAX_ADDR_TO_SEND addresses in response
// (bypassing the MAX_ADDR_PROCESSING_TOKEN_BUCKET limit).
- peer->m_addr_token_bucket += MAX_ADDR_TO_SEND;
+ peer.m_addr_token_bucket += MAX_ADDR_TO_SEND;
}
if (!pfrom.IsInboundConn()) {
@@ -3762,11 +3761,11 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
m_addrman.Good(pfrom.addr);
}
- peer->m_time_offset = NodeSeconds{std::chrono::seconds{nTime}} - Now<NodeSeconds>();
+ peer.m_time_offset = NodeSeconds{std::chrono::seconds{nTime}} - Now<NodeSeconds>();
if (!pfrom.IsInboundConn()) {
// Don't use timedata samples from inbound peers to make it
// harder for others to create false warnings about our clock being out of sync.
- m_outbound_time_offsets.Add(peer->m_time_offset);
+ m_outbound_time_offsets.Add(peer.m_time_offset);
m_outbound_time_offsets.WarnIfOutOfSync();
}
@@ -3801,7 +3800,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
return strprintf("New %s peer connected: transport: %s, version: %d, blocks=%d peer=%d%s%s\n",
pfrom.ConnectionTypeAsString(),
TransportTypeAsString(pfrom.m_transport->GetInfo().transport_type),
- pfrom.nVersion.load(), peer->m_starting_height,
+ pfrom.nVersion.load(), peer.m_starting_height,
pfrom.GetId(), pfrom.LogIP(fLogIPs),
(mapped_as ? strprintf(", mapped_as=%d", mapped_as) : ""));
};
@@ -3814,7 +3813,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
LogInfo("%s", new_peer_msg());
}
- if (auto tx_relay = peer->GetTxRelay()) {
+ if (auto tx_relay = peer.GetTxRelay()) {
// `TxRelay::m_tx_inventory_to_send` must be empty before the
// version handshake is completed as
// `TxRelay::m_next_inv_send_time` is first initialised in
@@ -3849,7 +3848,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
}
if (m_txreconciliation) {
- if (!peer->m_wtxid_relay || !m_txreconciliation->IsPeerRegistered(pfrom.GetId())) {
+ if (!peer.m_wtxid_relay || !m_txreconciliation->IsPeerRegistered(pfrom.GetId())) {
// We could have optimistically pre-registered/registered the peer. In that case,
// we should forget about the reconciliation state here if this wasn't followed
// by WTXIDRELAY (since WTXIDRELAY can't be announced later).
@@ -3863,7 +3862,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
m_txdownloadman.ConnectedPeer(pfrom.GetId(), node::TxDownloadConnectionInfo {
.m_preferred = state->fPreferredDownload,
.m_relay_permissions = pfrom.HasPermission(NetPermissionFlags::Relay),
- .m_wtxid_relay = peer->m_wtxid_relay,
+ .m_wtxid_relay = peer.m_wtxid_relay,
});
}
@@ -3872,7 +3871,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
}
if (msg_type == NetMsgType::SENDHEADERS) {
- peer->m_prefers_headers = true;
+ peer.m_prefers_headers = true;
return;
}
@@ -3904,8 +3903,8 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
return;
}
if (pfrom.GetCommonVersion() >= WTXID_RELAY_VERSION) {
- if (!peer->m_wtxid_relay) {
- peer->m_wtxid_relay = true;
+ if (!peer.m_wtxid_relay) {
+ peer.m_wtxid_relay = true;
m_wtxid_relay_peers++;
} else {
LogDebug(BCLog::NET, "ignoring duplicate wtxidrelay from peer=%d\n", pfrom.GetId());
@@ -3925,7 +3924,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
pfrom.fDisconnect = true;
return;
}
- peer->m_wants_addrv2 = true;
+ peer.m_wants_addrv2 = true;
return;
}
@@ -3954,7 +3953,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Peer must not offer us reconciliations if they specified no tx relay support in VERSION.
// This flag might also be false in other cases, but the RejectIncomingTxs check above
// eliminates them, so that this flag fully represents what we are looking for.
- const auto* tx_relay = peer->GetTxRelay();
+ const auto* tx_relay = peer.GetTxRelay();
if (!tx_relay || !WITH_LOCK(tx_relay->m_bloom_filter_mutex, return tx_relay->m_relay_txs)) {
LogDebug(BCLog::NET, "sendtxrcncl received which indicated no tx relay to us, %s\n", pfrom.DisconnectMsg(fLogIPs));
pfrom.fDisconnect = true;
@@ -4010,14 +4009,14 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
vRecv >> ser_params(vAddr);
- if (!SetupAddressRelay(pfrom, *peer)) {
+ if (!SetupAddressRelay(pfrom, peer)) {
LogDebug(BCLog::NET, "ignoring %s message from %s peer=%d\n", msg_type, pfrom.ConnectionTypeAsString(), pfrom.GetId());
return;
}
if (vAddr.size() > MAX_ADDR_TO_SEND)
{
- Misbehaving(*peer, strprintf("%s message size = %u", msg_type, vAddr.size()));
+ Misbehaving(peer, strprintf("%s message size = %u", msg_type, vAddr.size()));
return;
}
@@ -4027,13 +4026,13 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Update/increment addr rate limiting bucket.
const auto current_time{GetTime<std::chrono::microseconds>()};
- if (peer->m_addr_token_bucket < MAX_ADDR_PROCESSING_TOKEN_BUCKET) {
+ if (peer.m_addr_token_bucket < MAX_ADDR_PROCESSING_TOKEN_BUCKET) {
// Don't increment bucket if it's already full
- const auto time_diff = std::max(current_time - peer->m_addr_token_timestamp, 0us);
+ const auto time_diff = std::max(current_time - peer.m_addr_token_timestamp, 0us);
const double increment = Ticks<SecondsDouble>(time_diff) * MAX_ADDR_RATE_PER_SECOND;
- peer->m_addr_token_bucket = std::min<double>(peer->m_addr_token_bucket + increment, MAX_ADDR_PROCESSING_TOKEN_BUCKET);
+ peer.m_addr_token_bucket = std::min<double>(peer.m_addr_token_bucket + increment, MAX_ADDR_PROCESSING_TOKEN_BUCKET);
}
- peer->m_addr_token_timestamp = current_time;
+ peer.m_addr_token_timestamp = current_time;
const bool rate_limited = !pfrom.HasPermission(NetPermissionFlags::Addr);
uint64_t num_proc = 0;
@@ -4045,13 +4044,13 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
return;
// Apply rate limiting.
- if (peer->m_addr_token_bucket < 1.0) {
+ if (peer.m_addr_token_bucket < 1.0) {
if (rate_limited) {
++num_rate_limit;
continue;
}
} else {
- peer->m_addr_token_bucket -= 1.0;
+ peer.m_addr_token_bucket -= 1.0;
}
// We only bother storing full nodes, though this may include
// things which we would not make an outbound connection to, in
@@ -4062,14 +4061,14 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
if (addr.nTime <= NodeSeconds{100000000s} || addr.nTime > current_a_time + 10min) {
addr.nTime = current_a_time - 5 * 24h;
}
- AddAddressKnown(*peer, addr);
+ AddAddressKnown(peer, addr);
if (m_banman && (m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr))) {
// Do not process banned/discouraged addresses beyond remembering we received them
continue;
}
++num_proc;
const bool reachable{g_reachable_nets.Contains(addr)};
- if (addr.nTime > current_a_time - 10min && !peer->m_getaddr_sent && vAddr.size() <= 10 && addr.IsRoutable()) {
+ if (addr.nTime > current_a_time - 10min && !peer.m_getaddr_sent && vAddr.size() <= 10 && addr.IsRoutable()) {
// Relay to a limited number of other nodes
RelayAddress(pfrom.GetId(), addr, reachable);
}
@@ -4078,13 +4077,13 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
vAddrOk.push_back(addr);
}
}
- peer->m_addr_processed += num_proc;
- peer->m_addr_rate_limited += num_rate_limit;
+ peer.m_addr_processed += num_proc;
+ peer.m_addr_rate_limited += num_rate_limit;
LogDebug(BCLog::NET, "Received addr: %u addresses (%u processed, %u rate-limited) from peer=%d\n",
vAddr.size(), num_proc, num_rate_limit, pfrom.GetId());
m_addrman.Add(vAddrOk, pfrom.addr, 2h);
- if (vAddr.size() < 1000) peer->m_getaddr_sent = false;
+ if (vAddr.size() < 1000) peer.m_getaddr_sent = false;
// AddrFetch: Require multiple addresses to avoid disconnecting on self-announcements
if (pfrom.IsAddrFetchConn() && vAddr.size() > 1) {
@@ -4099,7 +4098,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
vRecv >> vInv;
if (vInv.size() > MAX_INV_SZ)
{
- Misbehaving(*peer, strprintf("inv message size = %u", vInv.size()));
+ Misbehaving(peer, strprintf("inv message size = %u", vInv.size()));
return;
}
@@ -4116,7 +4115,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Ignore INVs that don't match wtxidrelay setting.
// Note that orphan parent fetching always uses MSG_TX GETDATAs regardless of the wtxidrelay setting.
// This is fine as no INV messages are involved in that process.
- if (peer->m_wtxid_relay) {
+ if (peer.m_wtxid_relay) {
if (inv.IsMsgTx()) continue;
} else {
if (inv.IsMsgWtx()) continue;
@@ -4143,7 +4142,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
return;
}
const GenTxid gtxid = ToGenTxid(inv);
- AddKnownTx(*peer, inv.hash);
+ AddKnownTx(peer, inv.hash);
if (!m_chainman.IsInitialBlockDownload()) {
const bool fAlreadyHave{m_txdownloadman.AddTxAnnouncement(pfrom.GetId(), gtxid, current_time)};
@@ -4166,14 +4165,14 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// our initial peer is unresponsive (but less bandwidth than we'd
// use if we turned on sync with all peers).
CNodeState& state{*Assert(State(pfrom.GetId()))};
- if (state.fSyncStarted || (!peer->m_inv_triggered_getheaders_before_sync && *best_block != m_last_block_inv_triggering_headers_sync)) {
- if (MaybeSendGetHeaders(pfrom, GetLocator(m_chainman.m_best_header), *peer)) {
+ if (state.fSyncStarted || (!peer.m_inv_triggered_getheaders_before_sync && *best_block != m_last_block_inv_triggering_headers_sync)) {
+ if (MaybeSendGetHeaders(pfrom, GetLocator(m_chainman.m_best_header), peer)) {
LogDebug(BCLog::NET, "getheaders (%d) %s to peer=%d\n",
m_chainman.m_best_header->nHeight, best_block->ToString(),
pfrom.GetId());
}
if (!state.fSyncStarted) {
- peer->m_inv_triggered_getheaders_before_sync = true;
+ peer.m_inv_triggered_getheaders_before_sync = true;
// Update the last block hash that triggered a new headers
// sync, so that we don't turn on headers sync with more
// than 1 new peer every new block.
@@ -4190,7 +4189,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
vRecv >> vInv;
if (vInv.size() > MAX_INV_SZ)
{
- Misbehaving(*peer, strprintf("getdata message size = %u", vInv.size()));
+ Misbehaving(peer, strprintf("getdata message size = %u", vInv.size()));
return;
}
@@ -4217,8 +4216,8 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
MakeAndPushMessage(pfrom, NetMsgType::TX, TX_WITH_WITNESS(*pushed_tx));
- peer->m_ping_queued = true; // Ensure a ping will be sent: mimic a request via RPC.
- MaybeSendPing(pfrom, *peer, GetTime<std::chrono::microseconds>());
+ peer.m_ping_queued = true; // Ensure a ping will be sent: mimic a request via RPC.
+ MaybeSendPing(pfrom, peer, GetTime<std::chrono::microseconds>());
} else {
LogDebug(BCLog::PRIVBROADCAST, "Disconnecting: got an unexpected GETDATA message, peer=%d%s",
pfrom.GetId(), fLogIPs ? strprintf(", peeraddr=%s", pfrom.addr.ToStringAddrPort()) : "");
@@ -4228,9 +4227,9 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
}
{
- LOCK(peer->m_getdata_requests_mutex);
- peer->m_getdata_requests.insert(peer->m_getdata_requests.end(), vInv.begin(), vInv.end());
- ProcessGetData(pfrom, *peer, interruptMsgProc);
+ LOCK(peer.m_getdata_requests_mutex);
+ peer.m_getdata_requests.insert(peer.m_getdata_requests.end(), vInv.begin(), vInv.end());
+ ProcessGetData(pfrom, peer, interruptMsgProc);
}
return;
@@ -4290,12 +4289,12 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
LogDebug(BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
break;
}
- WITH_LOCK(peer->m_block_inv_mutex, peer->m_blocks_for_inv_relay.push_back(pindex->GetBlockHash()));
+ WITH_LOCK(peer.m_block_inv_mutex, peer.m_blocks_for_inv_relay.push_back(pindex->GetBlockHash()));
if (--nLimit <= 0) {
// When this block is requested, we'll send an inv that'll
// trigger the peer to getblocks the next batch of inventory.
LogDebug(BCLog::NET, " getblocks stopping at limit %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
- WITH_LOCK(peer->m_block_inv_mutex, {peer->m_continuation_block = pindex->GetBlockHash();});
+ WITH_LOCK(peer.m_block_inv_mutex, {peer.m_continuation_block = pindex->GetBlockHash();});
break;
}
}
@@ -4319,7 +4318,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Unlock m_most_recent_block_mutex to avoid cs_main lock inversion
}
if (recent_block) {
- SendBlockTransactions(pfrom, *peer, *recent_block, req);
+ SendBlockTransactions(pfrom, peer, *recent_block, req);
return;
}
@@ -4345,7 +4344,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// pruned after we release cs_main above, so this read should never fail.
assert(ret);
- SendBlockTransactions(pfrom, *peer, block, req);
+ SendBlockTransactions(pfrom, peer, block, req);
return;
}
@@ -4358,7 +4357,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// actually receive all the data read from disk over the network.
LogDebug(BCLog::NET, "Peer %d sent us a getblocktxn for a block > %i deep\n", pfrom.GetId(), MAX_BLOCKTXN_DEPTH);
CInv inv{MSG_WITNESS_BLOCK, req.blockhash};
- WITH_LOCK(peer->m_getdata_requests_mutex, peer->m_getdata_requests.push_back(inv));
+ WITH_LOCK(peer.m_getdata_requests_mutex, peer.m_getdata_requests.push_back(inv));
// The message processing loop will go around again (without pausing) and we'll respond then
return;
}
@@ -4461,8 +4460,8 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
const Txid& txid = ptx->GetHash();
const Wtxid& wtxid = ptx->GetWitnessHash();
- const uint256& hash = peer->m_wtxid_relay ? wtxid.ToUint256() : txid.ToUint256();
- AddKnownTx(*peer, hash);
+ const uint256& hash = peer.m_wtxid_relay ? wtxid.ToUint256() : txid.ToUint256();
+ AddKnownTx(peer, hash);
if (const auto num_broadcasted{m_tx_for_private_broadcast.Remove(ptx)}) {
LogDebug(BCLog::PRIVBROADCAST, "Received our privately broadcast transaction (txid=%s) from the "
@@ -4545,7 +4544,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
if (!prev_block) {
// Doesn't connect (or is genesis), instead of DoSing in AcceptBlockHeader, request deeper headers
if (!m_chainman.IsInitialBlockDownload()) {
- MaybeSendGetHeaders(pfrom, GetLocator(m_chainman.m_best_header), *peer);
+ MaybeSendGetHeaders(pfrom, GetLocator(m_chainman.m_best_header), peer);
}
return;
} else if (prev_block->nChainWork + GetBlockProof(cmpctblock.header) < GetAntiDoSWorkThreshold()) {
@@ -4621,7 +4620,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// We requested this block for some reason, but our mempool will probably be useless
// so we just grab the block via normal getdata
std::vector<CInv> vInv(1);
- vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(*peer), blockhash);
+ vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(peer), blockhash);
MakeAndPushMessage(pfrom, NetMsgType::GETDATA, vInv);
}
return;
@@ -4652,13 +4651,13 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
ReadStatus status = partialBlock.InitData(cmpctblock, vExtraTxnForCompact);
if (status == READ_STATUS_INVALID) {
RemoveBlockRequest(pindex->GetBlockHash(), pfrom.GetId()); // Reset in-flight state in case Misbehaving does not result in a disconnect
- Misbehaving(*peer, "invalid compact block");
+ Misbehaving(peer, "invalid compact block");
return;
} else if (status == READ_STATUS_FAILED) {
if (first_in_flight) {
// Duplicate txindexes, the block is now in-flight, so just request it
std::vector<CInv> vInv(1);
- vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(*peer), blockhash);
+ vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(peer), blockhash);
MakeAndPushMessage(pfrom, NetMsgType::GETDATA, vInv);
} else {
// Give up for this peer and wait for other peer(s)
@@ -4718,7 +4717,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// We requested this block, but its far into the future, so our
// mempool will probably be useless - request the block normally
std::vector<CInv> vInv(1);
- vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(*peer), blockhash);
+ vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(peer), blockhash);
MakeAndPushMessage(pfrom, NetMsgType::GETDATA, vInv);
return;
} else {
@@ -4731,7 +4730,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
if (fProcessBLOCKTXN) {
BlockTransactions txn;
txn.blockhash = blockhash;
- return ProcessCompactBlockTxns(pfrom, *peer, txn);
+ return ProcessCompactBlockTxns(pfrom, peer, txn);
}
if (fRevertToHeaderProcessing) {
@@ -4740,7 +4739,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// the peer if the header turns out to be for an invalid block.
// Note that if a peer tries to build on an invalid chain, that
// will be detected and the peer will be disconnected/discouraged.
- return ProcessHeadersMessage(pfrom, *peer, {cmpctblock.header}, /*via_compact_block=*/true);
+ return ProcessHeadersMessage(pfrom, peer, {cmpctblock.header}, /*via_compact_block=*/true);
}
if (fBlockReconstructed) {
@@ -4783,7 +4782,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
BlockTransactions resp;
vRecv >> resp;
- return ProcessCompactBlockTxns(pfrom, *peer, resp);
+ return ProcessCompactBlockTxns(pfrom, peer, resp);
}
if (msg_type == NetMsgType::HEADERS)
@@ -4799,7 +4798,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Bypass the normal CBlock deserialization, as we don't want to risk deserializing 2000 full blocks.
unsigned int nCount = ReadCompactSize(vRecv);
if (nCount > m_opts.max_headers_result) {
- Misbehaving(*peer, strprintf("headers message size = %u", nCount));
+ Misbehaving(peer, strprintf("headers message size = %u", nCount));
return;
}
headers.resize(nCount);
@@ -4808,7 +4807,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
ReadCompactSize(vRecv); // ignore tx count; assume it is 0.
}
- ProcessHeadersMessage(pfrom, *peer, std::move(headers), /*via_compact_block=*/false);
+ ProcessHeadersMessage(pfrom, peer, std::move(headers), /*via_compact_block=*/false);
// Check if the headers presync progress needs to be reported to validation.
// This needs to be done without holding the m_headers_presync_mutex lock.
@@ -4845,9 +4844,9 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Check for possible mutation if it connects to something we know so we can check for DEPLOYMENT_SEGWIT being active
if (prev_block && IsBlockMutated(/*block=*/*pblock,
/*check_witness_root=*/DeploymentActiveAfter(prev_block, m_chainman, Consensus::DEPLOYMENT_SEGWIT))) {
- LogDebug(BCLog::NET, "Received mutated block from peer=%d\n", peer->m_id);
- Misbehaving(*peer, "mutated block");
- WITH_LOCK(cs_main, RemoveBlockRequest(pblock->GetHash(), peer->m_id));
+ LogDebug(BCLog::NET, "Received mutated block from peer=%d\n", peer.m_id);
+ Misbehaving(peer, "mutated block");
+ WITH_LOCK(cs_main, RemoveBlockRequest(pblock->GetHash(), peer.m_id));
return;
}
@@ -4887,17 +4886,17 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
// Since this must be an inbound connection, SetupAddressRelay will
// never fail.
- Assume(SetupAddressRelay(pfrom, *peer));
+ Assume(SetupAddressRelay(pfrom, peer));
// Only send one GetAddr response per connection to reduce resource waste
// and discourage addr stamping of INV announcements.
- if (peer->m_getaddr_recvd) {
+ if (peer.m_getaddr_recvd) {
LogDebug(BCLog::NET, "Ignoring repeated \"getaddr\". peer=%d\n", pfrom.GetId());
return;
}
- peer->m_getaddr_recvd = true;
+ peer.m_getaddr_recvd = true;
- peer->m_addrs_to_send.clear();
+ peer.m_addrs_to_send.clear();
std::vector<CAddress> vAddr;
if (pfrom.HasPermission(NetPermissionFlags::Addr)) {
vAddr = m_connman.GetAddressesUnsafe(MAX_ADDR_TO_SEND, MAX_PCT_ADDR_TO_SEND, /*network=*/std::nullopt);
@@ -4905,7 +4904,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
vAddr = m_connman.GetAddresses(pfrom, MAX_ADDR_TO_SEND, MAX_PCT_ADDR_TO_SEND);
}
for (const CAddress &addr : vAddr) {
- PushAddress(*peer, addr);
+ PushAddress(peer, addr);
}
return;
}
@@ -4913,7 +4912,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
if (msg_type == NetMsgType::MEMPOOL) {
// Only process received mempool messages if we advertise NODE_BLOOM
// or if the peer has mempool permissions.
- if (!(peer->m_our_services & NODE_BLOOM) && !pfrom.HasPermission(NetPermissionFlags::Mempool))
+ if (!(peer.m_our_services & NODE_BLOOM) && !pfrom.HasPermission(NetPermissionFlags::Mempool))
{
if (!pfrom.HasPermission(NetPermissionFlags::NoBan))
{
@@ -4933,7 +4932,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
return;
}
- if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
+ if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
LOCK(tx_relay->m_tx_inventory_mutex);
tx_relay->m_send_mempool = true;
}
@@ -4971,11 +4970,11 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
vRecv >> nonce;
// Only process pong message if there is an outstanding ping (old ping without nonce should never pong)
- if (peer->m_ping_nonce_sent != 0) {
- if (nonce == peer->m_ping_nonce_sent) {
+ if (peer.m_ping_nonce_sent != 0) {
+ if (nonce == peer.m_ping_nonce_sent) {
// Matching pong received, this ping is no longer outstanding
bPingFinished = true;
- const auto ping_time = ping_end - peer->m_ping_start.load();
+ const auto ping_time = ping_end - peer.m_ping_start.load();
if (ping_time.count() >= 0) {
// Let connman know about this successful ping-pong
pfrom.PongReceived(ping_time);
@@ -5011,18 +5010,18 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
LogDebug(BCLog::NET, "pong peer=%d: %s, %x expected, %x received, %u bytes\n",
pfrom.GetId(),
sProblem,
- peer->m_ping_nonce_sent,
+ peer.m_ping_nonce_sent,
nonce,
nAvail);
}
if (bPingFinished) {
- peer->m_ping_nonce_sent = 0;
+ peer.m_ping_nonce_sent = 0;
}
return;
}
if (msg_type == NetMsgType::FILTERLOAD) {
- if (!(peer->m_our_services & NODE_BLOOM)) {
+ if (!(peer.m_our_services & NODE_BLOOM)) {
LogDebug(BCLog::NET, "filterload received despite not offering bloom services, %s\n", pfrom.DisconnectMsg(fLogIPs));
pfrom.fDisconnect = true;
return;
@@ -5033,8 +5032,8 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
if (!filter.IsWithinSizeConstraints())
{
// There is no excuse for sending a too-large filter
- Misbehaving(*peer, "too-large bloom filter");
- } else if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
+ Misbehaving(peer, "too-large bloom filter");
+ } else if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
{
LOCK(tx_relay->m_bloom_filter_mutex);
tx_relay->m_bloom_filter.reset(new CBloomFilter(filter));
@@ -5047,7 +5046,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
}
if (msg_type == NetMsgType::FILTERADD) {
- if (!(peer->m_our_services & NODE_BLOOM)) {
+ if (!(peer.m_our_services & NODE_BLOOM)) {
LogDebug(BCLog::NET, "filteradd received despite not offering bloom services, %s\n", pfrom.DisconnectMsg(fLogIPs));
pfrom.fDisconnect = true;
return;
@@ -5060,7 +5059,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
bool bad = false;
if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE) {
bad = true;
- } else if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
+ } else if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
LOCK(tx_relay->m_bloom_filter_mutex);
if (tx_relay->m_bloom_filter) {
tx_relay->m_bloom_filter->insert(vData);
@@ -5069,18 +5068,18 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
}
}
if (bad) {
- Misbehaving(*peer, "bad filteradd message");
+ Misbehaving(peer, "bad filteradd message");
}
return;
}
if (msg_type == NetMsgType::FILTERCLEAR) {
- if (!(peer->m_our_services & NODE_BLOOM)) {
+ if (!(peer.m_our_services & NODE_BLOOM)) {
LogDebug(BCLog::NET, "filterclear received despite not offering bloom services, %s\n", pfrom.DisconnectMsg(fLogIPs));
pfrom.fDisconnect = true;
return;
}
- auto tx_relay = peer->GetTxRelay();
+ auto tx_relay = peer.GetTxRelay();
if (!tx_relay) return;
{
@@ -5097,7 +5096,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
CAmount newFeeFilter = 0;
vRecv >> newFeeFilter;
if (MoneyRange(newFeeFilter)) {
- if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
+ if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
tx_relay->m_fee_filter_received = newFeeFilter;
}
LogDebug(BCLog::NET, "received: feefilter of %s from peer=%d\n", CFeeRate(newFeeFilter).ToString(), pfrom.GetId());
@@ -5106,17 +5105,17 @@ void PeerManagerImpl::ProcessMessage(Peer& peer_alias_removed_in_later_commit, C
}
if (msg_type == NetMsgType::GETCFILTERS) {
- ProcessGetCFilters(pfrom, *peer, vRecv);
+ ProcessGetCFilters(pfrom, peer, vRecv);
return;
}
if (msg_type == NetMsgType::GETCFHEADERS) {
- ProcessGetCFHeaders(pfrom, *peer, vRecv);
+ ProcessGetCFHeaders(pfrom, peer, vRecv);
return;
}
if (msg_type == NetMsgType::GETCFCHECKPT) {
- ProcessGetCFCheckPt(pfrom, *peer, vRecv);
+ ProcessGetCFCheckPt(pfrom, peer, vRecv);
return;
}
@@ -5185,25 +5184,24 @@ bool PeerManagerImpl::ProcessMessages(CNode& node, std::atomic<bool>& interruptM
AssertLockNotHeld(m_tx_download_mutex);
AssertLockHeld(g_msgproc_mutex);
- CNode* pfrom{&node}; // alias removed in a later commit.
- PeerRef maybe_peer{GetPeerRef(pfrom->GetId())};
+ PeerRef maybe_peer{GetPeerRef(node.GetId())};
if (maybe_peer == nullptr) return false;
- auto& peer{maybe_peer}; // alias cleaned up in later commit.
+ Peer& peer{*maybe_peer};
// For outbound connections, ensure that the initial VERSION message
// has been sent first before processing any incoming messages
- if (!pfrom->IsInboundConn() && !peer->m_outbound_version_message_sent) return false;
+ if (!node.IsInboundConn() && !peer.m_outbound_version_message_sent) return false;
{
- LOCK(peer->m_getdata_requests_mutex);
- if (!peer->m_getdata_requests.empty()) {
- ProcessGetData(*pfrom, *peer, interruptMsgProc);
+ LOCK(peer.m_getdata_requests_mutex);
+ if (!peer.m_getdata_requests.empty()) {
+ ProcessGetData(node, peer, interruptMsgProc);
}
}
- const bool processed_orphan = ProcessOrphanTx(*peer);
+ const bool processed_orphan = ProcessOrphanTx(peer);
- if (pfrom->fDisconnect)
+ if (node.fDisconnect)
return false;
if (processed_orphan) return true;
@@ -5211,14 +5209,14 @@ bool PeerManagerImpl::ProcessMessages(CNode& node, std::atomic<bool>& interruptM
// this maintains the order of responses
// and prevents m_getdata_requests to grow unbounded
{
- LOCK(peer->m_getdata_requests_mutex);
- if (!peer->m_getdata_requests.empty()) return true;
+ LOCK(peer.m_getdata_requests_mutex);
+ if (!peer.m_getdata_requests.empty()) return true;
}
// Don't bother if send buffer is too full to respond anyway
- if (pfrom->fPauseSend) return false;
+ if (node.fPauseSend) return false;
- auto poll_result{pfrom->PollMessage()};
+ auto poll_result{node.PollMessage()};
if (!poll_result) {
// No message to process
return false;
@@ -5228,24 +5226,24 @@ bool PeerManagerImpl::ProcessMessages(CNode& node, std::atomic<bool>& interruptM
bool fMoreWork = poll_result->second;
TRACEPOINT(net, inbound_message,
- pfrom->GetId(),
- pfrom->m_addr_name.c_str(),
- pfrom->ConnectionTypeAsString().c_str(),
+ node.GetId(),
+ node.m_addr_name.c_str(),
+ node.ConnectionTypeAsString().c_str(),
msg.m_type.c_str(),
msg.m_recv.size(),
msg.m_recv.data()
);
if (m_opts.capture_messages) {
- CaptureMessage(pfrom->addr, msg.m_type, MakeUCharSpan(msg.m_recv), /*is_incoming=*/true);
+ CaptureMessage(node.addr, msg.m_type, MakeUCharSpan(msg.m_recv), /*is_incoming=*/true);
}
try {
- ProcessMessage(*peer, *pfrom, msg.m_type, msg.m_recv, msg.m_time, interruptMsgProc);
+ ProcessMessage(peer, node, msg.m_type, msg.m_recv, msg.m_time, interruptMsgProc);
if (interruptMsgProc) return false;
{
- LOCK(peer->m_getdata_requests_mutex);
- if (!peer->m_getdata_requests.empty()) fMoreWork = true;
+ LOCK(peer.m_getdata_requests_mutex);
+ if (!peer.m_getdata_requests.empty()) fMoreWork = true;
}
// Does this peer has an orphan ready to reconsider?
// (Note: we may have provided a parent for an orphan provided
@@ -5253,7 +5251,7 @@ bool PeerManagerImpl::ProcessMessages(CNode& node, std::atomic<bool>& interruptM
// the extra work may not be noticed, possibly resulting in an
// unnecessary 100ms delay)
LOCK(m_tx_download_mutex);
- if (m_txdownloadman.HaveMoreWork(peer->m_id)) fMoreWork = true;
+ if (m_txdownloadman.HaveMoreWork(peer.m_id)) fMoreWork = true;
} catch (const std::exception& e) {
LogDebug(BCLog::NET, "%s(%s, %u bytes): Exception '%s' (%s) caught\n", __func__, SanitizeString(msg.m_type), msg.m_message_size, e.what(), typeid(e).name());
} catch (...) {
@@ -5689,24 +5687,23 @@ bool PeerManagerImpl::SendMessages(CNode& node)
AssertLockNotHeld(m_tx_download_mutex);
AssertLockHeld(g_msgproc_mutex);
- CNode* pto{&node}; // alias removed in a later commit
- PeerRef maybe_peer{GetPeerRef(pto->GetId())};
+ PeerRef maybe_peer{GetPeerRef(node.GetId())};
if (!maybe_peer) return false;
- auto& peer{maybe_peer}; // alias cleaned up in later commit
+ Peer& peer{*maybe_peer};
const Consensus::Params& consensusParams = m_chainparams.GetConsensus();
// We must call MaybeDiscourageAndDisconnect first, to ensure that we'll
// disconnect misbehaving peers even before the version handshake is complete.
- if (MaybeDiscourageAndDisconnect(*pto, *peer)) return true;
+ if (MaybeDiscourageAndDisconnect(node, peer)) return true;
// Initiate version handshake for outbound connections
- if (!pto->IsInboundConn() && !peer->m_outbound_version_message_sent) {
- PushNodeVersion(*pto, *peer);
- peer->m_outbound_version_message_sent = true;
+ if (!node.IsInboundConn() && !peer.m_outbound_version_message_sent) {
+ PushNodeVersion(node, peer);
+ peer.m_outbound_version_message_sent = true;
}
// Don't send anything until the version handshake is complete
- if (!pto->fSuccessfullyConnected || pto->fDisconnect)
+ if (!node.fSuccessfullyConnected || node.fDisconnect)
return true;
const auto current_time{GetTime<std::chrono::microseconds>()};
@@ -5714,34 +5711,34 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// The logic below does not apply to private broadcast peers, so skip it.
// Also in CConnman::PushMessage() we make sure that unwanted messages are
// not sent. This here is just an optimization.
- if (pto->IsPrivateBroadcastConn()) {
- if (pto->m_connected + PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME < current_time) {
+ if (node.IsPrivateBroadcastConn()) {
+ if (node.m_connected + PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME < current_time) {
LogDebug(BCLog::PRIVBROADCAST, "Disconnecting: did not complete the transaction send within %d seconds, peer=%d%s",
- count_seconds(PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME), pto->GetId(), pto->LogIP(fLogIPs));
- pto->fDisconnect = true;
+ count_seconds(PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME), node.GetId(), node.LogIP(fLogIPs));
+ node.fDisconnect = true;
}
return true;
}
- if (pto->IsAddrFetchConn() && current_time - pto->m_connected > 10 * AVG_ADDRESS_BROADCAST_INTERVAL) {
- LogDebug(BCLog::NET, "addrfetch connection timeout, %s\n", pto->DisconnectMsg(fLogIPs));
- pto->fDisconnect = true;
+ if (node.IsAddrFetchConn() && current_time - node.m_connected > 10 * AVG_ADDRESS_BROADCAST_INTERVAL) {
+ LogDebug(BCLog::NET, "addrfetch connection timeout, %s\n", node.DisconnectMsg(fLogIPs));
+ node.fDisconnect = true;
return true;
}
- MaybeSendPing(*pto, *peer, current_time);
+ MaybeSendPing(node, peer, current_time);
// MaybeSendPing may have marked peer for disconnection
- if (pto->fDisconnect) return true;
+ if (node.fDisconnect) return true;
- MaybeSendAddr(*pto, *peer, current_time);
+ MaybeSendAddr(node, peer, current_time);
- MaybeSendSendHeaders(*pto, *peer);
+ MaybeSendSendHeaders(node, peer);
{
LOCK(cs_main);
- CNodeState &state = *State(pto->GetId());
+ CNodeState &state = *State(node.GetId());
// Start block sync
if (m_chainman.m_best_header == nullptr) {
@@ -5754,7 +5751,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
bool sync_blocks_and_headers_from_peer = false;
if (state.fPreferredDownload) {
sync_blocks_and_headers_from_peer = true;
- } else if (CanServeBlocks(*peer) && !pto->IsAddrFetchConn()) {
+ } else if (CanServeBlocks(peer) && !node.IsAddrFetchConn()) {
// Typically this is an inbound peer. If we don't have any outbound
// peers, or if we aren't downloading any blocks from such peers,
// then allow block downloads from this peer, too.
@@ -5769,7 +5766,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
}
}
- if (!state.fSyncStarted && CanServeBlocks(*peer) && !m_chainman.m_blockman.LoadingBlocks()) {
+ if (!state.fSyncStarted && CanServeBlocks(peer) && !m_chainman.m_blockman.LoadingBlocks()) {
// Only actively request headers from a single peer, unless we're close to today.
if ((nSyncStarted == 0 && sync_blocks_and_headers_from_peer) || m_chainman.m_best_header->Time() > NodeClock::now() - 24h) {
const CBlockIndex* pindexStart = m_chainman.m_best_header;
@@ -5782,11 +5779,11 @@ bool PeerManagerImpl::SendMessages(CNode& node)
got back an empty response. */
if (pindexStart->pprev)
pindexStart = pindexStart->pprev;
- if (MaybeSendGetHeaders(*pto, GetLocator(pindexStart), *peer)) {
- LogDebug(BCLog::NET, "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->nHeight, pto->GetId(), peer->m_starting_height);
+ if (MaybeSendGetHeaders(node, GetLocator(pindexStart), peer)) {
+ LogDebug(BCLog::NET, "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->nHeight, node.GetId(), peer.m_starting_height);
state.fSyncStarted = true;
- peer->m_headers_sync_timeout = current_time + HEADERS_DOWNLOAD_TIMEOUT_BASE +
+ peer.m_headers_sync_timeout = current_time + HEADERS_DOWNLOAD_TIMEOUT_BASE +
(
// Convert HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER to microseconds before scaling
// to maintain precision
@@ -5809,20 +5806,20 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// If no header would connect, or if we have too many
// blocks, or if the peer doesn't want headers, just
// add all to the inv queue.
- LOCK(peer->m_block_inv_mutex);
+ LOCK(peer.m_block_inv_mutex);
std::vector<CBlock> vHeaders;
- bool fRevertToInv = ((!peer->m_prefers_headers &&
- (!state.m_requested_hb_cmpctblocks || peer->m_blocks_for_headers_relay.size() > 1)) ||
- peer->m_blocks_for_headers_relay.size() > MAX_BLOCKS_TO_ANNOUNCE);
+ bool fRevertToInv = ((!peer.m_prefers_headers &&
+ (!state.m_requested_hb_cmpctblocks || peer.m_blocks_for_headers_relay.size() > 1)) ||
+ peer.m_blocks_for_headers_relay.size() > MAX_BLOCKS_TO_ANNOUNCE);
const CBlockIndex *pBestIndex = nullptr; // last header queued for delivery
- ProcessBlockAvailability(pto->GetId()); // ensure pindexBestKnownBlock is up-to-date
+ ProcessBlockAvailability(node.GetId()); // ensure pindexBestKnownBlock is up-to-date
if (!fRevertToInv) {
bool fFoundStartingHeader = false;
// Try to find first header that our peer doesn't have, and
// then send all headers past that one. If we come across any
// headers that aren't on m_chainman.ActiveChain(), give up.
- for (const uint256& hash : peer->m_blocks_for_headers_relay) {
+ for (const uint256& hash : peer.m_blocks_for_headers_relay) {
const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(hash);
assert(pindex);
if (m_chainman.ActiveChain()[pindex->nHeight] != pindex) {
@@ -5869,7 +5866,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// We only send up to 1 block as header-and-ids, as otherwise
// probably means we're doing an initial-ish-sync or they're slow
LogDebug(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", __func__,
- vHeaders.front().GetHash().ToString(), pto->GetId());
+ vHeaders.front().GetHash().ToString(), node.GetId());
std::optional<CSerializedNetMsg> cached_cmpctblock_msg;
{
@@ -5879,26 +5876,26 @@ bool PeerManagerImpl::SendMessages(CNode& node)
}
}
if (cached_cmpctblock_msg.has_value()) {
- PushMessage(*pto, std::move(cached_cmpctblock_msg.value()));
+ PushMessage(node, std::move(cached_cmpctblock_msg.value()));
} else {
CBlock block;
const bool ret{m_chainman.m_blockman.ReadBlock(block, *pBestIndex)};
assert(ret);
CBlockHeaderAndShortTxIDs cmpctblock{block, m_rng.rand64()};
- MakeAndPushMessage(*pto, NetMsgType::CMPCTBLOCK, cmpctblock);
+ MakeAndPushMessage(node, NetMsgType::CMPCTBLOCK, cmpctblock);
}
state.pindexBestHeaderSent = pBestIndex;
- } else if (peer->m_prefers_headers) {
+ } else if (peer.m_prefers_headers) {
if (vHeaders.size() > 1) {
LogDebug(BCLog::NET, "%s: %u headers, range (%s, %s), to peer=%d\n", __func__,
vHeaders.size(),
vHeaders.front().GetHash().ToString(),
- vHeaders.back().GetHash().ToString(), pto->GetId());
+ vHeaders.back().GetHash().ToString(), node.GetId());
} else {
LogDebug(BCLog::NET, "%s: sending header %s to peer=%d\n", __func__,
- vHeaders.front().GetHash().ToString(), pto->GetId());
+ vHeaders.front().GetHash().ToString(), node.GetId());
}
- MakeAndPushMessage(*pto, NetMsgType::HEADERS, TX_WITH_WITNESS(vHeaders));
+ MakeAndPushMessage(node, NetMsgType::HEADERS, TX_WITH_WITNESS(vHeaders));
state.pindexBestHeaderSent = pBestIndex;
} else
fRevertToInv = true;
@@ -5907,8 +5904,8 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// If falling back to using an inv, just try to inv the tip.
// The last entry in m_blocks_for_headers_relay was our tip at some point
// in the past.
- if (!peer->m_blocks_for_headers_relay.empty()) {
- const uint256& hashToAnnounce = peer->m_blocks_for_headers_relay.back();
+ if (!peer.m_blocks_for_headers_relay.empty()) {
+ const uint256& hashToAnnounce = peer.m_blocks_for_headers_relay.back();
const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(hashToAnnounce);
assert(pindex);
@@ -5922,13 +5919,13 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// If the peer's chain has this block, don't inv it back.
if (!PeerHasHeader(&state, pindex)) {
- peer->m_blocks_for_inv_relay.push_back(hashToAnnounce);
+ peer.m_blocks_for_inv_relay.push_back(hashToAnnounce);
LogDebug(BCLog::NET, "%s: sending inv peer=%d hash=%s\n", __func__,
- pto->GetId(), hashToAnnounce.ToString());
+ node.GetId(), hashToAnnounce.ToString());
}
}
}
- peer->m_blocks_for_headers_relay.clear();
+ peer.m_blocks_for_headers_relay.clear();
}
//
@@ -5936,28 +5933,28 @@ bool PeerManagerImpl::SendMessages(CNode& node)
//
std::vector<CInv> vInv;
{
- LOCK(peer->m_block_inv_mutex);
- vInv.reserve(std::max<size_t>(peer->m_blocks_for_inv_relay.size(), INVENTORY_BROADCAST_TARGET));
+ LOCK(peer.m_block_inv_mutex);
+ vInv.reserve(std::max<size_t>(peer.m_blocks_for_inv_relay.size(), INVENTORY_BROADCAST_TARGET));
// Add blocks
- for (const uint256& hash : peer->m_blocks_for_inv_relay) {
+ for (const uint256& hash : peer.m_blocks_for_inv_relay) {
vInv.emplace_back(MSG_BLOCK, hash);
if (vInv.size() == MAX_INV_SZ) {
- MakeAndPushMessage(*pto, NetMsgType::INV, vInv);
+ MakeAndPushMessage(node, NetMsgType::INV, vInv);
vInv.clear();
}
}
- peer->m_blocks_for_inv_relay.clear();
+ peer.m_blocks_for_inv_relay.clear();
}
- if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
+ if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
LOCK(tx_relay->m_tx_inventory_mutex);
// Check whether periodic sends should happen
- bool fSendTrickle = pto->HasPermission(NetPermissionFlags::NoBan);
+ bool fSendTrickle = node.HasPermission(NetPermissionFlags::NoBan);
if (tx_relay->m_next_inv_send_time < current_time) {
fSendTrickle = true;
- if (pto->IsInboundConn()) {
- tx_relay->m_next_inv_send_time = NextInvToInbounds(current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL, pto->m_network_key);
+ if (node.IsInboundConn()) {
+ tx_relay->m_next_inv_send_time = NextInvToInbounds(current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL, node.m_network_key);
} else {
tx_relay->m_next_inv_send_time = current_time + m_rng.rand_exp_duration(OUTBOUND_INVENTORY_BROADCAST_INTERVAL);
}
@@ -5980,7 +5977,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
for (const auto& txinfo : vtxinfo) {
const Txid& txid{txinfo.tx->GetHash()};
const Wtxid& wtxid{txinfo.tx->GetWitnessHash()};
- const auto inv = peer->m_wtxid_relay ?
+ const auto inv = peer.m_wtxid_relay ?
CInv{MSG_WTX, wtxid.ToUint256()} :
CInv{MSG_TX, txid.ToUint256()};
tx_relay->m_tx_inventory_to_send.erase(wtxid);
@@ -5995,7 +5992,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
tx_relay->m_tx_inventory_known_filter.insert(inv.hash);
vInv.push_back(inv);
if (vInv.size() == MAX_INV_SZ) {
- MakeAndPushMessage(*pto, NetMsgType::INV, vInv);
+ MakeAndPushMessage(node, NetMsgType::INV, vInv);
vInv.clear();
}
}
@@ -6036,7 +6033,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// `TxRelay::m_tx_inventory_known_filter` contains either txids or wtxids
// depending on whether our peer supports wtxid-relay. Therefore, first
// construct the inv and then use its hash for the filter check.
- const auto inv = peer->m_wtxid_relay ?
+ const auto inv = peer.m_wtxid_relay ?
CInv{MSG_WTX, wtxid.ToUint256()} :
CInv{MSG_TX, txinfo.tx->GetHash().ToUint256()};
// Check if not in the filter already
@@ -6052,7 +6049,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
vInv.push_back(inv);
nRelayedTransactions++;
if (vInv.size() == MAX_INV_SZ) {
- MakeAndPushMessage(*pto, NetMsgType::INV, vInv);
+ MakeAndPushMessage(node, NetMsgType::INV, vInv);
vInv.clear();
}
tx_relay->m_tx_inventory_known_filter.insert(inv.hash);
@@ -6064,7 +6061,7 @@ bool PeerManagerImpl::SendMessages(CNode& node)
}
}
if (!vInv.empty())
- MakeAndPushMessage(*pto, NetMsgType::INV, vInv);
+ MakeAndPushMessage(node, NetMsgType::INV, vInv);
// Detect whether we're stalling
auto stalling_timeout = m_block_stalling_timeout.load();
@@ -6072,8 +6069,8 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// Stalling only triggers when the block download window cannot move. During normal steady state,
// the download window should be much larger than the to-be-downloaded set of blocks, so disconnection
// should only happen during initial block download.
- LogInfo("Peer is stalling block download, %s\n", pto->DisconnectMsg(fLogIPs));
- pto->fDisconnect = true;
+ LogInfo("Peer is stalling block download, %s\n", node.DisconnectMsg(fLogIPs));
+ node.fDisconnect = true;
// Increase timeout for the next peer so that we don't disconnect multiple peers if our own
// bandwidth is insufficient.
const auto new_timeout = std::min(2 * stalling_timeout, BLOCK_STALLING_TIMEOUT_MAX);
@@ -6091,27 +6088,27 @@ bool PeerManagerImpl::SendMessages(CNode& node)
QueuedBlock &queuedBlock = state.vBlocksInFlight.front();
int nOtherPeersWithValidatedDownloads = m_peers_downloading_from - 1;
if (current_time > state.m_downloading_since + std::chrono::seconds{consensusParams.nPowTargetSpacing} * (BLOCK_DOWNLOAD_TIMEOUT_BASE + BLOCK_DOWNLOAD_TIMEOUT_PER_PEER * nOtherPeersWithValidatedDownloads)) {
- LogInfo("Timeout downloading block %s, %s\n", queuedBlock.pindex->GetBlockHash().ToString(), pto->DisconnectMsg(fLogIPs));
- pto->fDisconnect = true;
+ LogInfo("Timeout downloading block %s, %s\n", queuedBlock.pindex->GetBlockHash().ToString(), node.DisconnectMsg(fLogIPs));
+ node.fDisconnect = true;
return true;
}
}
// Check for headers sync timeouts
- if (state.fSyncStarted && peer->m_headers_sync_timeout < std::chrono::microseconds::max()) {
+ if (state.fSyncStarted && peer.m_headers_sync_timeout < std::chrono::microseconds::max()) {
// Detect whether this is a stalling initial-headers-sync peer
if (m_chainman.m_best_header->Time() <= NodeClock::now() - 24h) {
- if (current_time > peer->m_headers_sync_timeout && nSyncStarted == 1 && (m_num_preferred_download_peers - state.fPreferredDownload >= 1)) {
+ if (current_time > peer.m_headers_sync_timeout && nSyncStarted == 1 && (m_num_preferred_download_peers - state.fPreferredDownload >= 1)) {
// Disconnect a peer (without NetPermissionFlags::NoBan permission) if it is our only sync peer,
// and we have others we could be using instead.
// Note: If all our peers are inbound, then we won't
// disconnect our sync peer for stalling; we have bigger
// problems if we can't get any outbound peers.
- if (!pto->HasPermission(NetPermissionFlags::NoBan)) {
- LogInfo("Timeout downloading headers, %s\n", pto->DisconnectMsg(fLogIPs));
- pto->fDisconnect = true;
+ if (!node.HasPermission(NetPermissionFlags::NoBan)) {
+ LogInfo("Timeout downloading headers, %s\n", node.DisconnectMsg(fLogIPs));
+ node.fDisconnect = true;
return true;
} else {
- LogInfo("Timeout downloading headers from noban peer, not %s\n", pto->DisconnectMsg(fLogIPs));
+ LogInfo("Timeout downloading headers from noban peer, not %s\n", node.DisconnectMsg(fLogIPs));
// Reset the headers sync state so that we have a
// chance to try downloading from a different peer.
// Note: this will also result in at least one more
@@ -6119,25 +6116,25 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// this peer (eventually).
state.fSyncStarted = false;
nSyncStarted--;
- peer->m_headers_sync_timeout = 0us;
+ peer.m_headers_sync_timeout = 0us;
}
}
} else {
// After we've caught up once, reset the timeout so we can't trigger
// disconnect later.
- peer->m_headers_sync_timeout = std::chrono::microseconds::max();
+ peer.m_headers_sync_timeout = std::chrono::microseconds::max();
}
}
// Check that outbound peers have reasonable chains
// GetTime() is used by this anti-DoS logic so we can test this using mocktime
- ConsiderEviction(*pto, *peer, GetTime<std::chrono::seconds>());
+ ConsiderEviction(node, peer, GetTime<std::chrono::seconds>());
//
// Message: getdata (blocks)
//
std::vector<CInv> vGetData;
- if (CanServeBlocks(*peer) && ((sync_blocks_and_headers_from_peer && !IsLimitedPeer(*peer)) || !m_chainman.IsInitialBlockDownload()) && state.vBlocksInFlight.size() < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
+ if (CanServeBlocks(peer) && ((sync_blocks_and_headers_from_peer && !IsLimitedPeer(peer)) || !m_chainman.IsInitialBlockDownload()) && state.vBlocksInFlight.size() < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
std::vector<const CBlockIndex*> vToDownload;
NodeId staller = -1;
auto get_inflight_budget = [&state]() {
@@ -6147,23 +6144,23 @@ bool PeerManagerImpl::SendMessages(CNode& node)
// If there are multiple chainstates, download blocks for the
// current chainstate first, to prioritize getting to network tip
// before downloading historical blocks.
- FindNextBlocksToDownload(*peer, get_inflight_budget(), vToDownload, staller);
+ FindNextBlocksToDownload(peer, get_inflight_budget(), vToDownload, staller);
auto historical_blocks{m_chainman.GetHistoricalBlockRange()};
- if (historical_blocks && !IsLimitedPeer(*peer)) {
+ if (historical_blocks && !IsLimitedPeer(peer)) {
// If the first needed historical block is not an ancestor of the last,
// we need to start requesting blocks from their last common ancestor.
const CBlockIndex* from_tip = LastCommonAncestor(historical_blocks->first, historical_blocks->second);
TryDownloadingHistoricalBlocks(
- *peer,
+ peer,
get_inflight_budget(),
vToDownload, from_tip, historical_blocks->second);
}
for (const CBlockIndex *pindex : vToDownload) {
- uint32_t nFetchFlags = GetFetchFlags(*peer);
+ uint32_t nFetchFlags = GetFetchFlags(peer);
vGetData.emplace_back(MSG_BLOCK | nFetchFlags, pindex->GetBlockHash());
- BlockRequested(pto->GetId(), *pindex);
+ BlockRequested(node.GetId(), *pindex);
LogDebug(BCLog::NET, "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(),
- pindex->nHeight, pto->GetId());
+ pindex->nHeight, node.GetId());
}
if (state.vBlocksInFlight.empty() && staller != -1) {
if (State(staller)->m_stalling_since == 0us) {
@@ -6178,18 +6175,18 @@ bool PeerManagerImpl::SendMessages(CNode& node)
//
{
LOCK(m_tx_download_mutex);
- for (const GenTxid& gtxid : m_txdownloadman.GetRequestsToSend(pto->GetId(), current_time)) {
- vGetData.emplace_back(gtxid.IsWtxid() ? MSG_WTX : (MSG_TX | GetFetchFlags(*peer)), gtxid.ToUint256());
+ for (const GenTxid& gtxid : m_txdownloadman.GetRequestsToSend(node.GetId(), current_time)) {
+ vGetData.emplace_back(gtxid.IsWtxid() ? MSG_WTX : (MSG_TX | GetFetchFlags(peer)), gtxid.ToUint256());
if (vGetData.size() >= MAX_GETDATA_SZ) {
- MakeAndPushMessage(*pto, NetMsgType::GETDATA, vGetData);
+ MakeAndPushMessage(node, NetMsgType::GETDATA, vGetData);
vGetData.clear();
}
}
}
if (!vGetData.empty())
- MakeAndPushMessage(*pto, NetMsgType::GETDATA, vGetData);
+ MakeAndPushMessage(node, NetMsgType::GETDATA, vGetData);
} // release cs_main
- MaybeSendFeefilter(*pto, *peer, current_time);
+ MaybeSendFeefilter(node, peer, current_time);
return true;
}
Risk score
Our methodology →Why this scored 15/100
Human-validated context
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
No validated notes yet.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.