What peer messages mean

6001    const bool rate_limited = !pfrom.HasPermission(NetPermissionFlags::Addr);
6002    uint64_t num_proc = 0;
6003    uint64_t num_rate_limit = 0;
6004    std::shuffle(vAddr.begin(), vAddr.end(), m_rng);
6005    for (CAddress& addr : vAddr)
6006    {
6007        if (interruptMsgProc)
6008            return;
6009
6010        // Apply rate limiting.
6011        if (peer.m_addr_token_bucket < 1.0) {
6012            if (rate_limited) {
6013                ++num_rate_limit;
6014                continue;
6015            }
6016        } else {
6017            peer.m_addr_token_bucket -= 1.0;
6018        }
6019        // We only bother storing full nodes, though this may include
6020        // things which we would not make an outbound connection to, in
6021        // part because we may make feeler connections to them.
6022        if (!MayHaveUsefulAddressDB(addr.nServices) && !HasAllDesirableServiceFlags(addr.nServices))
6023            continue;
6024
6025        if (addr.nTime <= NodeSeconds{100000000s} || addr.nTime > current_time + 10min) {
6026            addr.nTime = std::chrono::time_point_cast<std::chrono::seconds>(current_time - 5 * 24h);
6027        }
6028        AddAddressKnown(peer, addr);
6029        if (m_banman && (m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr))) {
6030            // Do not process banned/discouraged addresses beyond remembering we received them
6031            continue;
6032        }
6033        ++num_proc;
6034        const bool reachable{g_reachable_nets.Contains(addr)};
6035        if (addr.nTime > current_time - 10min && !peer.m_getaddr_sent && vAddr.size() <= 10 && addr.IsRoutable()) {
6036            // Relay to a limited number of other nodes
6037            RelayAddress(pfrom.GetId(), addr, reachable);
6038        }
6039        // Do not store addresses outside our network
6040        if (reachable) {
6041            vAddrOk.push_back(addr);
6042        }
6043    }
6044    peer.m_addr_processed += num_proc;
6045    peer.m_addr_rate_limited += num_rate_limit;
6046    LogDebug(BCLog::NET, "Received addr: %u addresses (%u processed, %u rate-limited) from peer=%d\n",
6047             vAddr.size(), num_proc, num_rate_limit, pfrom.GetId());
6048
6049    m_addrman.Add(vAddrOk, pfrom.addr, /*time_penalty=*/2h);
6050    if (vAddr.size() < 1000) peer.m_getaddr_sent = false;
6051
6052    // AddrFetch: Require multiple addresses to avoid disconnecting on self-announcements
6053    if (pfrom.IsAddrFetchConn() && vAddr.size() > 1) {
6054        LogDebug(BCLog::NET, "addrfetch connection completed, %s", pfrom.DisconnectMsg());
6055        pfrom.fDisconnect = true;
6056    }
6057}
6058
6059bool PeerManagerImpl::SendMessages(CNode& node)
6060{
6061    AssertLockNotHeld(m_tx_download_mutex);
6062    AssertLockHeld(g_msgproc_mutex);
6063
6064    PeerRef maybe_peer{GetPeerRef(node.GetId())};
6065    if (!maybe_peer) return false;
6066    Peer& peer{*maybe_peer};
6067    const Consensus::Params& consensusParams = m_chainparams.GetConsensus();
6068
6069    // We must call MaybeDiscourageAndDisconnect first, to ensure that we'll
6070    // disconnect misbehaving peers even before the version handshake is complete.
6071    if (MaybeDiscourageAndDisconnect(node, peer)) return true;
6072
6073    // Initiate version handshake for outbound connections
6074    if (!node.IsInboundConn() && !peer.m_outbound_version_message_sent) {
6075        PushNodeVersion(node, peer);
6076        peer.m_outbound_version_message_sent = true;
6077    }
6078
6079    // Don't send anything until the version handshake is complete
6080    if (!node.fSuccessfullyConnected || node.fDisconnect)
6081        return true;
6082
6083    const auto now{NodeClock::now()};
6084    const auto current_time{GetTime<std::chrono::microseconds>()};
6085
6086    // The logic below does not apply to private broadcast peers, so skip it.
6087    // Also in CConnman::PushMessage() we make sure that unwanted messages are
6088    // not sent. This here is just an optimization.
6089    if (node.IsPrivateBroadcastConn()) {
6090        if (node.m_connected + PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME < now) {
6091            LogDebug(BCLog::PRIVBROADCAST, "Disconnecting: did not complete the transaction send within %d seconds, %s",
6092                     count_seconds(PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME), node.LogPeer());
6093            node.fDisconnect = true;
6094        }
6095        return true;
6096    }
6097
6098    if (node.IsAddrFetchConn() && now - node.m_connected > 10 * AVG_ADDRESS_BROADCAST_INTERVAL) {
6099        LogDebug(BCLog::NET, "addrfetch connection timeout, %s", node.DisconnectMsg());
6100        node.fDisconnect = true;
6101        return true;
6102    }
6103
6104    MaybeSendPing(node, peer, now);
6105
6106    // MaybeSendPing may have marked peer for disconnection
6107    if (node.fDisconnect) return true;
6108
6109    MaybeSendAddr(node, peer, current_time);
6110
6111    MaybeSendSendHeaders(node, peer);
6112
6113    ProcessInvBacklog(now);
6114
6115    {
6116        LOCK(cs_main);
6117
6118        CNodeState &state = *State(node.GetId());
6119
6120        // Start block sync
6121        if (m_chainman.m_best_header == nullptr) {
6122            m_chainman.m_best_header = m_chainman.ActiveChain().Tip();
6123        }
6124
6125        // Determine whether we might try initial headers sync or parallel
6126        // block download from this peer -- this mostly affects behavior while
6127        // in IBD (once out of IBD, we sync from all peers).
6128        bool sync_blocks_and_headers_from_peer = false;
6129        if (state.fPreferredDownload) {
6130            sync_blocks_and_headers_from_peer = true;
6131        } else if (CanServeBlocks(peer) && !node.IsAddrFetchConn()) {
6132            // Typically this is an inbound peer. If we don't have any outbound
6133            // peers, or if we aren't downloading any blocks from such peers,
6134            // then allow block downloads from this peer, too.
6135            // We prefer downloading blocks from outbound peers to avoid
6136            // putting undue load on (say) some home user who is just making
6137            // outbound connections to the network, but if our only source of
6138            // the latest blocks is from an inbound peer, we have to be sure to
6139            // eventually download it (and not just wait indefinitely for an
6140            // outbound peer to have it).
6141            if (m_num_preferred_download_peers == 0 || mapBlocksInFlight.empty()) {
6142                sync_blocks_and_headers_from_peer = true;
6143            }
6144        }
6145
6146        if (!state.fSyncStarted && CanServeBlocks(peer) && !m_chainman.m_blockman.LoadingBlocks()) {
6147            // Only actively request headers from a single peer, unless we're close to today.
6148            if ((nSyncStarted == 0 && sync_blocks_and_headers_from_peer) || m_chainman.m_best_header->Time() > NodeClock::now() - 24h) {
6149                const CBlockIndex* pindexStart = m_chainman.m_best_header;
6150                /* If possible, start at the block preceding the currently
6151                   best known header.  This ensures that we always get a
6152                   non-empty list of headers back as long as the peer
6153                   is up-to-date.  With a non-empty response, we can initialise
6154                   the peer's known best block.  This wouldn't be possible
6155                   if we requested starting at m_chainman.m_best_header and
6156                   got back an empty response.  */
6157                if (pindexStart->pprev)
6158                    pindexStart = pindexStart->pprev;
6159                if (MaybeSendGetHeaders(node, GetLocator(pindexStart), peer)) {
6160                    LogDebug(BCLog::NET, "initial getheaders (%d) to peer=%d", pindexStart->nHeight, node.GetId());
6161
6162                    state.fSyncStarted = true;
6163                    peer.m_headers_sync_timeout = current_time + HEADERS_DOWNLOAD_TIMEOUT_BASE +
6164                        (
6165                         // Convert HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER to microseconds before scaling
6166                         // to maintain precision
6167                         std::chrono::microseconds{HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER} *
6168                         Ticks<std::chrono::seconds>(NodeClock::now() - m_chainman.m_best_header->Time()) / consensusParams.nPowTargetSpacing
6169                        );
6170                    nSyncStarted++;
6171                }
6172            }
6173        }
6174
6175        //
6176        // Try sending block announcements via headers
6177        //
6178        {
6179            // If we have no more than MAX_BLOCKS_TO_ANNOUNCE in our
6180            // list of block hashes we're relaying, and our peer wants
6181            // headers announcements, then find the first header
6182            // not yet known to our peer but would connect, and send.
6183            // If no header would connect, or if we have too many
6184            // blocks, or if the peer doesn't want headers, just
6185            // add all to the inv queue.
6186            LOCK(peer.m_block_inv_mutex);
6187            std::vector<CBlock> vHeaders;
6188            bool fRevertToInv = ((!peer.m_prefers_headers &&
6189                                 (!state.m_requested_hb_cmpctblocks || peer.m_blocks_for_headers_relay.size() > 1)) ||
6190                                 peer.m_blocks_for_headers_relay.size() > MAX_BLOCKS_TO_ANNOUNCE);
6191            const CBlockIndex *pBestIndex = nullptr; // last header queued for delivery
6192            ProcessBlockAvailability(node.GetId()); // ensure pindexBestKnownBlock is up-to-date
6193
6194            if (!fRevertToInv) {
6195                bool fFoundStartingHeader = false;
6196                // Try to find first header that our peer doesn't have, and
6197                // then send all headers past that one.  If we come across any
6198                // headers that aren't on m_chainman.ActiveChain(), give up.
6199                for (const uint256& hash : peer.m_blocks_for_headers_relay) {
6200                    const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(hash);
6201                    assert(pindex);
6202                    if (m_chainman.ActiveChain()[pindex->nHeight] != pindex) {
6203                        // Bail out if we reorged away from this block
6204                        fRevertToInv = true;
6205                        break;
6206                    }
6207                    if (pBestIndex != nullptr && pindex->pprev != pBestIndex) {
6208                        // This means that the list of blocks to announce don't
6209                        // connect to each other.
6210                        // This shouldn't really be possible to hit during
6211                        // regular operation (because reorgs should take us to
6212                        // a chain that has some block not on the prior chain,
6213                        // which should be caught by the prior check), but one
6214                        // way this could happen is by using invalidateblock /
6215                        // reconsiderblock repeatedly on the tip, causing it to
6216                        // be added multiple times to m_blocks_for_headers_relay.
6217                        // Robustly deal with this rare situation by reverting
6218                        // to an inv.
6219                        fRevertToInv = true;
6220                        break;
6221                    }
6222                    pBestIndex = pindex;
6223                    if (fFoundStartingHeader) {
6224                        // add this to the headers message
6225                        vHeaders.emplace_back(pindex->GetBlockHeader());
6226                    } else if (PeerHasHeader(&state, pindex)) {
6227                        continue; // keep looking for the first new block
6228                    } else if (pindex->pprev == nullptr || PeerHasHeader(&state, pindex->pprev)) {
6229                        // Peer doesn't have this header but they do have the prior one.
6230                        // Start sending headers.
6231                        fFoundStartingHeader = true;
6232                        vHeaders.emplace_back(pindex->GetBlockHeader());
6233                    } else {
6234                        // Peer doesn't have this header or the prior one -- nothing will
6235                        // connect, so bail out.
6236                        fRevertToInv = true;
6237                        break;
6238                    }
6239                }
6240            }
6241            if (!fRevertToInv && !vHeaders.empty()) {
6242                if (vHeaders.size() == 1 && state.m_requested_hb_cmpctblocks) {
6243                    // We only send up to 1 block as header-and-ids, as otherwise
6244                    // probably means we're doing an initial-ish-sync or they're slow
6245                    LogDebug(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", __func__,
6246                            vHeaders.front().GetHash().ToString(), node.GetId());
6247
6248                    std::optional<CSerializedNetMsg> cached_cmpctblock_msg;
6249                    {
6250                        LOCK(m_most_recent_block_mutex);