What peer messages mean

2001    }
2002    m_connman.m_private_broadcast.NumToOpenSub(connections_cancelled);
2003
2004    return removed_txs;
2005}
2006
2007void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef& tx)
2008{
2009    if (m_opts.max_extra_txs == 0) return;
2010    if (vExtraTxnForCompact.size() < m_opts.max_extra_txs) {
2011        if (vExtraTxnForCompact.empty()) vExtraTxnForCompact.reserve(m_opts.max_extra_txs);
2012        vExtraTxnForCompact.emplace_back(tx->GetWitnessHash(), tx);
2013    } else {
2014        vExtraTxnForCompact[vExtraTxnForCompactIt] = std::make_pair(tx->GetWitnessHash(), tx);
2015    }
2016    vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % m_opts.max_extra_txs;
2017}
2018
2019void PeerManagerImpl::Misbehaving(Peer& peer, const std::string& message)
2020{
2021    LOCK(peer.m_misbehavior_mutex);
2022
2023    const std::string message_prefixed = message.empty() ? "" : (": " + message);
2024    peer.m_should_discourage = true;
2025    LogDebug(BCLog::NET, "Misbehaving: peer=%d%s\n", peer.m_id, message_prefixed);
2026    TRACEPOINT(net, misbehaving_connection,
2027        peer.m_id,
2028        message.c_str()
2029    );
2030}
2031
2032void PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
2033                                              bool via_compact_block, const std::string& message)
2034{
2035    PeerRef peer{GetPeerRef(nodeid)};
2036    switch (state.GetResult()) {
2037    case BlockValidationResult::BLOCK_RESULT_UNSET:
2038        break;
2039    case BlockValidationResult::BLOCK_HEADER_LOW_WORK:
2040        // We didn't try to process the block because the header chain may have
2041        // too little work.
2042        break;
2043    // The node is providing invalid data:
2044    case BlockValidationResult::BLOCK_CONSENSUS:
2045    case BlockValidationResult::BLOCK_MUTATED:
2046        if (!via_compact_block) {
2047            if (peer) Misbehaving(*peer, message);
2048            return;
2049        }
2050        break;
2051    case BlockValidationResult::BLOCK_CACHED_INVALID:
2052        {
2053            // Discourage outbound (but not inbound) peers if on an invalid chain.
2054            // Exempt HB compact block peers. Manual connections are always protected from discouragement.
2055            if (peer && !via_compact_block && !peer->m_is_inbound) {
2056                if (peer) Misbehaving(*peer, message);
2057                return;
2058            }
2059            break;
2060        }
2061    case BlockValidationResult::BLOCK_INVALID_HEADER:
2062    case BlockValidationResult::BLOCK_INVALID_PREV:
2063        if (peer) Misbehaving(*peer, message);
2064        return;
2065    // Conflicting (but not necessarily invalid) data or different policy:
2066    case BlockValidationResult::BLOCK_MISSING_PREV:
2067        if (peer) Misbehaving(*peer, message);
2068        return;
2069    case BlockValidationResult::BLOCK_TIME_FUTURE:
2070        break;
2071    }
2072    if (message != "") {
2073        LogDebug(BCLog::NET, "peer=%d: %s\n", nodeid, message);
2074    }
2075}
2076
2077bool PeerManagerImpl::BlockRequestAllowed(const CBlockIndex& block_index)
2078{
2079    AssertLockHeld(cs_main);
2080    if (m_chainman.ActiveChain().Contains(block_index)) return true;
2081    return block_index.IsValid(BLOCK_VALID_SCRIPTS) && (m_chainman.m_best_header != nullptr) &&
2082           (m_chainman.m_best_header->GetBlockTime() - block_index.GetBlockTime() < STALE_RELAY_AGE_LIMIT) &&
2083           (GetBlockProofEquivalentTime(*m_chainman.m_best_header, block_index, *m_chainman.m_best_header, m_chainparams.GetConsensus()) < STALE_RELAY_AGE_LIMIT);
2084}
2085
2086util::Expected<void, std::string> PeerManagerImpl::FetchBlock(NodeId peer_id, const CBlockIndex& block_index)
2087{
2088    if (m_chainman.m_blockman.LoadingBlocks()) return util::Unexpected{"Loading blocks ..."};
2089
2090    // The lock must be taken here before fetching Peer so another thread does
2091    // not delete the CNodeState from under the current thread, causing an
2092    // assertion failure in BlockRequested. This lock can be replaced with a
2093    // net-specific lock when more of CNodeState is moved into Peer.
2094    LOCK(cs_main);
2095
2096    // Ensure this peer exists and hasn't been disconnected
2097    PeerRef peer = GetPeerRef(peer_id);
2098    if (peer == nullptr) return util::Unexpected{"Peer does not exist"};
2099
2100    // Ignore pre-segwit peers
2101    if (!CanServeWitnesses(*peer)) return util::Unexpected{"Pre-SegWit peer"};
2102
2103    // Forget about all prior requests
2104    RemoveBlockRequest(block_index.GetBlockHash(), std::nullopt);
2105
2106    // Mark block as in-flight
2107    if (!BlockRequested(peer_id, block_index)) return util::Unexpected{"Already requested from this peer"};
2108
2109    // Construct message to request the block
2110    const uint256& hash{block_index.GetBlockHash()};
2111    std::vector<CInv> invs{CInv(MSG_BLOCK | MSG_WITNESS_FLAG, hash)};
2112
2113    // Send block request message to the peer
2114    bool success = m_connman.ForNode(peer_id, [this, &invs](CNode* node) {
2115        this->MakeAndPushMessage(*node, NetMsgType::GETDATA, invs);
2116        return true;
2117    });
2118
2119    if (!success) return util::Unexpected{"Peer not fully connected"};
2120
2121    LogDebug(BCLog::NET, "Requesting block %s from peer=%d\n",
2122                 hash.ToString(), peer_id);
2123    return {};
2124}
2125
2126std::unique_ptr<PeerManager> PeerManager::make(CConnman& connman, AddrMan& addrman,
2127                                               BanMan* banman, ChainstateManager& chainman,
2128                                               CTxMemPool& pool, node::Warnings& warnings, Options opts)
2129{
2130    return std::make_unique<PeerManagerImpl>(connman, addrman, banman, chainman, pool, warnings, opts);
2131}
2132
2133PeerManagerImpl::PeerManagerImpl(CConnman& connman, AddrMan& addrman,
2134                                 BanMan* banman, ChainstateManager& chainman,
2135                                 CTxMemPool& pool, node::Warnings& warnings, Options opts)
2136    : m_rng{opts.deterministic_rng},
2137      m_fee_filter_rounder{CFeeRate{DEFAULT_MIN_RELAY_TX_FEE}, m_rng},
2138      m_chainparams(chainman.GetParams()),
2139      m_connman(connman),
2140      m_addrman(addrman),
2141      m_banman(banman),
2142      m_chainman(chainman),
2143      m_mempool(pool),
2144      m_txdownloadman{node::TxDownloadOptions{pool, opts.deterministic_rng}},
2145      m_warnings{warnings},
2146      m_opts{opts},
2147      m_inbound_inv_bucket(/*rate=*/m_opts.tx_send_rate, /*mult=*/1.0),
2148      m_outbound_inv_bucket(/*rate=*/m_opts.tx_send_rate, /*mult=*/OUTBOUND_INVENTORY_BUCKET_MULTIPLIER)
2149{
2150    // While Erlay support is incomplete, it must be enabled explicitly via -txreconciliation.
2151    // This argument can go away after Erlay support is complete.
2152    if (opts.reconcile_txs) {
2153        m_txreconciliation = std::make_unique<TxReconciliationTracker>(TXRECONCILIATION_VERSION);
2154    }
2155}
2156
2157void PeerManagerImpl::StartScheduledTasks(CScheduler& scheduler)
2158{
2159    // Stale tip checking and peer eviction are on two different timers, but we
2160    // don't want them to get out of sync due to drift in the scheduler, so we
2161    // combine them in one function and schedule at the quicker (peer-eviction)
2162    // timer.
2163    static_assert(EXTRA_PEER_CHECK_INTERVAL < STALE_CHECK_INTERVAL, "peer eviction timer should be less than stale tip check timer");
2164    scheduler.scheduleEvery([this] { this->CheckForStaleTipAndEvictPeers(); }, std::chrono::seconds{EXTRA_PEER_CHECK_INTERVAL});
2165
2166    // schedule next run for 10-15 minutes in the future
2167    const auto delta = 10min + FastRandomContext().randrange<std::chrono::milliseconds>(5min);
2168    scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); }, delta);
2169
2170    if (m_opts.private_broadcast) {
2171        scheduler.scheduleFromNow([&] { ReattemptPrivateBroadcast(scheduler); }, 0min);
2172    }
2173}
2174
2175void PeerManagerImpl::ActiveTipChange(const CBlockIndex& new_tip, bool is_ibd)
2176{
2177    // Ensure mempool mutex was released, otherwise deadlock may occur if another thread holding
2178    // m_tx_download_mutex waits on the mempool mutex.
2179    AssertLockNotHeld(m_mempool.cs);
2180    AssertLockNotHeld(m_tx_download_mutex);
2181
2182    if (!is_ibd) {
2183        LOCK(m_tx_download_mutex);
2184        // If the chain tip has changed, previously rejected transactions might now be valid, e.g. due
2185        // to a timelock. Reset the rejection filters to give those transactions another chance if we
2186        // see them again.
2187        m_txdownloadman.ActiveTipChange();
2188    }
2189}
2190
2191/**
2192 * Evict orphan txn pool entries based on a newly connected
2193 * block, remember the recently confirmed transactions, and delete tracked
2194 * announcements for them. Also save the time of the last tip update and
2195 * possibly reduce dynamic block stalling timeout.
2196 */
2197void PeerManagerImpl::BlockConnected(
2198    const ChainstateRole& role,
2199    const std::shared_ptr<const CBlock>& pblock,
2200    const CBlockIndex* pindex)
2201{
2202    // Update this for all chainstate roles so that we don't mistakenly see peers
2203    // helping us do background IBD as having a stale tip.
2204    m_last_tip_update = GetTime<std::chrono::seconds>();
2205
2206    // In case the dynamic timeout was doubled once or more, reduce it slowly back to its default value
2207    auto stalling_timeout = m_block_stalling_timeout.load();
2208    Assume(stalling_timeout >= BLOCK_STALLING_TIMEOUT_DEFAULT);
2209    if (stalling_timeout != BLOCK_STALLING_TIMEOUT_DEFAULT) {
2210        const auto new_timeout = std::max(std::chrono::duration_cast<std::chrono::seconds>(stalling_timeout * 0.85), BLOCK_STALLING_TIMEOUT_DEFAULT);
2211        if (m_block_stalling_timeout.compare_exchange_strong(stalling_timeout, new_timeout)) {
2212            LogDebug(BCLog::NET, "Decreased stalling timeout to %d seconds\n", count_seconds(new_timeout));
2213        }
2214    }
2215
2216    // The following task can be skipped since we don't maintain a mempool for
2217    // the historical chainstate, or during ibd since we don't receive incoming
2218    // transactions from peers into the mempool.
2219    if (!role.historical && !m_chainman.IsInitialBlockDownload()) {
2220        LOCK(m_tx_download_mutex);
2221        m_txdownloadman.BlockConnected(pblock);
2222    }
2223}
2224
2225void PeerManagerImpl::BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex* pindex)
2226{
2227    LOCK(m_tx_download_mutex);
2228    m_txdownloadman.BlockDisconnected();
2229}
2230
2231/**
2232 * Maintain state about the best-seen block and fast-announce a compact block
2233 * to compatible peers.
2234 */
2235void PeerManagerImpl::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock)
2236{
2237    auto pcmpctblock = std::make_shared<const CBlockHeaderAndShortTxIDs>(*pblock, FastRandomContext().rand64());
2238
2239    LOCK(cs_main);
2240
2241    if (pindex->nHeight <= m_highest_fast_announce)
2242        return;
2243    m_highest_fast_announce = pindex->nHeight;
2244
2245    if (!DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_SEGWIT)) return;
2246
2247    uint256 hashBlock(pblock->GetHash());
2248    const std::shared_future<CSerializedNetMsg> lazy_ser{
2249        std::async(std::launch::deferred, [&] { return NetMsg::Make(NetMsgType::CMPCTBLOCK, *pcmpctblock); })};
2250