What peer messages mean

2751
2752    // Or it might be from the most recent block
2753    {
2754        LOCK(m_most_recent_block_mutex);
2755        if (m_most_recent_block_txs != nullptr) {
2756            auto it = m_most_recent_block_txs->find(gtxid);
2757            if (it != m_most_recent_block_txs->end()) return it->second;
2758        }
2759    }
2760
2761    return {};
2762}
2763
2764void PeerManagerImpl::ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic<bool>& interruptMsgProc)
2765{
2766    AssertLockNotHeld(cs_main);
2767
2768    auto tx_relay = peer.GetTxRelay();
2769
2770    std::deque<CInv>::iterator it = peer.m_getdata_requests.begin();
2771    std::vector<CInv> vNotFound;
2772
2773    // Process as many TX items from the front of the getdata queue as
2774    // possible, since they're common and it's efficient to batch process
2775    // them.
2776    while (it != peer.m_getdata_requests.end() && it->IsGenTxMsg()) {
2777        if (interruptMsgProc) return;
2778        // The send buffer provides backpressure. If there's no space in
2779        // the buffer, pause processing until the next call.
2780        if (pfrom.fPauseSend) break;
2781
2782        const CInv &inv = *it++;
2783
2784        if (tx_relay == nullptr) {
2785            // Ignore GETDATA requests for transactions from block-relay-only
2786            // peers and peers that asked us not to announce transactions.
2787            continue;
2788        }
2789
2790        if (auto tx{FindTxForGetData(*tx_relay, ToGenTxid(inv))}) {
2791            // WTX and WITNESS_TX imply we serialize with witness
2792            const auto maybe_with_witness = (inv.IsMsgTx() ? TX_NO_WITNESS : TX_WITH_WITNESS);
2793            MakeAndPushMessage(pfrom, NetMsgType::TX, maybe_with_witness(*tx));
2794            m_mempool.RemoveUnbroadcastTx(tx->GetHash());
2795        } else {
2796            vNotFound.push_back(inv);
2797        }
2798    }
2799
2800    // Only process one BLOCK item per call, since they're uncommon and can be
2801    // expensive to process.
2802    if (it != peer.m_getdata_requests.end() && !pfrom.fPauseSend) {
2803        const CInv &inv = *it++;
2804        if (inv.IsGenBlkMsg()) {
2805            ProcessGetBlockData(pfrom, peer, inv);
2806        }
2807        // else: If the first item on the queue is an unknown type, we erase it
2808        // and continue processing the queue on the next call.
2809        // NOTE: previously we wouldn't do so and the peer sending us a malformed GETDATA could
2810        // result in never making progress and this thread using 100% allocated CPU. See
2811        // https://bitcoincore.org/en/2024/07/03/disclose-getdata-cpu.
2812    }
2813
2814    peer.m_getdata_requests.erase(peer.m_getdata_requests.begin(), it);
2815
2816    if (!vNotFound.empty()) {
2817        // Let the peer know that we didn't find what it asked for, so it doesn't
2818        // have to wait around forever.
2819        // SPV clients care about this message: it's needed when they are
2820        // recursively walking the dependencies of relevant unconfirmed
2821        // transactions. SPV clients want to do that because they want to know
2822        // about (and store and rebroadcast and risk analyze) the dependencies
2823        // of transactions relevant to them, without having to download the
2824        // entire memory pool.
2825        // Also, other nodes can use these messages to automatically request a
2826        // transaction from some other peer that announced it, and stop
2827        // waiting for us to respond.
2828        // In normal operation, we often send NOTFOUND messages for parents of
2829        // transactions that we relay; if a peer is missing a parent, they may
2830        // assume we have them and request the parents from us.
2831        MakeAndPushMessage(pfrom, NetMsgType::NOTFOUND, vNotFound);
2832    }
2833}
2834
2835uint32_t PeerManagerImpl::GetFetchFlags(const Peer& peer) const
2836{
2837    uint32_t nFetchFlags = 0;
2838    if (CanServeWitnesses(peer)) {
2839        nFetchFlags |= MSG_WITNESS_FLAG;
2840    }
2841    return nFetchFlags;
2842}
2843
2844void PeerManagerImpl::SendBlockTransactions(CNode& pfrom, Peer& peer, const CBlock& block, const BlockTransactionsRequest& req)
2845{
2846    BlockTransactions resp(req);
2847    for (size_t i = 0; i < req.indexes.size(); i++) {
2848        if (req.indexes[i] >= block.vtx.size()) {
2849            Misbehaving(peer, "getblocktxn with out-of-bounds tx indices");
2850            return;
2851        }
2852        resp.txn[i] = block.vtx[req.indexes[i]];
2853    }
2854
2855    if (util::log::ShouldDebugLog(BCLog::CMPCTBLOCK)) {
2856        uint32_t tx_requested_size{0};
2857        for (const auto& tx : resp.txn) tx_requested_size += tx->ComputeTotalSize();
2858        LogDebug(BCLog::CMPCTBLOCK, "%s sent us a GETBLOCKTXN for block %s, sending a BLOCKTXN with %u txns. (%u bytes)", pfrom.LogPeer(), block.GetHash().ToString(), resp.txn.size(), tx_requested_size);
2859    }
2860    MakeAndPushMessage(pfrom, NetMsgType::BLOCKTXN, resp);
2861}
2862
2863bool PeerManagerImpl::CheckHeadersPoW(const std::vector<CBlockHeader>& headers, Peer& peer)
2864{
2865    // Do these headers have proof-of-work matching what's claimed?
2866    if (!HasValidProofOfWork(headers, m_chainparams.GetConsensus())) {
2867        Misbehaving(peer, "header with invalid proof of work");
2868        return false;
2869    }
2870
2871    // Are these headers connected to each other?
2872    if (!CheckHeadersAreContinuous(headers)) {
2873        Misbehaving(peer, "non-continuous headers sequence");
2874        return false;
2875    }
2876    return true;
2877}
2878
2879arith_uint256 PeerManagerImpl::GetAntiDoSWorkThreshold()
2880{
2881    arith_uint256 near_chaintip_work = 0;
2882    LOCK(cs_main);
2883    if (m_chainman.ActiveChain().Tip() != nullptr) {
2884        const CBlockIndex *tip = m_chainman.ActiveChain().Tip();
2885        // Use a 144 block buffer, so that we'll accept headers that fork from
2886        // near our tip.
2887        near_chaintip_work = tip->nChainWork - std::min<arith_uint256>(144*GetBlockProof(*tip), tip->nChainWork);
2888    }
2889    return std::max(near_chaintip_work, m_chainman.MinimumChainWork());
2890}
2891
2892/**
2893 * Special handling for unconnecting headers that might be part of a block
2894 * announcement.
2895 *
2896 * We'll send a getheaders message in response to try to connect the chain.
2897 */
2898void PeerManagerImpl::HandleUnconnectingHeaders(CNode& pfrom, Peer& peer,
2899        const std::vector<CBlockHeader>& headers)
2900{
2901    // Try to fill in the missing headers.
2902    const CBlockIndex* best_header{WITH_LOCK(cs_main, return m_chainman.m_best_header)};
2903    if (MaybeSendGetHeaders(pfrom, GetLocator(best_header), peer)) {
2904        LogDebug(BCLog::NET, "received header %s: missing prev block %s, sending getheaders (%d) to end (peer=%d)\n",
2905            headers[0].GetHash().ToString(),
2906            headers[0].hashPrevBlock.ToString(),
2907            best_header->nHeight,
2908            pfrom.GetId());
2909    }
2910
2911    // Set hashLastUnknownBlock for this peer, so that if we
2912    // eventually get the headers - even from a different peer -
2913    // we can use this peer to download.
2914    WITH_LOCK(cs_main, UpdateBlockAvailability(pfrom.GetId(), headers.back().GetHash()));
2915}
2916
2917bool PeerManagerImpl::CheckHeadersAreContinuous(const std::vector<CBlockHeader>& headers) const
2918{
2919    uint256 hashLastBlock;
2920    for (const CBlockHeader& header : headers) {
2921        if (!hashLastBlock.IsNull() && header.hashPrevBlock != hashLastBlock) {
2922            return false;
2923        }
2924        hashLastBlock = header.GetHash();
2925    }
2926    return true;
2927}
2928
2929bool PeerManagerImpl::IsContinuationOfLowWorkHeadersSync(Peer& peer, CNode& pfrom, std::vector<CBlockHeader>& headers)
2930{
2931    if (peer.m_headers_sync) {
2932        auto result = peer.m_headers_sync->ProcessNextHeaders(headers, headers.size() == m_opts.max_headers_result);
2933        // If it is a valid continuation, we should treat the existing getheaders request as responded to.
2934        if (result.success) peer.m_last_getheaders_timestamp = {};
2935        if (result.request_more) {
2936            auto locator = peer.m_headers_sync->NextHeadersRequestLocator();
2937            // If we were instructed to ask for a locator, it should not be empty.
2938            Assume(!locator.vHave.empty());
2939            // We can only be instructed to request more if processing was successful.
2940            Assume(result.success);
2941            if (!locator.vHave.empty()) {
2942                // It should be impossible for the getheaders request to fail,
2943                // because we just cleared the last getheaders timestamp.
2944                bool sent_getheaders = MaybeSendGetHeaders(pfrom, locator, peer);
2945                Assume(sent_getheaders);
2946                LogDebug(BCLog::NET, "more getheaders (from %s) to peer=%d\n",
2947                    locator.vHave.front().ToString(), pfrom.GetId());
2948            }
2949        }
2950
2951        if (peer.m_headers_sync->GetState() == HeadersSyncState::State::FINAL) {
2952            peer.m_headers_sync.reset(nullptr);
2953
2954            // Delete this peer's entry in m_headers_presync_stats.
2955            // If this is m_headers_presync_bestpeer, it will be replaced later
2956            // by the next peer that triggers the else{} branch below.
2957            LOCK(m_headers_presync_mutex);
2958            m_headers_presync_stats.erase(pfrom.GetId());
2959        } else {
2960            // Build statistics for this peer's sync.
2961            HeadersPresyncStats stats;
2962            stats.first = peer.m_headers_sync->GetPresyncWork();
2963            if (peer.m_headers_sync->GetState() == HeadersSyncState::State::PRESYNC) {
2964                stats.second = {peer.m_headers_sync->GetPresyncHeight(),
2965                                peer.m_headers_sync->GetPresyncTime()};
2966            }
2967
2968            // Update statistics in stats.
2969            LOCK(m_headers_presync_mutex);
2970            m_headers_presync_stats[pfrom.GetId()] = stats;
2971            auto best_it = m_headers_presync_stats.find(m_headers_presync_bestpeer);
2972            bool best_updated = false;
2973            if (best_it == m_headers_presync_stats.end()) {
2974                // If the cached best peer is outdated, iterate over all remaining ones (including
2975                // newly updated one) to find the best one.
2976                NodeId peer_best{-1};
2977                const HeadersPresyncStats* stat_best{nullptr};
2978                for (const auto& [peer, stat] : m_headers_presync_stats) {
2979                    if (!stat_best || stat > *stat_best) {
2980                        peer_best = peer;
2981                        stat_best = &stat;
2982                    }
2983                }
2984                m_headers_presync_bestpeer = peer_best;
2985                best_updated = (peer_best == pfrom.GetId());
2986            } else if (best_it->first == pfrom.GetId() || stats > best_it->second) {
2987                // pfrom was and remains the best peer, or pfrom just became best.
2988                m_headers_presync_bestpeer = pfrom.GetId();
2989                best_updated = true;
2990            }
2991            if (best_updated && stats.second.has_value()) {
2992                // If the best peer updated, and it is in its first phase, signal.
2993                m_headers_presync_should_signal = true;
2994            }
2995        }
2996
2997        if (result.success) {
2998            // We only overwrite the headers passed in if processing was
2999            // successful.
3000            headers.swap(result.pow_validated_headers);