What peer messages mean

6251                        if (m_most_recent_block_hash == pBestIndex->GetBlockHash()) {
6252                            cached_cmpctblock_msg = NetMsg::Make(NetMsgType::CMPCTBLOCK, *m_most_recent_compact_block);
6253                        }
6254                    }
6255                    if (cached_cmpctblock_msg.has_value()) {
6256                        PushMessage(node, std::move(cached_cmpctblock_msg.value()));
6257                    } else {
6258                        CBlock block;
6259                        const bool ret{m_chainman.m_blockman.ReadBlock(block, *pBestIndex)};
6260                        assert(ret);
6261                        CBlockHeaderAndShortTxIDs cmpctblock{block, m_rng.rand64()};
6262                        MakeAndPushMessage(node, NetMsgType::CMPCTBLOCK, cmpctblock);
6263                    }
6264                    state.pindexBestHeaderSent = pBestIndex;
6265                } else if (peer.m_prefers_headers) {
6266                    if (vHeaders.size() > 1) {
6267                        LogDebug(BCLog::NET, "%s: %u headers, range (%s, %s), to peer=%d\n", __func__,
6268                                vHeaders.size(),
6269                                vHeaders.front().GetHash().ToString(),
6270                                vHeaders.back().GetHash().ToString(), node.GetId());
6271                    } else {
6272                        LogDebug(BCLog::NET, "%s: sending header %s to peer=%d\n", __func__,
6273                                vHeaders.front().GetHash().ToString(), node.GetId());
6274                    }
6275                    MakeAndPushMessage(node, NetMsgType::HEADERS, TX_WITH_WITNESS(vHeaders));
6276                    state.pindexBestHeaderSent = pBestIndex;
6277                } else
6278                    fRevertToInv = true;
6279            }
6280            if (fRevertToInv) {
6281                // If falling back to using an inv, just try to inv the tip.
6282                // The last entry in m_blocks_for_headers_relay was our tip at some point
6283                // in the past.
6284                if (!peer.m_blocks_for_headers_relay.empty()) {
6285                    const uint256& hashToAnnounce = peer.m_blocks_for_headers_relay.back();
6286                    const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(hashToAnnounce);
6287                    assert(pindex);
6288
6289                    // Warn if we're announcing a block that is not on the main chain.
6290                    // This should be very rare and could be optimized out.
6291                    // Just log for now.
6292                    if (m_chainman.ActiveChain()[pindex->nHeight] != pindex) {
6293                        LogDebug(BCLog::NET, "Announcing block %s not on main chain (tip=%s)\n",
6294                            hashToAnnounce.ToString(), m_chainman.ActiveChain().Tip()->GetBlockHash().ToString());
6295                    }
6296
6297                    // If the peer's chain has this block, don't inv it back.
6298                    if (!PeerHasHeader(&state, pindex)) {
6299                        peer.m_blocks_for_inv_relay.push_back(hashToAnnounce);
6300                        LogDebug(BCLog::NET, "%s: sending inv peer=%d hash=%s\n", __func__,
6301                            node.GetId(), hashToAnnounce.ToString());
6302                    }
6303                }
6304            }
6305            peer.m_blocks_for_headers_relay.clear();
6306        }
6307
6308        //
6309        // Message: inventory
6310        //
6311        std::vector<CInv> vInv;
6312        {
6313            LOCK(peer.m_block_inv_mutex);
6314            vInv.reserve(peer.m_blocks_for_inv_relay.size());
6315
6316            // Add blocks
6317            for (const uint256& hash : peer.m_blocks_for_inv_relay) {
6318                vInv.emplace_back(MSG_BLOCK, hash);
6319                if (vInv.size() == MAX_INV_SZ) {
6320                    MakeAndPushMessage(node, NetMsgType::INV, vInv);
6321                    vInv.clear();
6322                }
6323            }
6324            peer.m_blocks_for_inv_relay.clear();
6325        }
6326
6327        if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
6328                LOCK(tx_relay->m_tx_inventory_mutex);
6329                // Check whether periodic sends should happen
6330                bool fSendTrickle = node.HasPermission(NetPermissionFlags::NoBan);
6331                if (tx_relay->m_next_inv_send_time < current_time) {
6332                    fSendTrickle = true;
6333                    if (node.IsInboundConn()) {
6334                        tx_relay->m_next_inv_send_time = NextInvToInbounds(current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL, node.m_network_key);
6335                    } else {
6336                        tx_relay->m_next_inv_send_time = current_time + m_rng.rand_exp_duration(OUTBOUND_INVENTORY_BROADCAST_INTERVAL);
6337                    }
6338                }
6339
6340                // Time to send but the peer has requested we not relay transactions.
6341                if (fSendTrickle) {
6342                    LOCK(tx_relay->m_bloom_filter_mutex);
6343                    if (!tx_relay->m_relay_txs) tx_relay->m_tx_inventory_to_send.clear();
6344                }
6345
6346                // Respond to BIP35 mempool requests
6347                if (fSendTrickle && tx_relay->m_send_mempool) {
6348                    auto vtxinfo = m_mempool.infoAll();
6349
6350                    // Ensure we'll respond to GETDATA requests for anything we're about to announce
6351                    tx_relay->m_last_inv_sequence = WITH_LOCK(m_mempool.cs, return m_mempool.GetSequence());
6352
6353                    tx_relay->m_send_mempool = false;
6354                    const CFeeRate filterrate{tx_relay->m_fee_filter_received.load()};
6355
6356                    // we'll send everything in the mempool momentarily, so this is redundant
6357                    tx_relay->m_tx_inventory_to_send.clear();
6358
6359                    LOCK(tx_relay->m_bloom_filter_mutex);
6360
6361                    for (const auto& txinfo : vtxinfo) {
6362                        const Txid& txid{txinfo.tx->GetHash()};
6363                        const Wtxid& wtxid{txinfo.tx->GetWitnessHash()};
6364                        const auto inv = peer.m_wtxid_relay ?
6365                                             CInv{MSG_WTX, wtxid.ToUint256()} :
6366                                             CInv{MSG_TX, txid.ToUint256()};
6367
6368                        // Don't send transactions that peers will not put into their mempool
6369                        if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) {
6370                            continue;
6371                        }
6372                        if (tx_relay->m_bloom_filter) {
6373                            if (!tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
6374                        }
6375                        tx_relay->m_tx_inventory_known_filter.insert(inv.hash);
6376                        vInv.push_back(inv);
6377                        if (vInv.size() == MAX_INV_SZ) {
6378                            MakeAndPushMessage(node, NetMsgType::INV, vInv);
6379                            vInv.clear();
6380                        }
6381                    }
6382                }
6383
6384                // Determine transactions to relay
6385                if (fSendTrickle) {
6386                    // Topologically and fee-rate sort the inventory we send for privacy and priority reasons.
6387                    // (sorted from higher priority to lowest, skipping low fee)
6388                    const CFeeRate filterrate{tx_relay->m_fee_filter_received.load()};
6389
6390                    auto inv_tx = [&]() EXCLUSIVE_LOCKS_REQUIRED(tx_relay->m_tx_inventory_mutex) {
6391                        auto& invs = tx_relay->m_tx_inventory_to_send;
6392                        std::vector<CTransactionRef> res;
6393
6394                        if (invs.size() == 0) return res;
6395
6396                        // if previous allocations were excessive, shrink to the current size
6397                        if (invs.capacity() > 2 * invs.size()) invs.shrink_to_fit();
6398
6399                        LOCK(m_mempool.cs);
6400                        auto txiters = m_mempool.ExtractBestByMiningScoreWithTopology(invs, invs.size());
6401                        res.reserve(txiters.size());
6402                        for (auto txiter : txiters) {
6403                            if (txiter->GetFee() < filterrate.GetFee(txiter->GetTxSize())) {
6404                                continue; // higher feerate CPFP txs may follow, so just skip, don't stop
6405                            }
6406                            res.push_back(txiter->GetSharedTx());
6407                        }
6408                        // Ensure we'll respond to GETDATA requests for anything we're about to announce
6409                        tx_relay->m_last_inv_sequence = m_mempool.GetSequence();
6410                        return res;
6411                    }();
6412
6413                    LOCK(tx_relay->m_bloom_filter_mutex);
6414                    vInv.reserve(std::min<size_t>(MAX_INV_SZ, vInv.size() + inv_tx.size()));
6415                    for (auto& tx : inv_tx) {
6416                        // `TxRelay::m_tx_inventory_known_filter` contains either txids or wtxids
6417                        // depending on whether our peer supports wtxid-relay. Therefore, first
6418                        // construct the inv and then use its hash for the filter check.
6419                        const auto inv = peer.m_wtxid_relay ?
6420                                             CInv{MSG_WTX, tx->GetWitnessHash().ToUint256()} :
6421                                             CInv{MSG_TX, tx->GetHash().ToUint256()};
6422                        // Check if not in the filter already
6423                        if (tx_relay->m_tx_inventory_known_filter.contains(inv.hash)) {
6424                            continue;
6425                        }
6426                        if (tx_relay->m_bloom_filter && !tx_relay->m_bloom_filter->IsRelevantAndUpdate(*tx)) continue;
6427                        // Send
6428                        vInv.push_back(inv);
6429                        if (vInv.size() == MAX_INV_SZ) {
6430                            MakeAndPushMessage(node, NetMsgType::INV, vInv);
6431                            vInv.clear();
6432                        }
6433                        tx_relay->m_tx_inventory_known_filter.insert(inv.hash);
6434                    }
6435                }
6436        }
6437        if (!vInv.empty())
6438            MakeAndPushMessage(node, NetMsgType::INV, vInv);
6439
6440        // Detect whether we're stalling
6441        auto stalling_timeout = m_block_stalling_timeout.load();
6442        if (state.m_stalling_since.count() && state.m_stalling_since < current_time - stalling_timeout) {
6443            // Stalling only triggers when the block download window cannot move. During normal steady state,
6444            // the download window should be much larger than the to-be-downloaded set of blocks, so disconnection
6445            // should only happen during initial block download.
6446            LogInfo("Peer is stalling block download, %s", node.DisconnectMsg());
6447            node.fDisconnect = true;
6448            // Increase timeout for the next peer so that we don't disconnect multiple peers if our own
6449            // bandwidth is insufficient.
6450            const auto new_timeout = std::min(2 * stalling_timeout, BLOCK_STALLING_TIMEOUT_MAX);
6451            if (stalling_timeout != new_timeout && m_block_stalling_timeout.compare_exchange_strong(stalling_timeout, new_timeout)) {
6452                LogDebug(BCLog::NET, "Increased stalling timeout temporarily to %d seconds\n", count_seconds(new_timeout));
6453            }
6454            return true;
6455        }
6456        // In case there is a block that has been in flight from this peer for block_interval * (1 + 0.5 * N)
6457        // (with N the number of peers from which we're downloading validated blocks), disconnect due to timeout.
6458        // We compensate for other peers to prevent killing off peers due to our own downstream link
6459        // being saturated. We only count validated in-flight blocks so peers can't advertise non-existing block hashes
6460        // to unreasonably increase our timeout.
6461        if (state.vBlocksInFlight.size() > 0) {
6462            QueuedBlock &queuedBlock = state.vBlocksInFlight.front();
6463            int nOtherPeersWithValidatedDownloads = m_peers_downloading_from - 1;
6464            if (current_time > state.m_downloading_since + std::chrono::seconds{consensusParams.nPowTargetSpacing} * (BLOCK_DOWNLOAD_TIMEOUT_BASE + BLOCK_DOWNLOAD_TIMEOUT_PER_PEER * nOtherPeersWithValidatedDownloads)) {
6465                LogInfo("Timeout downloading block %s, %s", queuedBlock.pindex->GetBlockHash().ToString(), node.DisconnectMsg());
6466                node.fDisconnect = true;
6467                return true;
6468            }
6469        }
6470        // Check for headers sync timeouts
6471        if (state.fSyncStarted && peer.m_headers_sync_timeout < std::chrono::microseconds::max()) {
6472            // Detect whether this is a stalling initial-headers-sync peer
6473            if (m_chainman.m_best_header->Time() <= NodeClock::now() - 24h) {
6474                if (current_time > peer.m_headers_sync_timeout && nSyncStarted == 1 && (m_num_preferred_download_peers - state.fPreferredDownload >= 1)) {
6475                    // Disconnect a peer (without NetPermissionFlags::NoBan permission) if it is our only sync peer,
6476                    // and we have others we could be using instead.
6477                    // Note: If all our peers are inbound, then we won't
6478                    // disconnect our sync peer for stalling; we have bigger
6479                    // problems if we can't get any outbound peers.
6480                    if (!node.HasPermission(NetPermissionFlags::NoBan)) {
6481                        LogInfo("Timeout downloading headers, %s", node.DisconnectMsg());
6482                        node.fDisconnect = true;
6483                        return true;
6484                    } else {
6485                        LogInfo("Timeout downloading headers from noban peer, not %s", node.DisconnectMsg());
6486                        // Reset the headers sync state so that we have a
6487                        // chance to try downloading from a different peer.
6488                        // Note: this will also result in at least one more
6489                        // getheaders message to be sent to
6490                        // this peer (eventually).
6491                        state.fSyncStarted = false;
6492                        nSyncStarted--;
6493                        peer.m_headers_sync_timeout = 0us;
6494                    }
6495                }
6496            } else {
6497                // After we've caught up once, reset the timeout so we can't trigger
6498                // disconnect later.
6499                peer.m_headers_sync_timeout = std::chrono::microseconds::max();
6500            }