3751                std::vector<CInv> invs;
3752                invs.emplace_back(MSG_BLOCK | GetFetchFlags(peer), block_transactions.blockhash);
3753                MakeAndPushMessage(pfrom, NetMsgType::GETDATA, invs);
3754            } else {
3755                RemoveBlockRequest(block_transactions.blockhash, pfrom.GetId());
3756                LogDebug(BCLog::NET, "Peer %d sent us a compact block but it failed to reconstruct, waiting on first download to complete\n", pfrom.GetId());
3757                return;
3758            }
3759        } else {
3760            // Block is okay for further processing
3761            RemoveBlockRequest(block_transactions.blockhash, pfrom.GetId()); // it is now an empty pointer
3762            fBlockRead = true;
3763            // mapBlockSource is used for potentially punishing peers and
3764            // updating which peers send us compact blocks, so the race
3765            // between here and cs_main in ProcessNewBlock is fine.
3766            // BIP 152 permits peers to relay compact blocks after validating
3767            // the header only; we should not punish peers if the block turns
3768            // out to be invalid.
3769            mapBlockSource.emplace(block_transactions.blockhash, std::make_pair(pfrom.GetId(), false));
3770        }
3771    } // Don't hold cs_main when we call into ProcessNewBlock
3772    if (fBlockRead) {
3773        // Since we requested this block (it was in mapBlocksInFlight), force it to be processed,
3774        // even if it would not be a candidate for new tip (missing previous block, chain not long enough, etc)
3775        // This bypasses some anti-DoS logic in AcceptBlock (eg to prevent
3776        // disk-space attacks), but this should be safe due to the
3777        // protections in the compact block handler -- see related comment
3778        // in compact block optimistic reconstruction handling.
3779        ProcessBlock(pfrom, pblock, /*force_processing=*/true, /*min_pow_checked=*/true);
3780    }
3781    return;
3782}
3783
3784void PeerManagerImpl::LogBlockHeader(const CBlockIndex& index, const CNode& peer, bool via_compact_block) {
3785    // To prevent log spam, this function should only be called after it was determined that a
3786    // header is both new and valid.
3787    //
3788    // These messages are valuable for detecting potential selfish mining behavior;
3789    // if multiple displacing headers are seen near simultaneously across many
3790    // nodes in the network, this might be an indication of selfish mining.
3791    // In addition it can be used to identify peers which send us a header, but
3792    // don't followup with a complete and valid (compact) block.
3793    // Having this log by default when not in IBD ensures broad availability of
3794    // this data in case investigation is merited.
3795    const auto msg = strprintf(
3796        "Saw new %sheader hash=%s height=%d %s",
3797        via_compact_block ? "cmpctblock " : "",
3798        index.GetBlockHash().ToString(),
3799        index.nHeight,
3800        peer.LogPeer()
3801    );
3802    if (m_chainman.IsInitialBlockDownload()) {
3803        LogDebug(BCLog::VALIDATION, "%s", msg);
3804    } else {
3805        LogInfo("%s", msg);
3806    }
3807}
3808
3809void PeerManagerImpl::PushPrivateBroadcastTx(CNode& node)
3810{
3811    Assume(node.IsPrivateBroadcastConn());
3812
3813    const auto opt_tx{m_tx_for_private_broadcast.PickTxForSend(node.GetId(), CService{node.addr})};
3814    if (!opt_tx) {
3815        LogDebug(BCLog::PRIVBROADCAST, "Disconnecting: no more transactions for private broadcast (connected in vain), %s", node.LogPeer());
3816        node.fDisconnect = true;
3817        return;
3818    }
3819    const CTransactionRef& tx{*opt_tx};
3820
3821    LogDebug(BCLog::PRIVBROADCAST, "P2P handshake completed, sending INV for txid=%s%s, %s",
3822             tx->GetHash().ToString(), tx->HasWitness() ? strprintf(", wtxid=%s", tx->GetWitnessHash().ToString()) : "",
3823             node.LogPeer());
3824
3825    MakeAndPushMessage(node, NetMsgType::INV, std::vector<CInv>{{CInv{MSG_TX, tx->GetHash().ToUint256()}}});
3826}
3827
3828void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string& msg_type, DataStream& vRecv,
3829                                     const NodeClock::time_point time_received,
3830                                     const std::atomic<bool>& interruptMsgProc)
3831{
3832    AssertLockHeld(g_msgproc_mutex);
3833
3834    LogDebug(BCLog::NET, "received: %s (%u bytes) peer=%d\n", SanitizeString(msg_type), vRecv.size(), pfrom.GetId());
3835
3836
3837    if (msg_type == NetMsgType::VERSION) {
3838        if (pfrom.nVersion != 0) {
3839            LogDebug(BCLog::NET, "redundant version message from peer=%d\n", pfrom.GetId());
3840            return;
3841        }
3842
3843        int64_t nTime;
3844        CService addrMe;
3845        uint64_t nNonce = 1;
3846        ServiceFlags nServices;
3847        int nVersion;
3848        std::string cleanSubVer;
3849        int starting_height = -1;
3850        bool fRelay = true;
3851
3852        vRecv >> nVersion >> Using<CustomUintFormatter<8>>(nServices) >> nTime;
3853        if (nTime < 0) {
3854            nTime = 0;
3855        }
3856        vRecv.ignore(8); // Ignore the addrMe service bits sent by the peer
3857        vRecv >> CNetAddr::V1(addrMe);
3858        if (!pfrom.IsInboundConn() && !pfrom.IsPrivateBroadcastConn())
3859        {
3860            // Overwrites potentially existing services. In contrast to this,
3861            // unvalidated services received via gossip relay in ADDR/ADDRV2
3862            // messages are only ever added but cannot replace existing ones.
3863            m_addrman.SetServices(pfrom.addr, nServices);
3864        }
3865        if (pfrom.ExpectServicesFromConn() && !HasAllDesirableServiceFlags(nServices))
3866        {
3867            LogDebug(BCLog::NET, "peer does not offer the expected services (%08x offered, %08x expected), %s",
3868                     nServices,
3869                     GetDesirableServiceFlags(nServices),
3870                     pfrom.DisconnectMsg());
3871            pfrom.fDisconnect = true;
3872            return;
3873        }
3874
3875        if (nVersion < MIN_PEER_PROTO_VERSION) {
3876            // disconnect from peers older than this proto version
3877            LogDebug(BCLog::NET, "peer using obsolete version %i, %s", nVersion, pfrom.DisconnectMsg());
3878            pfrom.fDisconnect = true;
3879            return;
3880        }
3881
3882        if (!vRecv.empty()) {
3883            // The version message includes information about the sending node which we don't use:
3884            //   - 8 bytes (service bits)
3885            //   - 16 bytes (ipv6 address)
3886            //   - 2 bytes (port)
3887            vRecv.ignore(26);
3888            vRecv >> nNonce;
3889        }
3890        if (!vRecv.empty()) {
3891            std::string strSubVer;
3892            vRecv >> LIMITED_STRING(strSubVer, MAX_SUBVERSION_LENGTH);
3893            cleanSubVer = SanitizeString(strSubVer);
3894        }
3895        if (!vRecv.empty()) {
3896            vRecv >> starting_height;
3897        }
3898        if (!vRecv.empty())
3899            vRecv >> fRelay;
3900        // Disconnect if we connected to ourself
3901        if (pfrom.IsInboundConn() && !m_connman.CheckIncomingNonce(nNonce))
3902        {
3903            LogInfo("connected to self at %s, disconnecting\n", pfrom.addr.ToStringAddrPort());
3904            pfrom.fDisconnect = true;
3905            return;
3906        }
3907
3908        if (pfrom.IsInboundConn() && addrMe.IsRoutable())
3909        {
3910            SeenLocal(addrMe);
3911        }
3912
3913        // Inbound peers send us their version message when they connect.
3914        // We send our version message in response.
3915        if (pfrom.IsInboundConn()) {
3916            PushNodeVersion(pfrom, peer);
3917        }
3918
3919        // Change version
3920        const int greatest_common_version = std::min(nVersion, pfrom.AdvertisedVersion());
3921        pfrom.SetCommonVersion(greatest_common_version);
3922        pfrom.nVersion = nVersion;
3923
3924        pfrom.m_has_all_wanted_services = HasAllDesirableServiceFlags(nServices);
3925        peer.m_their_services = nServices;
3926        pfrom.SetAddrLocal(addrMe);
3927        {
3928            LOCK(pfrom.m_subver_mutex);
3929            pfrom.cleanSubVer = cleanSubVer;
3930        }
3931
3932        // Only initialize the Peer::TxRelay m_relay_txs data structure if:
3933        // - this isn't an outbound block-relay-only connection, and
3934        // - this isn't an outbound feeler connection, and
3935        // - fRelay=true (the peer wishes to receive transaction announcements)
3936        //   or we're offering NODE_BLOOM to this peer. NODE_BLOOM means that
3937        //   the peer may turn on transaction relay later.
3938        if (!pfrom.IsBlockOnlyConn() &&
3939            !pfrom.IsFeelerConn() &&
3940            (fRelay || (peer.m_our_services & NODE_BLOOM))) {
3941            auto* const tx_relay = peer.SetTxRelay();
3942            {
3943                LOCK(tx_relay->m_bloom_filter_mutex);
3944                tx_relay->m_relay_txs = fRelay; // set to true after we get the first filter* message
3945            }
3946            if (fRelay) pfrom.m_relays_txs = true;
3947        }
3948
3949        const auto mapped_as{m_connman.GetMappedAS(pfrom.addr)};
3950        LogDebug(BCLog::NET, "receive version message: %s: version %d, blocks=%d, us=%s, txrelay=%d, %s%s",
3951                  cleanSubVer.empty() ? "<no user agent>" : cleanSubVer, pfrom.nVersion,
3952                  starting_height, addrMe.ToStringAddrPort(), fRelay, pfrom.LogPeer(),
3953                  (mapped_as ? strprintf(", mapped_as=%d", mapped_as) : ""));
3954
3955        if (pfrom.IsPrivateBroadcastConn()) {
3956            if (fRelay) {
3957                MakeAndPushMessage(pfrom, NetMsgType::VERACK);
3958            } else {
3959                LogDebug(BCLog::PRIVBROADCAST, "Disconnecting: does not support transaction relay (connected in vain), %s",
3960                         pfrom.LogPeer());
3961                pfrom.fDisconnect = true;
3962            }
3963            return;
3964        }
3965
3966        if (greatest_common_version >= WTXID_RELAY_VERSION) {
3967            MakeAndPushMessage(pfrom, NetMsgType::WTXIDRELAY);
3968        }
3969
3970        // Signal ADDRv2 support (BIP155).
3971        if (greatest_common_version >= 70016) {
3972            // BIP155 defines addrv2 and sendaddrv2 for all protocol versions, but some
3973            // implementations reject messages they don't know. As a courtesy, don't send
3974            // it to nodes with a version before 70016, as no software is known to support
3975            // BIP155 that doesn't announce at least that protocol version number.
3976            MakeAndPushMessage(pfrom, NetMsgType::SENDADDRV2);
3977        }
3978
3979        if (greatest_common_version >= WTXID_RELAY_VERSION && m_txreconciliation) {
3980            // Per BIP-330, we announce txreconciliation support if:
3981            // - protocol version per the peer's VERSION message supports WTXID_RELAY;
3982            // - transaction relay is supported per the peer's VERSION message
3983            // - this is not a block-relay-only connection and not a feeler
3984            // - this is not an addr fetch connection;
3985            // - we are not in -blocksonly mode.
3986            const auto* tx_relay = peer.GetTxRelay();
3987            if (tx_relay && WITH_LOCK(tx_relay->m_bloom_filter_mutex, return tx_relay->m_relay_txs) &&
3988                !pfrom.IsAddrFetchConn() && !m_opts.ignore_incoming_txs) {
3989                const uint64_t recon_salt = m_txreconciliation->PreRegisterPeer(pfrom.GetId());
3990                MakeAndPushMessage(pfrom, NetMsgType::SENDTXRCNCL,
3991                                   TXRECONCILIATION_VERSION, recon_salt);
3992            }
3993        }
3994
3995        if (greatest_common_version >= FEATURE_VERSION) {
3996            // announce supported features
3997            // MakeAndPushFeature(pfrom, NetMsgFeature::FOO, uint32_t{1});
3998        }
3999
4000        // If we have too many tx-relaying inbound peers, attempt to evict an existing one.