Method HeadersDirectFetchBlocks

src/net_processing.cpp:3982–4045

* Given a new headers tip ending in last_header, potentially request blocks * towards that tip. We require that the given tip have at least as much work as * our tip, and for our current tip to be "close to synced" (see * CanDirectFetch()). */

 * CanDirectFetch()).
 */
void PeerManagerImpl::HeadersDirectFetchBlocks(const Config &config,
                                               CNode &pfrom,
                                               const CBlockIndex &last_header) {
    LOCK(cs_main);
    CNodeState *nodestate = State(pfrom.GetId());

    if (CanDirectFetch() && last_header.IsValid(BlockValidity::TREE) &&
        m_chainman.ActiveChain().Tip()->nChainWork <= last_header.nChainWork) {
        std::vector<const CBlockIndex *> vToFetch;
        const CBlockIndex *pindexWalk{&last_header};
        // Calculate all the blocks we'd need to switch to last_header, up to
        // a limit.
        while (pindexWalk && !m_chainman.ActiveChain().Contains(pindexWalk) &&
               vToFetch.size() <= MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
            if (!pindexWalk->nStatus.hasData() &&
                !IsBlockRequested(pindexWalk->GetBlockHash())) {
                // We don't have this block, and it's not yet in flight.
                vToFetch.push_back(pindexWalk);
            }
            pindexWalk = pindexWalk->pprev;
        }
        // If pindexWalk still isn't on our main chain, we're looking at a
        // very large reorg at a time we think we're close to caught up to
        // the main chain -- this shouldn't really happen. Bail out on the
        // direct fetch and rely on parallel download instead.
        if (!m_chainman.ActiveChain().Contains(pindexWalk)) {
            LogPrint(BCLog::NET, "Large reorg, won't direct fetch to %s (%d)\n",
                     last_header.GetBlockHash().ToString(),
                     last_header.nHeight);
        } else {
            std::vector<CInv> vGetData;
            // Download as much as possible, from earliest to latest.
            for (const CBlockIndex *pindex : reverse_iterate(vToFetch)) {
                if (nodestate->vBlocksInFlight.size() >=
                    MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
                    // Can't download any more from this peer
                    break;
                }
                vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
                BlockRequested(config, pfrom.GetId(), *pindex);
                LogPrint(BCLog::NET, "Requesting block %s from  peer=%d\n",
                         pindex->GetBlockHash().ToString(), pfrom.GetId());
            }
            if (vGetData.size() > 1) {
                LogPrint(BCLog::NET,
                         "Downloading blocks toward %s (%d) via headers "
                         "direct fetch\n",
                         last_header.GetBlockHash().ToString(),
                         last_header.nHeight);
            }
            if (vGetData.size() > 0) {
                if (!m_opts.ignore_incoming_txs &&
                    nodestate->m_provides_cmpctblocks && vGetData.size() == 1 &&
                    mapBlocksInFlight.size() == 1 &&
                    last_header.pprev->IsValid(BlockValidity::CHAIN)) {
                    // In any case, we want to download using a compact
                    // block, not a regular one.
                    vGetData[0] = CInv(MSG_CMPCT_BLOCK, vGetData[0].hash);