What peer messages mean

4751            }
4752
4753            if (package_to_validate) {
4754                const auto package_result{ProcessNewPackage(m_chainman.ActiveChainstate(), m_mempool, package_to_validate->m_txns, /*test_accept=*/false, /*client_maxfeerate=*/std::nullopt)};
4755                LogDebug(BCLog::TXPACKAGES, "package evaluation for %s: %s\n", package_to_validate->ToString(),
4756                         package_result.m_state.IsValid() ? "package accepted" : "package rejected");
4757                ProcessPackageResult(package_to_validate.value(), package_result);
4758            }
4759            return;
4760        }
4761
4762        // ReceivedTx should not be telling us to validate the tx and a package.
4763        Assume(!package_to_validate.has_value());
4764
4765        const MempoolAcceptResult result = m_chainman.ProcessTransaction(ptx);
4766        const TxValidationState& state = result.m_state;
4767
4768        if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
4769            ProcessValidTx(pfrom.GetId(), ptx, result.m_replaced_transactions);
4770            pfrom.m_last_tx_time = GetTime<std::chrono::seconds>();
4771        }
4772        if (state.IsInvalid()) {
4773            if (auto package_to_validate{ProcessInvalidTx(pfrom.GetId(), ptx, state, /*first_time_failure=*/true)}) {
4774                const auto package_result{ProcessNewPackage(m_chainman.ActiveChainstate(), m_mempool, package_to_validate->m_txns, /*test_accept=*/false, /*client_maxfeerate=*/std::nullopt)};
4775                LogDebug(BCLog::TXPACKAGES, "package evaluation for %s: %s\n", package_to_validate->ToString(),
4776                         package_result.m_state.IsValid() ? "package accepted" : "package rejected");
4777                ProcessPackageResult(package_to_validate.value(), package_result);
4778            }
4779        }
4780
4781        return;
4782    }
4783
4784    if (msg_type == NetMsgType::CMPCTBLOCK)
4785    {
4786        // Ignore cmpctblock received while importing
4787        if (m_chainman.m_blockman.LoadingBlocks()) {
4788            LogDebug(BCLog::CMPCTBLOCK, "%s sent us a compact block even though we are still loading blocks!", pfrom.LogPeer());
4789            return;
4790        } else if (m_opts.ignore_incoming_txs) {
4791            LogDebug(BCLog::CMPCTBLOCK, "%s sent us a compact block even though we are blocksonly!", pfrom.LogPeer());
4792            return;
4793        }
4794
4795        {
4796            LOCK(cs_main);
4797            const CNodeState *nodestate = State(pfrom.GetId());
4798            if (!nodestate->m_provides_cmpctblocks) {
4799                LogDebug(BCLog::CMPCTBLOCK, "%s sent us a compact block despite never having sent us a SENDCMPCT!", pfrom.LogPeer());
4800                return;
4801            }
4802        }
4803
4804        CBlockHeaderAndShortTxIDs cmpctblock;
4805        vRecv >> cmpctblock;
4806
4807        bool received_new_header = false;
4808        const auto blockhash = cmpctblock.header.GetHash();
4809
4810        {
4811        LOCK(cs_main);
4812
4813        const CBlockIndex* prev_block = m_chainman.m_blockman.LookupBlockIndex(cmpctblock.header.hashPrevBlock);
4814        if (!prev_block) {
4815            // Doesn't connect (or is genesis), instead of DoSing in AcceptBlockHeader, request deeper headers
4816            if (!m_chainman.IsInitialBlockDownload()) {
4817                MaybeSendGetHeaders(pfrom, GetLocator(m_chainman.m_best_header), peer);
4818            }
4819            return;
4820        } else if (prev_block->nChainWork + GetBlockProof(cmpctblock.header) < GetAntiDoSWorkThreshold()) {
4821            // If we get a low-work header in a compact block, we can ignore it.
4822            LogDebug(BCLog::NET, "Ignoring low-work compact block from peer %d\n", pfrom.GetId());
4823            return;
4824        }
4825
4826        if (!m_chainman.m_blockman.LookupBlockIndex(blockhash)) {
4827            received_new_header = true;
4828        }
4829        }
4830
4831        const CBlockIndex *pindex = nullptr;
4832        BlockValidationState state;
4833        if (!m_chainman.ProcessNewBlockHeaders({{cmpctblock.header}}, /*min_pow_checked=*/true, state, &pindex)) {
4834            if (state.IsInvalid()) {
4835                MaybePunishNodeForBlock(pfrom.GetId(), state, /*via_compact_block=*/true, "invalid header via cmpctblock");
4836                return;
4837            }
4838        }
4839
4840        // If AcceptBlockHeader returned true, it set pindex
4841        Assert(pindex);
4842        if (received_new_header) {
4843            LogBlockHeader(*pindex, pfrom, /*via_compact_block=*/true);
4844        }
4845
4846        bool fProcessBLOCKTXN = false;
4847
4848        // If we end up treating this as a plain headers message, call that as well
4849        // without cs_main.
4850        bool fRevertToHeaderProcessing = false;
4851
4852        // Keep a CBlock for "optimistic" compactblock reconstructions (see
4853        // below)
4854        std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
4855        bool fBlockReconstructed = false;
4856
4857        {
4858        LOCK(cs_main);
4859        UpdateBlockAvailability(pfrom.GetId(), pindex->GetBlockHash());
4860
4861        CNodeState *nodestate = State(pfrom.GetId());
4862
4863        // If this was a new header with more work than our tip, update the
4864        // peer's last block announcement time
4865        if (received_new_header && pindex->nChainWork > m_chainman.ActiveChain().Tip()->nChainWork) {
4866            nodestate->m_last_block_announcement = GetTime();
4867        }
4868
4869        if (pindex->nStatus & BLOCK_HAVE_DATA) // Nothing to do here
4870            return;
4871
4872        auto range_flight = mapBlocksInFlight.equal_range(pindex->GetBlockHash());
4873        size_t already_in_flight = std::distance(range_flight.first, range_flight.second);
4874        bool requested_block_from_this_peer{false};
4875
4876        // Multimap ensures ordering of outstanding requests. It's either empty or first in line.
4877        bool first_in_flight = already_in_flight == 0 || (range_flight.first->second.first == pfrom.GetId());
4878
4879        while (range_flight.first != range_flight.second) {
4880            if (range_flight.first->second.first == pfrom.GetId()) {
4881                requested_block_from_this_peer = true;
4882                break;
4883            }
4884            range_flight.first++;
4885        }
4886
4887        if (!requested_block_from_this_peer && !pfrom.m_bip152_highbandwidth_to) {
4888            LogDebug(BCLog::CMPCTBLOCK, "%s, not marked as high-bandwidth, sent us an unsolicited compact block!", pfrom.LogPeer());
4889            return;
4890        }
4891
4892        if (pindex->nChainWork <= m_chainman.ActiveChain().Tip()->nChainWork || // We know something better
4893                pindex->nTx != 0) { // We had this block at some point, but pruned it
4894            if (requested_block_from_this_peer) {
4895                // We requested this block for some reason, but our mempool will probably be useless
4896                // so we just grab the block via normal getdata
4897                std::vector<CInv> vInv(1);
4898                vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(peer), blockhash);
4899                MakeAndPushMessage(pfrom, NetMsgType::GETDATA, vInv);
4900            }
4901            return;
4902        }
4903
4904        // If we're not close to tip yet, give up and let parallel block fetch work its magic
4905        if (!already_in_flight && !CanDirectFetch()) {
4906            return;
4907        }
4908
4909        // We want to be a bit conservative just to be extra careful about DoS
4910        // possibilities in compact block processing...
4911        if (pindex->nHeight <= m_chainman.ActiveChain().Height() + 2) {
4912            if ((already_in_flight < MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK && nodestate->vBlocksInFlight.size() < MAX_BLOCKS_IN_TRANSIT_PER_PEER) ||
4913                 requested_block_from_this_peer) {
4914                std::list<QueuedBlock>::iterator* queuedBlockIt = nullptr;
4915                if (!BlockRequested(pfrom.GetId(), *pindex, &queuedBlockIt)) {
4916                    if (!(*queuedBlockIt)->partialBlock)
4917                        (*queuedBlockIt)->partialBlock.reset(new PartiallyDownloadedBlock(&m_mempool));
4918                    else {
4919                        // The block was already in flight using compact blocks from the same peer
4920                        LogDebug(BCLog::NET, "Peer sent us compact block we were already syncing!\n");
4921                        return;
4922                    }
4923                }
4924
4925                PartiallyDownloadedBlock& partialBlock = *(*queuedBlockIt)->partialBlock;
4926                ReadStatus status = partialBlock.InitData(cmpctblock, vExtraTxnForCompact);
4927                if (status == READ_STATUS_INVALID) {
4928                    RemoveBlockRequest(pindex->GetBlockHash(), pfrom.GetId()); // Reset in-flight state in case Misbehaving does not result in a disconnect
4929                    Misbehaving(peer, "invalid compact block");
4930                    return;
4931                } else if (status == READ_STATUS_FAILED) {
4932                    if (first_in_flight)  {
4933                        // Duplicate txindexes, the block is now in-flight, so just request it
4934                        std::vector<CInv> vInv(1);
4935                        vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(peer), blockhash);
4936                        MakeAndPushMessage(pfrom, NetMsgType::GETDATA, vInv);
4937                    } else {
4938                        // Give up for this peer and wait for other peer(s)
4939                        RemoveBlockRequest(pindex->GetBlockHash(), pfrom.GetId());
4940                    }
4941                    return;
4942                }
4943
4944                BlockTransactionsRequest req;
4945                for (size_t i = 0; i < cmpctblock.BlockTxCount(); i++) {
4946                    if (!partialBlock.IsTxAvailable(i))
4947                        req.indexes.push_back(i);
4948                }
4949                if (req.indexes.empty()) {
4950                    fProcessBLOCKTXN = true;
4951                } else if (first_in_flight) {
4952                    // We will try to round-trip any compact blocks we get on failure,
4953                    // as long as it's first...
4954                    req.blockhash = pindex->GetBlockHash();
4955                    MakeAndPushMessage(pfrom, NetMsgType::GETBLOCKTXN, req);
4956                } else if (pfrom.m_bip152_highbandwidth_to &&
4957                    (!pfrom.IsInboundConn() ||
4958                    IsBlockRequestedFromOutbound(blockhash) ||
4959                    already_in_flight < MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK - 1)) {
4960                    // ... or it's a hb relay peer and:
4961                    // - peer is outbound, or
4962                    // - we already have an outbound attempt in flight(so we'll take what we can get), or
4963                    // - it's not the final parallel download slot (which we may reserve for first outbound)
4964                    req.blockhash = pindex->GetBlockHash();
4965                    MakeAndPushMessage(pfrom, NetMsgType::GETBLOCKTXN, req);
4966                } else {
4967                    // Give up for this peer and wait for other peer(s)
4968                    RemoveBlockRequest(pindex->GetBlockHash(), pfrom.GetId());
4969                }
4970            } else {
4971                // This block is either already in flight from a different
4972                // peer, or this peer has too many blocks outstanding to
4973                // download from.
4974                // Optimistically try to reconstruct anyway since we might be
4975                // able to without any round trips.
4976                PartiallyDownloadedBlock tempBlock(&m_mempool);
4977                ReadStatus status = tempBlock.InitData(cmpctblock, vExtraTxnForCompact);
4978                if (status != READ_STATUS_OK) {
4979                    // TODO: don't ignore failures
4980                    return;
4981                }
4982                std::vector<CTransactionRef> dummy;
4983                const CBlockIndex* prev_block{Assume(m_chainman.m_blockman.LookupBlockIndex(cmpctblock.header.hashPrevBlock))};
4984                status = tempBlock.FillBlock(*pblock, dummy,
4985                                             /*segwit_active=*/DeploymentActiveAfter(prev_block, m_chainman, Consensus::DEPLOYMENT_SEGWIT));
4986                if (status == READ_STATUS_OK) {
4987                    fBlockReconstructed = true;
4988                }
4989            }
4990        } else {
4991            if (requested_block_from_this_peer) {
4992                // We requested this block, but its far into the future, so our
4993                // mempool will probably be useless - request the block normally
4994                std::vector<CInv> vInv(1);
4995                vInv[0] = CInv(MSG_BLOCK | GetFetchFlags(peer), blockhash);
4996                MakeAndPushMessage(pfrom, NetMsgType::GETDATA, vInv);
4997                return;
4998            } else {
4999                // If this was an announce-cmpctblock, we want the same treatment as a header message
5000                fRevertToHeaderProcessing = true;