Method ProcessHeadersMessage

src/net_processing.cpp:2085–2320

}

void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
                                            const std::vector<CBlockHeader>& headers,
                                            bool via_compact_block)
{
    const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
    size_t nCount = headers.size();

    if (nCount == 0) {
        // Nothing interesting. Stop asking this peers for more headers.
        return;
    }

    // If we are already too far ahead of where we want to be on headers, discard
    //   the received headers. We can still get ahead by up to a single maximum-sized
    //   headers message here, but never further, so that's fine.
    if (node::fTrimHeaders) {
        LOCK(cs_main);
        if (pindexBestHeader)  {
            int64_t headers_ahead = pindexBestHeader->nHeight - m_chainman.ActiveHeight();
            if (headers_ahead >= node::nHeaderDownloadBuffer) {
                CNodeState *nodestate = State(pfrom.GetId());
                if ((nodestate->pindexBestKnownBlock == nullptr) ||
                (nodestate->pindexBestKnownBlock->nHeight < m_chainman.ActiveHeight())) {
                    // Our notion of what blocks a peer has available is based on its pindexBestKnownBlock,
                    // which is based on headers received from it. If we don't have one, or it's too old,
                    // then we can never get blocks from this peer until we accept headers from it first.
                    LogPrint(BCLog::NET, "NOT discarding headers from peer=%d, to update its block availability. (current best header %d, active chain height %d)\n", pfrom.GetId(), pindexBestHeader->nHeight, m_chainman.ActiveHeight());
                } else {
                    LogPrint(BCLog::NET, "Discarding received headers and pausing header sync from peer=%d, because we are too far ahead of block sync. (%d > %d)\n", pfrom.GetId(), pindexBestHeader->nHeight, m_chainman.ActiveHeight());
                    if (nodestate->fSyncStarted) {
                        // Cancel sync from this node, so we don't penalize it later.
                        // This will cause us to automatically start syncing from a different node (or restart syncing from the same node) later,
                        //   if we still need to sync headers.
                        nSyncStarted--;
                        nodestate->fSyncStarted = false;
                        nodestate->m_headers_sync_timeout = 0us;
                    }
                    return;
                }
            }
        }
    }

    bool received_new_header = false;
    const CBlockIndex *pindexLast = nullptr;
    {
        LOCK(cs_main);
        CNodeState *nodestate = State(pfrom.GetId());

        // If this looks like it could be a block announcement (nCount <
        // MAX_BLOCKS_TO_ANNOUNCE), use special logic for handling headers that
        // don't connect:
        // - Send a getheaders message in response to try to connect the chain.
        // - The peer can send up to MAX_UNCONNECTING_HEADERS in a row that
        //   don't connect before giving DoS points
        // - Once a headers message is received that is valid and does connect,
        //   nUnconnectingHeaders gets reset back to 0.
        if (!m_chainman.m_blockman.LookupBlockIndex(headers[0].hashPrevBlock) && nCount < MAX_BLOCKS_TO_ANNOUNCE) {