What peer messages mean

2501    case PrivateBroadcast::AddResult::Added:
2502        LogDebug(BCLog::PRIVBROADCAST, "Requesting %d new connections due to %s", PrivateBroadcast::INITIAL_CONNECTION_COUNT, txstr);
2503        m_connman.m_private_broadcast.NumToOpenAdd(PrivateBroadcast::INITIAL_CONNECTION_COUNT);
2504        return node::TransactionError::OK;
2505    case PrivateBroadcast::AddResult::AlreadyPresent:
2506        LogDebug(BCLog::PRIVBROADCAST, "Ignoring unnecessary request to schedule an already scheduled transaction: %s", txstr);
2507        return node::TransactionError::OK;
2508    case PrivateBroadcast::AddResult::QueueFull:
2509        LogDebug(BCLog::PRIVBROADCAST, "Rejecting private broadcast, queue full (cap=%u): %s", PrivateBroadcast::MAX_TRANSACTIONS, txstr);
2510        return node::TransactionError::PRIVATE_BROADCAST_FULL;
2511    } // no default case, so the compiler can warn about missing cases
2512    assert(false);
2513}
2514
2515void PeerManagerImpl::RelayAddress(NodeId originator,
2516                                   const CAddress& addr,
2517                                   bool fReachable)
2518{
2519    // We choose the same nodes within a given 24h window (if the list of connected
2520    // nodes does not change) and we don't relay to nodes that already know an
2521    // address. So within 24h we will likely relay a given address once. This is to
2522    // prevent a peer from unjustly giving their address better propagation by sending
2523    // it to us repeatedly.
2524
2525    if (!fReachable && !addr.IsRelayable()) return;
2526
2527    // Relay to a limited number of other nodes
2528    // Use deterministic randomness to send to the same nodes for 24 hours
2529    // at a time so the m_addr_knowns of the chosen nodes prevent repeats
2530    const uint64_t hash_addr{CServiceHash(0, 0)(addr)};
2531    const auto current_time{GetTime<std::chrono::seconds>()};
2532    // Adding address hash makes exact rotation time different per address, while preserving periodicity.
2533    const uint64_t time_addr{(static_cast<uint64_t>(count_seconds(current_time)) + hash_addr) / count_seconds(ROTATE_ADDR_RELAY_DEST_INTERVAL)};
2534    const CSipHasher hasher{m_connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY)
2535                                .Write(hash_addr)
2536                                .Write(time_addr)};
2537
2538    // Relay reachable addresses to 2 peers. Unreachable addresses are relayed randomly to 1 or 2 peers.
2539    unsigned int nRelayNodes = (fReachable || (hasher.Finalize() & 1)) ? 2 : 1;
2540
2541    std::array<std::pair<uint64_t, Peer*>, 2> best{{{0, nullptr}, {0, nullptr}}};
2542    assert(nRelayNodes <= best.size());
2543
2544    LOCK(m_peer_mutex);
2545
2546    for (auto& [id, peer] : m_peer_map) {
2547        if (peer->m_addr_relay_enabled && id != originator && IsAddrCompatible(*peer, addr)) {
2548            uint64_t hashKey = CSipHasher(hasher).Write(id).Finalize();
2549            for (unsigned int i = 0; i < nRelayNodes; i++) {
2550                 if (hashKey > best[i].first) {
2551                     std::copy(best.begin() + i, best.begin() + nRelayNodes - 1, best.begin() + i + 1);
2552                     best[i] = std::make_pair(hashKey, peer.get());
2553                     break;
2554                 }
2555            }
2556        }
2557    };
2558
2559    for (unsigned int i = 0; i < nRelayNodes && best[i].first != 0; i++) {
2560        PushAddress(*best[i].second, addr);
2561    }
2562}
2563
2564void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv& inv)
2565{
2566    // First perform the stateless checks:
2567    // A filtered-block can only ever be requested if we offer NODE_BLOOM
2568    if (inv.IsMsgFilteredBlk() && !(peer.m_our_services & NODE_BLOOM)) {
2569        LogDebug(BCLog::NET, "filtered block request received when NODE_BLOOM service disabled, %s", pfrom.DisconnectMsg());
2570        pfrom.fDisconnect = true;
2571        return;
2572    }
2573
2574    std::shared_ptr<const CBlock> a_recent_block;
2575    std::shared_ptr<const CBlockHeaderAndShortTxIDs> a_recent_compact_block;
2576    {
2577        LOCK(m_most_recent_block_mutex);
2578        a_recent_block = m_most_recent_block;
2579        a_recent_compact_block = m_most_recent_compact_block;
2580    }
2581
2582    bool need_activate_chain = false;
2583    {
2584        LOCK(cs_main);
2585        const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(inv.hash);
2586        if (pindex) {
2587            if (pindex->HaveNumChainTxs() && !pindex->IsValid(BLOCK_VALID_SCRIPTS) &&
2588                    pindex->IsValid(BLOCK_VALID_TREE)) {
2589                // If we have the block and all of its parents, but have not yet validated it,
2590                // we might be in the middle of connecting it (ie in the unlock of cs_main
2591                // before ActivateBestChain but after AcceptBlock).
2592                // In this case, we need to run ActivateBestChain prior to checking the relay
2593                // conditions below.
2594                need_activate_chain = true;
2595            }
2596        }
2597    } // release cs_main before calling ActivateBestChain
2598    if (need_activate_chain) {
2599        BlockValidationState state;
2600        if (!m_chainman.ActiveChainstate().ActivateBestChain(state, a_recent_block)) {
2601            LogDebug(BCLog::NET, "failed to activate chain (%s)\n", state.ToString());
2602        }
2603    }
2604
2605    const CBlockIndex* pindex{nullptr};
2606    const CBlockIndex* tip{nullptr};
2607    bool can_direct_fetch{false};
2608    FlatFilePos block_pos{};
2609    {
2610        LOCK(cs_main);
2611        pindex = m_chainman.m_blockman.LookupBlockIndex(inv.hash);
2612        if (!pindex) {
2613            return;
2614        }
2615        if (!BlockRequestAllowed(*pindex)) {
2616            LogDebug(BCLog::NET, "%s: ignoring request from peer=%i for old block that isn't in the main chain\n", __func__, pfrom.GetId());
2617            return;
2618        }
2619        // disconnect node in case we have reached the outbound limit for serving historical blocks
2620        if (m_connman.OutboundTargetReached(true) &&
2621            (((m_chainman.m_best_header != nullptr) && (m_chainman.m_best_header->GetBlockTime() - pindex->GetBlockTime() > HISTORICAL_BLOCK_AGE)) || inv.IsMsgFilteredBlk()) &&
2622            !pfrom.HasPermission(NetPermissionFlags::Download) // nodes with the download permission may exceed target
2623        ) {
2624            LogDebug(BCLog::NET, "historical block serving limit reached, %s", pfrom.DisconnectMsg());
2625            pfrom.fDisconnect = true;
2626            return;
2627        }
2628        tip = m_chainman.ActiveChain().Tip();
2629        // Avoid leaking prune-height by never sending blocks below the NODE_NETWORK_LIMITED threshold
2630        if (!pfrom.HasPermission(NetPermissionFlags::NoBan) && (
2631                (((peer.m_our_services & NODE_NETWORK_LIMITED) == NODE_NETWORK_LIMITED) && ((peer.m_our_services & NODE_NETWORK) != NODE_NETWORK) && (tip->nHeight - pindex->nHeight > (int)NODE_NETWORK_LIMITED_MIN_BLOCKS + 2 /* add two blocks buffer extension for possible races */) )
2632           )) {
2633            LogDebug(BCLog::NET, "Ignore block request below NODE_NETWORK_LIMITED threshold, %s", pfrom.DisconnectMsg());
2634            //disconnect node and prevent it from stalling (would otherwise wait for the missing block)
2635            pfrom.fDisconnect = true;
2636            return;
2637        }
2638        // Pruned nodes may have deleted the block, so check whether
2639        // it's available before trying to send.
2640        if (!(pindex->nStatus & BLOCK_HAVE_DATA)) {
2641            return;
2642        }
2643        can_direct_fetch = CanDirectFetch();
2644        block_pos = pindex->GetBlockPos();
2645    }
2646
2647    std::shared_ptr<const CBlock> pblock;
2648    if (a_recent_block && a_recent_block->GetHash() == inv.hash) {
2649        pblock = a_recent_block;
2650    } else if (inv.IsMsgWitnessBlk()) {
2651        // Fast-path: in this case it is possible to serve the block directly from disk,
2652        // as the network format matches the format on disk
2653        if (const auto block_data{m_chainman.m_blockman.ReadRawBlock(block_pos)}) {
2654            MakeAndPushMessage(pfrom, NetMsgType::BLOCK, std::span{*block_data});
2655        } else {
2656            if (WITH_LOCK(m_chainman.GetMutex(), return m_chainman.m_blockman.IsBlockPruned(*pindex))) {
2657                LogDebug(BCLog::NET, "Block was pruned before it could be read, %s", pfrom.DisconnectMsg());
2658            } else {
2659                LogError("Cannot load block from disk, %s", pfrom.DisconnectMsg());
2660            }
2661            pfrom.fDisconnect = true;
2662            return;
2663        }
2664        // Don't set pblock as we've sent the block
2665    } else {
2666        // Send block from disk
2667        std::shared_ptr<CBlock> pblockRead = std::make_shared<CBlock>();
2668        if (!m_chainman.m_blockman.ReadBlock(*pblockRead, block_pos, inv.hash)) {
2669            if (WITH_LOCK(m_chainman.GetMutex(), return m_chainman.m_blockman.IsBlockPruned(*pindex))) {
2670                LogDebug(BCLog::NET, "Block was pruned before it could be read, %s", pfrom.DisconnectMsg());
2671            } else {
2672                LogError("Cannot load block from disk, %s", pfrom.DisconnectMsg());
2673            }
2674            pfrom.fDisconnect = true;
2675            return;
2676        }
2677        pblock = pblockRead;
2678    }
2679    if (pblock) {
2680        if (inv.IsMsgBlk()) {
2681            MakeAndPushMessage(pfrom, NetMsgType::BLOCK, TX_NO_WITNESS(*pblock));
2682        } else if (inv.IsMsgWitnessBlk()) {
2683            MakeAndPushMessage(pfrom, NetMsgType::BLOCK, TX_WITH_WITNESS(*pblock));
2684        } else if (inv.IsMsgFilteredBlk()) {
2685            bool sendMerkleBlock = false;
2686            CMerkleBlock merkleBlock;
2687            if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
2688                LOCK(tx_relay->m_bloom_filter_mutex);
2689                if (tx_relay->m_bloom_filter) {
2690                    sendMerkleBlock = true;
2691                    merkleBlock = CMerkleBlock(*pblock, *tx_relay->m_bloom_filter);
2692                }
2693            }
2694            if (sendMerkleBlock) {
2695                MakeAndPushMessage(pfrom, NetMsgType::MERKLEBLOCK, merkleBlock);
2696                // CMerkleBlock just contains hashes, so also push any transactions in the block the client did not see
2697                // This avoids hurting performance by pointlessly requiring a round-trip
2698                // Note that there is currently no way for a node to request any single transactions we didn't send here -
2699                // they must either disconnect and retry or request the full block.
2700                // Thus, the protocol spec specified allows for us to provide duplicate txn here,
2701                // however we MUST always provide at least what the remote peer needs
2702                for (const auto& [tx_idx, _] : merkleBlock.vMatchedTxn)
2703                    MakeAndPushMessage(pfrom, NetMsgType::TX, TX_NO_WITNESS(*pblock->vtx[tx_idx]));
2704            }
2705            // else
2706            // no response
2707        } else if (inv.IsMsgCmpctBlk()) {
2708            // If a peer is asking for old blocks, we're almost guaranteed
2709            // they won't have a useful mempool to match against a compact block,
2710            // and we don't feel like constructing the object for them, so
2711            // instead we respond with the full, non-compact block.
2712            if (can_direct_fetch && pindex->nHeight >= tip->nHeight - MAX_CMPCTBLOCK_DEPTH) {
2713                if (a_recent_compact_block && a_recent_compact_block->header.GetHash() == inv.hash) {
2714                    MakeAndPushMessage(pfrom, NetMsgType::CMPCTBLOCK, *a_recent_compact_block);
2715                } else {
2716                    CBlockHeaderAndShortTxIDs cmpctblock{*pblock, m_rng.rand64()};
2717                    MakeAndPushMessage(pfrom, NetMsgType::CMPCTBLOCK, cmpctblock);
2718                }
2719            } else {
2720                MakeAndPushMessage(pfrom, NetMsgType::BLOCK, TX_WITH_WITNESS(*pblock));
2721            }
2722        }
2723    }
2724
2725    {
2726        LOCK(peer.m_block_inv_mutex);
2727        // Trigger the peer node to send a getblocks request for the next batch of inventory
2728        if (inv.hash == peer.m_continuation_block) {
2729            // Send immediately. This must send even if redundant,
2730            // and we want it right after the last block so they don't
2731            // wait for other stuff first.
2732            std::vector<CInv> vInv;
2733            vInv.emplace_back(MSG_BLOCK, tip->GetBlockHash());
2734            MakeAndPushMessage(pfrom, NetMsgType::INV, vInv);
2735            peer.m_continuation_block.SetNull();
2736        }
2737    }
2738}
2739
2740CTransactionRef PeerManagerImpl::FindTxForGetData(const Peer::TxRelay& tx_relay, const GenTxid& gtxid)
2741{
2742    // If a tx was in the mempool prior to the last INV for this peer, permit the request.
2743    auto txinfo{std::visit(
2744        [&](const auto& id) {
2745            return m_mempool.info_for_relay(id, WITH_LOCK(tx_relay.m_tx_inventory_mutex, return tx_relay.m_last_inv_sequence));
2746        },
2747        gtxid)};
2748    if (txinfo.tx) {
2749        return std::move(txinfo.tx);
2750    }