What peer messages mean

4501            pfrom.fDisconnect = true;
4502            return;
4503        }
4504
4505        // We might have announced the currently-being-connected tip using a
4506        // compact block, which resulted in the peer sending a getblocks
4507        // request, which we would otherwise respond to without the new block.
4508        // To avoid this situation we simply verify that we are on our best
4509        // known chain now. This is super overkill, but we handle it better
4510        // for getheaders requests, and there are no known nodes which support
4511        // compact blocks but still use getblocks to request blocks.
4512        {
4513            std::shared_ptr<const CBlock> a_recent_block;
4514            {
4515                LOCK(m_most_recent_block_mutex);
4516                a_recent_block = m_most_recent_block;
4517            }
4518            BlockValidationState state;
4519            if (!m_chainman.ActiveChainstate().ActivateBestChain(state, a_recent_block)) {
4520                LogDebug(BCLog::NET, "failed to activate chain (%s)\n", state.ToString());
4521            }
4522        }
4523
4524        LOCK(cs_main);
4525
4526        // Find the last block the caller has in the main chain
4527        const CBlockIndex* pindex = m_chainman.ActiveChainstate().FindForkInGlobalIndex(locator);
4528
4529        // Send the rest of the chain
4530        if (pindex)
4531            pindex = m_chainman.ActiveChain().Next(*pindex);
4532        int nLimit = 500;
4533        LogDebug(BCLog::NET, "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit, pfrom.GetId());
4534        for (; pindex; pindex = m_chainman.ActiveChain().Next(*pindex))
4535        {
4536            if (pindex->GetBlockHash() == hashStop)
4537            {
4538                LogDebug(BCLog::NET, " getblocks stopping at %d %s", pindex->nHeight, pindex->GetBlockHash().ToString());
4539                break;
4540            }
4541            // If pruning, don't inv blocks unless we have on disk and are likely to still have
4542            // for some reasonable time window (1 hour) that block relay might require.
4543            const int nPrunedBlocksLikelyToHave = MIN_BLOCKS_TO_KEEP - 3600 / m_chainparams.GetConsensus().nPowTargetSpacing;
4544            if (m_chainman.m_blockman.IsPruneMode() && (!(pindex->nStatus & BLOCK_HAVE_DATA) || pindex->nHeight <= m_chainman.ActiveChain().Tip()->nHeight - nPrunedBlocksLikelyToHave)) {
4545                LogDebug(BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
4546                break;
4547            }
4548            WITH_LOCK(peer.m_block_inv_mutex, peer.m_blocks_for_inv_relay.push_back(pindex->GetBlockHash()));
4549            if (--nLimit <= 0) {
4550                // When this block is requested, we'll send an inv that'll
4551                // trigger the peer to getblocks the next batch of inventory.
4552                LogDebug(BCLog::NET, " getblocks stopping at limit %d %s", pindex->nHeight, pindex->GetBlockHash().ToString());
4553                WITH_LOCK(peer.m_block_inv_mutex, {peer.m_continuation_block = pindex->GetBlockHash();});
4554                break;
4555            }
4556        }
4557        return;
4558    }
4559
4560    if (msg_type == NetMsgType::GETBLOCKTXN) {
4561        BlockTransactionsRequest req;
4562        vRecv >> req;
4563
4564        // No legitimate reason to send indexes empty
4565        if (req.indexes.empty()) {
4566            LogDebug(BCLog::NET, "getblocktxn received with no transaction indexes, %s", pfrom.DisconnectMsg());
4567            pfrom.fDisconnect = true;
4568            return;
4569        }
4570
4571        // Verify differential encoding invariant: indexes must be strictly increasing
4572        // DifferenceFormatter should guarantee this property during deserialization
4573        for (size_t i = 1; i < req.indexes.size(); ++i) {
4574            Assume(req.indexes[i] > req.indexes[i-1]);
4575        }
4576
4577        std::shared_ptr<const CBlock> recent_block;
4578        {
4579            LOCK(m_most_recent_block_mutex);
4580            if (m_most_recent_block_hash == req.blockhash)
4581                recent_block = m_most_recent_block;
4582            // Unlock m_most_recent_block_mutex to avoid cs_main lock inversion
4583        }
4584        if (recent_block) {
4585            SendBlockTransactions(pfrom, peer, *recent_block, req);
4586            return;
4587        }
4588
4589        FlatFilePos block_pos{};
4590        {
4591            LOCK(cs_main);
4592
4593            const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(req.blockhash);
4594            if (!pindex || !(pindex->nStatus & BLOCK_HAVE_DATA)) {
4595                LogDebug(BCLog::NET, "Peer %d sent us a getblocktxn for a block we don't have\n", pfrom.GetId());
4596                return;
4597            }
4598
4599            if (pindex->nHeight >= m_chainman.ActiveChain().Height() - MAX_BLOCKTXN_DEPTH) {
4600                block_pos = pindex->GetBlockPos();
4601            }
4602        }
4603
4604        if (!block_pos.IsNull()) {
4605            CBlock block;
4606            const bool ret{m_chainman.m_blockman.ReadBlock(block, block_pos, req.blockhash)};
4607            // If height is above MAX_BLOCKTXN_DEPTH then this block cannot get
4608            // pruned after we release cs_main above, so this read should never fail.
4609            assert(ret);
4610
4611            SendBlockTransactions(pfrom, peer, block, req);
4612            return;
4613        }
4614
4615        // If an older block is requested (should never happen in practice,
4616        // but can happen in tests) send a block response instead of a
4617        // blocktxn response. Sending a full block response instead of a
4618        // small blocktxn response is preferable in the case where a peer
4619        // might maliciously send lots of getblocktxn requests to trigger
4620        // expensive disk reads, because it will require the peer to
4621        // actually receive all the data read from disk over the network.
4622        LogDebug(BCLog::NET, "Peer %d sent us a getblocktxn for a block > %i deep\n", pfrom.GetId(), MAX_BLOCKTXN_DEPTH);
4623        CInv inv{MSG_WITNESS_BLOCK, req.blockhash};
4624        WITH_LOCK(peer.m_getdata_requests_mutex, peer.m_getdata_requests.push_back(inv));
4625        // The message processing loop will go around again (without pausing) and we'll respond then
4626        return;
4627    }
4628
4629    if (msg_type == NetMsgType::GETHEADERS) {
4630        CBlockLocator locator;
4631        uint256 hashStop;
4632        vRecv >> locator >> hashStop;
4633
4634        if (locator.vHave.size() > MAX_LOCATOR_SZ) {
4635            LogDebug(BCLog::NET, "getheaders locator size %lld > %d, %s", locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.DisconnectMsg());
4636            pfrom.fDisconnect = true;
4637            return;
4638        }
4639
4640        if (m_chainman.m_blockman.LoadingBlocks()) {
4641            LogDebug(BCLog::NET, "Ignoring getheaders from peer=%d while importing/reindexing\n", pfrom.GetId());
4642            return;
4643        }
4644
4645        LOCK(cs_main);
4646
4647        // Don't serve headers from our active chain until our chainwork is at least
4648        // the minimum chain work. This prevents us from starting a low-work headers
4649        // sync that will inevitably be aborted by our peer.
4650        if (m_chainman.ActiveTip() == nullptr ||
4651                (m_chainman.ActiveTip()->nChainWork < m_chainman.MinimumChainWork() && !pfrom.HasPermission(NetPermissionFlags::Download))) {
4652            LogDebug(BCLog::NET, "Ignoring getheaders from peer=%d because active chain has too little work; sending empty response\n", pfrom.GetId());
4653            // Just respond with an empty headers message, to tell the peer to
4654            // go away but not treat us as unresponsive.
4655            MakeAndPushMessage(pfrom, NetMsgType::HEADERS, std::vector<CBlockHeader>());
4656            return;
4657        }
4658
4659        CNodeState *nodestate = State(pfrom.GetId());
4660        const CBlockIndex* pindex = nullptr;
4661        if (locator.IsNull())
4662        {
4663            // If locator is null, return the hashStop block
4664            pindex = m_chainman.m_blockman.LookupBlockIndex(hashStop);
4665            if (!pindex) {
4666                return;
4667            }
4668            if (!BlockRequestAllowed(*pindex)) {
4669                LogDebug(BCLog::NET, "%s: ignoring request from peer=%i for old block header that isn't in the main chain\n", __func__, pfrom.GetId());
4670                return;
4671            }
4672        }
4673        else
4674        {
4675            // Find the last block the caller has in the main chain
4676            pindex = m_chainman.ActiveChainstate().FindForkInGlobalIndex(locator);
4677            if (pindex)
4678                pindex = m_chainman.ActiveChain().Next(*pindex);
4679        }
4680
4681        // we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx count at the end
4682        std::vector<CBlock> vHeaders;
4683        int nLimit = m_opts.max_headers_result;
4684        LogDebug(BCLog::NET, "getheaders %d to %s from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), pfrom.GetId());
4685        for (; pindex; pindex = m_chainman.ActiveChain().Next(*pindex))
4686        {
4687            vHeaders.emplace_back(pindex->GetBlockHeader());
4688            if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
4689                break;
4690        }
4691        // pindex can be nullptr either if we sent m_chainman.ActiveChain().Tip() OR
4692        // if our peer has m_chainman.ActiveChain().Tip() (and thus we are sending an empty
4693        // headers message). In both cases it's safe to update
4694        // pindexBestHeaderSent to be our tip.
4695        //
4696        // It is important that we simply reset the BestHeaderSent value here,
4697        // and not max(BestHeaderSent, newHeaderSent). We might have announced
4698        // the currently-being-connected tip using a compact block, which
4699        // resulted in the peer sending a headers request, which we respond to
4700        // without the new block. By resetting the BestHeaderSent, we ensure we
4701        // will re-announce the new block via headers (or compact blocks again)
4702        // in the SendMessages logic.
4703        nodestate->pindexBestHeaderSent = pindex ? pindex : m_chainman.ActiveChain().Tip();
4704        MakeAndPushMessage(pfrom, NetMsgType::HEADERS, TX_WITH_WITNESS(vHeaders));
4705        return;
4706    }
4707
4708    if (msg_type == NetMsgType::TX) {
4709        if (RejectIncomingTxs(pfrom)) {
4710            LogDebug(BCLog::NET, "transaction sent in violation of protocol, %s", pfrom.DisconnectMsg());
4711            pfrom.fDisconnect = true;
4712            return;
4713        }
4714
4715        // Stop processing the transaction early if we are still in IBD since we don't
4716        // have enough information to validate it yet. Sending unsolicited transactions
4717        // is not considered a protocol violation, so don't punish the peer.
4718        if (m_chainman.IsInitialBlockDownload()) return;
4719
4720        CTransactionRef ptx;
4721        vRecv >> TX_WITH_WITNESS(ptx);
4722
4723        const Txid& txid = ptx->GetHash();
4724        const Wtxid& wtxid = ptx->GetWitnessHash();
4725
4726        const uint256& hash = peer.m_wtxid_relay ? wtxid.ToUint256() : txid.ToUint256();
4727        AddKnownTx(peer, hash);
4728
4729        if (m_tx_for_private_broadcast.MarkResolved(ptx)) {
4730            LogDebug(BCLog::PRIVBROADCAST, "Received our privately broadcast transaction (txid=%s) from the "
4731                                           "network from %s",
4732                     txid.ToString(), pfrom.LogPeer());
4733        }
4734
4735        LOCK2(cs_main, m_tx_download_mutex);
4736
4737        const auto& [should_validate, package_to_validate] = m_txdownloadman.ReceivedTx(pfrom.GetId(), ptx);
4738        if (!should_validate) {
4739            if (pfrom.HasPermission(NetPermissionFlags::ForceRelay)) {
4740                // Always relay transactions received from peers with forcerelay
4741                // permission, even if they were already in the mempool, allowing
4742                // the node to function as a gateway for nodes hidden behind it.
4743                if (!m_mempool.exists(txid)) {
4744                    LogInfo("Not relaying non-mempool transaction %s (wtxid=%s) from forcerelay peer=%d\n",
4745                              txid.ToString(), wtxid.ToString(), pfrom.GetId());
4746                } else {
4747                    LogInfo("Force relaying tx %s (wtxid=%s) from peer=%d\n",
4748                              txid.ToString(), wtxid.ToString(), pfrom.GetId());
4749                    InitiateTxBroadcastToAll(wtxid);
4750                }