What peer messages mean

5001            }
5002        }
5003        } // cs_main
5004
5005        if (fProcessBLOCKTXN) {
5006            BlockTransactions txn;
5007            txn.blockhash = blockhash;
5008            return ProcessCompactBlockTxns(pfrom, peer, txn);
5009        }
5010
5011        if (fRevertToHeaderProcessing) {
5012            // Headers received from HB compact block peers are permitted to be
5013            // relayed before full validation (see BIP 152), so we don't want to disconnect
5014            // the peer if the header turns out to be for an invalid block.
5015            // Note that if a peer tries to build on an invalid chain, that
5016            // will be detected and the peer will be disconnected/discouraged.
5017            return ProcessHeadersMessage(pfrom, peer, {cmpctblock.header}, /*via_compact_block=*/true);
5018        }
5019
5020        if (fBlockReconstructed) {
5021            // If we got here, we were able to optimistically reconstruct a
5022            // block that is in flight from some other peer.
5023            {
5024                LOCK(cs_main);
5025                mapBlockSource.emplace(pblock->GetHash(), std::make_pair(pfrom.GetId(), false));
5026            }
5027            // Setting force_processing to true means that we bypass some of
5028            // our anti-DoS protections in AcceptBlock, which filters
5029            // unrequested blocks that might be trying to waste our resources
5030            // (eg disk space). Because we only try to reconstruct blocks when
5031            // we're close to caught up (via the CanDirectFetch() requirement
5032            // above, combined with the behavior of not requesting blocks until
5033            // we have a chain with at least the minimum chain work), and we ignore
5034            // compact blocks with less work than our tip, it is safe to treat
5035            // reconstructed compact blocks as having been requested.
5036            ProcessBlock(pfrom, pblock, /*force_processing=*/true, /*min_pow_checked=*/true);
5037            LOCK(cs_main); // hold cs_main for CBlockIndex::IsValid()
5038            if (pindex->IsValid(BLOCK_VALID_TRANSACTIONS)) {
5039                // Clear download state for this block, which is in
5040                // process from some other peer.  We do this after calling
5041                // ProcessNewBlock so that a malleated cmpctblock announcement
5042                // can't be used to interfere with block relay.
5043                RemoveBlockRequest(pblock->GetHash(), std::nullopt);
5044            }
5045        }
5046        return;
5047    }
5048
5049    if (msg_type == NetMsgType::BLOCKTXN)
5050    {
5051        // Ignore blocktxn received while importing
5052        if (m_chainman.m_blockman.LoadingBlocks()) {
5053            LogDebug(BCLog::NET, "Unexpected blocktxn message received from peer %d\n", pfrom.GetId());
5054            return;
5055        }
5056
5057        BlockTransactions resp;
5058        vRecv >> resp;
5059
5060        return ProcessCompactBlockTxns(pfrom, peer, resp);
5061    }
5062
5063    if (msg_type == NetMsgType::HEADERS)
5064    {
5065        // Ignore headers received while importing
5066        if (m_chainman.m_blockman.LoadingBlocks()) {
5067            LogDebug(BCLog::NET, "Unexpected headers message received from peer %d\n", pfrom.GetId());
5068            return;
5069        }
5070
5071        std::vector<CBlockHeader> headers;
5072
5073        // Bypass the normal CBlock deserialization, as we don't want to risk deserializing 2000 full blocks.
5074        unsigned int nCount = ReadCompactSize(vRecv);
5075        if (nCount > m_opts.max_headers_result) {
5076            Misbehaving(peer, strprintf("headers message size = %u", nCount));
5077            return;
5078        }
5079        headers.resize(nCount);
5080        for (unsigned int n = 0; n < nCount; n++) {
5081            vRecv >> headers[n];
5082            ReadCompactSize(vRecv); // ignore tx count; assume it is 0.
5083        }
5084
5085        ProcessHeadersMessage(pfrom, peer, std::move(headers), /*via_compact_block=*/false);
5086
5087        // Check if the headers presync progress needs to be reported to validation.
5088        // This needs to be done without holding the m_headers_presync_mutex lock.
5089        if (m_headers_presync_should_signal.exchange(false)) {
5090            HeadersPresyncStats stats;
5091            {
5092                LOCK(m_headers_presync_mutex);
5093                auto it = m_headers_presync_stats.find(m_headers_presync_bestpeer);
5094                if (it != m_headers_presync_stats.end()) stats = it->second;
5095            }
5096            if (stats.second) {
5097                m_chainman.ReportHeadersPresync(stats.second->first, stats.second->second);
5098            }
5099        }
5100
5101        return;
5102    }
5103
5104    if (msg_type == NetMsgType::BLOCK)
5105    {
5106        // Ignore block received while importing
5107        if (m_chainman.m_blockman.LoadingBlocks()) {
5108            LogDebug(BCLog::NET, "Unexpected block message received from peer %d\n", pfrom.GetId());
5109            return;
5110        }
5111
5112        std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
5113        vRecv >> TX_WITH_WITNESS(*pblock);
5114
5115        LogDebug(BCLog::NET, "received block %s peer=%d\n", pblock->GetHash().ToString(), pfrom.GetId());
5116
5117        const CBlockIndex* prev_block{WITH_LOCK(m_chainman.GetMutex(), return m_chainman.m_blockman.LookupBlockIndex(pblock->hashPrevBlock))};
5118
5119        // Check for possible mutation if it connects to something we know so we can check for DEPLOYMENT_SEGWIT being active
5120        if (prev_block && IsBlockMutated(/*block=*/*pblock,
5121                           /*check_witness_root=*/DeploymentActiveAfter(prev_block, m_chainman, Consensus::DEPLOYMENT_SEGWIT))) {
5122            LogDebug(BCLog::NET, "Received mutated block from peer=%d\n", peer.m_id);
5123            Misbehaving(peer, "mutated block");
5124            WITH_LOCK(cs_main, RemoveBlockRequest(pblock->GetHash(), peer.m_id));
5125            return;
5126        }
5127
5128        bool forceProcessing = false;
5129        const uint256 hash(pblock->GetHash());
5130        bool min_pow_checked = false;
5131        {
5132            LOCK(cs_main);
5133            // Always process the block if we requested it, since we may
5134            // need it even when it's not a candidate for a new best tip.
5135            forceProcessing = IsBlockRequested(hash);
5136            RemoveBlockRequest(hash, pfrom.GetId());
5137            // mapBlockSource is only used for punishing peers and setting
5138            // which peers send us compact blocks, so the race between here and
5139            // cs_main in ProcessNewBlock is fine.
5140            mapBlockSource.emplace(hash, std::make_pair(pfrom.GetId(), true));
5141
5142            // Check claimed work on this block against our anti-dos thresholds.
5143            if (prev_block && prev_block->nChainWork + GetBlockProof(*pblock) >= GetAntiDoSWorkThreshold()) {
5144                min_pow_checked = true;
5145            }
5146        }
5147        ProcessBlock(pfrom, pblock, forceProcessing, min_pow_checked);
5148        return;
5149    }
5150
5151    if (msg_type == NetMsgType::GETADDR) {
5152        // This asymmetric behavior for inbound and outbound connections was introduced
5153        // to prevent a fingerprinting attack: an attacker can send specific fake addresses
5154        // to users' AddrMan and later request them by sending getaddr messages.
5155        // Making nodes which are behind NAT and can only make outgoing connections ignore
5156        // the getaddr message mitigates the attack.
5157        if (!pfrom.IsInboundConn()) {
5158            LogDebug(BCLog::NET, "Ignoring \"getaddr\" from %s connection. peer=%d\n", pfrom.ConnectionTypeAsString(), pfrom.GetId());
5159            return;
5160        }
5161
5162        // Since this must be an inbound connection, SetupAddressRelay will
5163        // never fail.
5164        Assume(SetupAddressRelay(pfrom, peer));
5165
5166        // Only send one GetAddr response per connection to reduce resource waste
5167        // and discourage addr stamping of INV announcements.
5168        if (peer.m_getaddr_recvd) {
5169            LogDebug(BCLog::NET, "Ignoring repeated \"getaddr\". peer=%d\n", pfrom.GetId());
5170            return;
5171        }
5172        peer.m_getaddr_recvd = true;
5173
5174        peer.m_addrs_to_send.clear();
5175        std::vector<CAddress> vAddr;
5176        if (pfrom.HasPermission(NetPermissionFlags::Addr)) {
5177            vAddr = m_connman.GetAddressesUnsafe(MAX_ADDR_TO_SEND, MAX_PCT_ADDR_TO_SEND, /*network=*/std::nullopt);
5178        } else {
5179            vAddr = m_connman.GetAddresses(pfrom, MAX_ADDR_TO_SEND, MAX_PCT_ADDR_TO_SEND);
5180        }
5181        for (const CAddress &addr : vAddr) {
5182            PushAddress(peer, addr);
5183        }
5184        return;
5185    }
5186
5187    if (msg_type == NetMsgType::MEMPOOL) {
5188        // Only process received mempool messages if we advertise NODE_BLOOM
5189        // or if the peer has mempool permissions.
5190        if (!(peer.m_our_services & NODE_BLOOM) && !pfrom.HasPermission(NetPermissionFlags::Mempool))
5191        {
5192            if (!pfrom.HasPermission(NetPermissionFlags::NoBan))
5193            {
5194                LogDebug(BCLog::NET, "mempool request with bloom filters disabled, %s", pfrom.DisconnectMsg());
5195                pfrom.fDisconnect = true;
5196            }
5197            return;
5198        }
5199
5200        if (m_connman.OutboundTargetReached(false) && !pfrom.HasPermission(NetPermissionFlags::Mempool))
5201        {
5202            if (!pfrom.HasPermission(NetPermissionFlags::NoBan))
5203            {
5204                LogDebug(BCLog::NET, "mempool request with bandwidth limit reached, %s", pfrom.DisconnectMsg());
5205                pfrom.fDisconnect = true;
5206            }
5207            return;
5208        }
5209
5210        if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
5211            LOCK(tx_relay->m_tx_inventory_mutex);
5212            tx_relay->m_send_mempool = true;
5213        }
5214        return;
5215    }
5216
5217    if (msg_type == NetMsgType::PING) {
5218        if (pfrom.GetCommonVersion() > BIP0031_VERSION) {
5219            uint64_t nonce = 0;
5220            vRecv >> nonce;
5221            // Echo the message back with the nonce. This allows for two useful features:
5222            //
5223            // 1) A remote node can quickly check if the connection is operational
5224            // 2) Remote nodes can measure the latency of the network thread. If this node
5225            //    is overloaded it won't respond to pings quickly and the remote node can
5226            //    avoid sending us more work, like chain download requests.
5227            //
5228            // The nonce stops the remote getting confused between different pings: without
5229            // it, if the remote node sends a ping once per second and this node takes 5
5230            // seconds to respond to each, the 5th ping the remote sends would appear to
5231            // return very quickly.
5232            MakeAndPushMessage(pfrom, NetMsgType::PONG, nonce);
5233        }
5234        return;
5235    }
5236
5237    if (msg_type == NetMsgType::PONG) {
5238        ProcessPong(pfrom, peer, /*ping_end=*/time_received, vRecv);
5239        return;
5240    }
5241
5242    if (msg_type == NetMsgType::FILTERLOAD) {
5243        if (!(peer.m_our_services & NODE_BLOOM)) {
5244            LogDebug(BCLog::NET, "filterload received despite not offering bloom services, %s", pfrom.DisconnectMsg());
5245            pfrom.fDisconnect = true;
5246            return;
5247        }
5248        CBloomFilter filter;
5249        vRecv >> filter;
5250