From c853ef002ee7074b6e20eb8f58138c8293846424 Mon Sep 17 00:00:00 2001 From: John Newbery Date: Tue, 16 Jun 2020 16:27:34 -0400 Subject: [PATCH] scripted-diff: rename vBlockHashesToAnnounce and vInventoryBlockToSend -BEGIN VERIFY SCRIPT- sed -i 's/vBlockHashesToAnnounce/m_blocks_for_headers_relay/g' src/net_processing.* sed -i 's/vInventoryBlockToSend/m_blocks_for_inv_relay/g' src/net_processing.* -END VERIFY SCRIPT- --- src/net_processing.cpp | 28 ++++++++++++++-------------- src/net_processing.h | 4 ++-- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/net_processing.cpp b/src/net_processing.cpp index 8f9eb621001..8dafd98d76e 100644 --- a/src/net_processing.cpp +++ b/src/net_processing.cpp @@ -1321,7 +1321,7 @@ void PeerManager::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockInde Peer& peer = *it.second; LOCK(peer.m_block_inv_mutex); for (const uint256& hash : reverse_iterate(vHashes)) { - peer.vBlockHashesToAnnounce.push_back(hash); + peer.m_blocks_for_headers_relay.push_back(hash); } } } @@ -2799,7 +2799,7 @@ void PeerManager::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDat LogPrint(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->vInventoryBlockToSend.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 @@ -4225,8 +4225,8 @@ bool PeerManager::SendMessages(CNode* pto) LOCK(peer->m_block_inv_mutex); std::vector vHeaders; bool fRevertToInv = ((!state.fPreferHeaders && - (!state.fPreferHeaderAndIDs || peer->vBlockHashesToAnnounce.size() > 1)) || - peer->vBlockHashesToAnnounce.size() > MAX_BLOCKS_TO_ANNOUNCE); + (!state.fPreferHeaderAndIDs || 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 @@ -4235,7 +4235,7 @@ bool PeerManager::SendMessages(CNode* pto) // 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 ::ChainActive(), give up. - for (const uint256& hash : peer->vBlockHashesToAnnounce) { + for (const uint256& hash : peer->m_blocks_for_headers_relay) { const CBlockIndex* pindex = LookupBlockIndex(hash); assert(pindex); if (::ChainActive()[pindex->nHeight] != pindex) { @@ -4252,7 +4252,7 @@ bool PeerManager::SendMessages(CNode* pto) // which should be caught by the prior check), but one // way this could happen is by using invalidateblock / // reconsiderblock repeatedly on the tip, causing it to - // be added multiple times to vBlockHashesToAnnounce. + // be added multiple times to m_blocks_for_headers_relay. // Robustly deal with this rare situation by reverting // to an inv. fRevertToInv = true; @@ -4324,10 +4324,10 @@ bool PeerManager::SendMessages(CNode* pto) } if (fRevertToInv) { // If falling back to using an inv, just try to inv the tip. - // The last entry in vBlockHashesToAnnounce was our tip at some point + // The last entry in m_blocks_for_headers_relay was our tip at some point // in the past. - if (!peer->vBlockHashesToAnnounce.empty()) { - const uint256& hashToAnnounce = peer->vBlockHashesToAnnounce.back(); + if (!peer->m_blocks_for_headers_relay.empty()) { + const uint256& hashToAnnounce = peer->m_blocks_for_headers_relay.back(); const CBlockIndex* pindex = LookupBlockIndex(hashToAnnounce); assert(pindex); @@ -4341,13 +4341,13 @@ bool PeerManager::SendMessages(CNode* pto) // If the peer's chain has this block, don't inv it back. if (!PeerHasHeader(&state, pindex)) { - peer->vInventoryBlockToSend.push_back(hashToAnnounce); + peer->m_blocks_for_inv_relay.push_back(hashToAnnounce); LogPrint(BCLog::NET, "%s: sending inv peer=%d hash=%s\n", __func__, pto->GetId(), hashToAnnounce.ToString()); } } } - peer->vBlockHashesToAnnounce.clear(); + peer->m_blocks_for_headers_relay.clear(); } // @@ -4356,17 +4356,17 @@ bool PeerManager::SendMessages(CNode* pto) std::vector vInv; { LOCK(peer->m_block_inv_mutex); - vInv.reserve(std::max(peer->vInventoryBlockToSend.size(), INVENTORY_BROADCAST_MAX)); + vInv.reserve(std::max(peer->m_blocks_for_inv_relay.size(), INVENTORY_BROADCAST_MAX)); // Add blocks - for (const uint256& hash : peer->vInventoryBlockToSend) { + for (const uint256& hash : peer->m_blocks_for_inv_relay) { vInv.push_back(CInv(MSG_BLOCK, hash)); if (vInv.size() == MAX_INV_SZ) { m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv)); vInv.clear(); } } - peer->vInventoryBlockToSend.clear(); + peer->m_blocks_for_inv_relay.clear(); if (pto->m_tx_relay != nullptr) { LOCK(pto->m_tx_relay->cs_tx_inventory); diff --git a/src/net_processing.h b/src/net_processing.h index 44c85a55baf..3080a7da4c3 100644 --- a/src/net_processing.h +++ b/src/net_processing.h @@ -68,11 +68,11 @@ struct Peer { /** List of blocks that we'll anounce via an `inv` message. * There is no final sorting before sending, as they are always sent * immediately and in the order requested. */ - std::vector vInventoryBlockToSend GUARDED_BY(m_block_inv_mutex); + std::vector m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex); /** Unfiltered list of blocks that we'd like to announce via a `headers` * message. If we can't announce via a `headers` message, we'll fall back to * announcing via `inv`. */ - std::vector vBlockHashesToAnnounce GUARDED_BY(m_block_inv_mutex); + std::vector m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex); /** This peer's reported block height when we connected */ std::atomic m_starting_height{-1};