What peer messages mean

5751        // This might be unnecessary if the bloom filter has already rolled
5752        // over since our last self-announcement, but there is only a small
5753        // bandwidth cost that we can incur by doing this (which happens
5754        // once a day on average).
5755        if (peer.m_next_local_addr_send != 0us) {
5756            peer.m_addr_known->reset();
5757        }
5758        if (std::optional<CService> local_service = GetLocalAddrForPeer(node)) {
5759            CAddress local_addr{*local_service, peer.m_our_services, Now<NodeSeconds>()};
5760            if (peer.m_next_local_addr_send == 0us) {
5761                // Send the initial self-announcement in its own message. This makes sure
5762                // rate-limiting with limited start-tokens doesn't ignore it if the first
5763                // message ends up containing multiple addresses.
5764                if (IsAddrCompatible(peer, local_addr)) {
5765                    std::vector<CAddress> self_announcement{local_addr};
5766                    if (peer.m_wants_addrv2) {
5767                        MakeAndPushMessage(node, NetMsgType::ADDRV2, CAddress::V2_NETWORK(self_announcement));
5768                    } else {
5769                        MakeAndPushMessage(node, NetMsgType::ADDR, CAddress::V1_NETWORK(self_announcement));
5770                    }
5771                }
5772            } else {
5773                // All later self-announcements are sent together with the other addresses.
5774                PushAddress(peer, local_addr);
5775            }
5776        }
5777        peer.m_next_local_addr_send = current_time + m_rng.rand_exp_duration(AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL);
5778    }
5779
5780    // We sent an `addr` message to this peer recently. Nothing more to do.
5781    if (current_time <= peer.m_next_addr_send) return;
5782
5783    peer.m_next_addr_send = current_time + m_rng.rand_exp_duration(AVG_ADDRESS_BROADCAST_INTERVAL);
5784
5785    if (!Assume(peer.m_addrs_to_send.size() <= MAX_ADDR_TO_SEND)) {
5786        // Should be impossible since we always check size before adding to
5787        // m_addrs_to_send. Recover by trimming the vector.
5788        peer.m_addrs_to_send.resize(MAX_ADDR_TO_SEND);
5789    }
5790
5791    // Remove addr records that the peer already knows about, and add new
5792    // addrs to the m_addr_known filter on the same pass.
5793    auto addr_already_known = [&peer](const CAddress& addr) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) {
5794        bool ret = peer.m_addr_known->contains(addr.GetKey());
5795        if (!ret) peer.m_addr_known->insert(addr.GetKey());
5796        return ret;
5797    };
5798    peer.m_addrs_to_send.erase(std::remove_if(peer.m_addrs_to_send.begin(), peer.m_addrs_to_send.end(), addr_already_known),
5799                           peer.m_addrs_to_send.end());
5800
5801    // No addr messages to send
5802    if (peer.m_addrs_to_send.empty()) return;
5803
5804    if (peer.m_wants_addrv2) {
5805        MakeAndPushMessage(node, NetMsgType::ADDRV2, CAddress::V2_NETWORK(peer.m_addrs_to_send));
5806    } else {
5807        MakeAndPushMessage(node, NetMsgType::ADDR, CAddress::V1_NETWORK(peer.m_addrs_to_send));
5808    }
5809    peer.m_addrs_to_send.clear();
5810
5811    // we only send the big addr message once
5812    if (peer.m_addrs_to_send.capacity() > 40) {
5813        peer.m_addrs_to_send.shrink_to_fit();
5814    }
5815}
5816
5817void PeerManagerImpl::MaybeSendSendHeaders(CNode& node, Peer& peer)
5818{
5819    // Delay sending SENDHEADERS (BIP 130) until we're done with an
5820    // initial-headers-sync with this peer. Receiving headers announcements for
5821    // new blocks while trying to sync their headers chain is problematic,
5822    // because of the state tracking done.
5823    if (!peer.m_sent_sendheaders && node.GetCommonVersion() >= SENDHEADERS_VERSION) {
5824        LOCK(cs_main);
5825        CNodeState &state = *State(node.GetId());
5826        if (state.pindexBestKnownBlock != nullptr &&
5827                state.pindexBestKnownBlock->nChainWork > m_chainman.MinimumChainWork()) {
5828            // Tell our peer we prefer to receive headers rather than inv's
5829            // We send this to non-NODE NETWORK peers as well, because even
5830            // non-NODE NETWORK peers can announce blocks (such as pruning
5831            // nodes)
5832            MakeAndPushMessage(node, NetMsgType::SENDHEADERS);
5833            peer.m_sent_sendheaders = true;
5834        }
5835    }
5836}
5837
5838void PeerManagerImpl::MaybeSendFeefilter(CNode& pto, Peer& peer, std::chrono::microseconds current_time)
5839{
5840    if (m_opts.ignore_incoming_txs) return;
5841    if (pto.GetCommonVersion() < FEEFILTER_VERSION) return;
5842    // peers with the forcerelay permission should not filter txs to us
5843    if (pto.HasPermission(NetPermissionFlags::ForceRelay)) return;
5844    // Don't send feefilter messages to outbound block-relay-only peers since they should never announce
5845    // transactions to us, regardless of feefilter state.
5846    if (pto.IsBlockOnlyConn()) return;
5847
5848    CAmount currentFilter = m_mempool.GetMinFee().GetFeePerK();
5849
5850    if (m_chainman.IsInitialBlockDownload()) {
5851        // Received tx-inv messages are discarded when the active
5852        // chainstate is in IBD, so tell the peer to not send them.
5853        currentFilter = MAX_MONEY;
5854    } else {
5855        static const CAmount MAX_FILTER{m_fee_filter_rounder.round(MAX_MONEY)};
5856        if (peer.m_fee_filter_sent == MAX_FILTER) {
5857            // Send the current filter if we sent MAX_FILTER previously
5858            // and made it out of IBD.
5859            peer.m_next_send_feefilter = 0us;
5860        }
5861    }
5862    if (current_time > peer.m_next_send_feefilter) {
5863        CAmount filterToSend = m_fee_filter_rounder.round(currentFilter);
5864        // We always have a fee filter of at least the min relay fee
5865        filterToSend = std::max(filterToSend, m_mempool.m_opts.min_relay_feerate.GetFeePerK());
5866        if (filterToSend != peer.m_fee_filter_sent) {
5867            MakeAndPushMessage(pto, NetMsgType::FEEFILTER, filterToSend);
5868            peer.m_fee_filter_sent = filterToSend;
5869        }
5870        peer.m_next_send_feefilter = current_time + m_rng.rand_exp_duration(AVG_FEEFILTER_BROADCAST_INTERVAL);
5871    }
5872    // If the fee filter has changed substantially and it's still more than MAX_FEEFILTER_CHANGE_DELAY
5873    // until scheduled broadcast, then move the broadcast to within MAX_FEEFILTER_CHANGE_DELAY.
5874    else if (current_time + MAX_FEEFILTER_CHANGE_DELAY < peer.m_next_send_feefilter &&
5875                (currentFilter < 3 * peer.m_fee_filter_sent / 4 || currentFilter > 4 * peer.m_fee_filter_sent / 3)) {
5876        peer.m_next_send_feefilter = current_time + m_rng.randrange<std::chrono::microseconds>(MAX_FEEFILTER_CHANGE_DELAY);
5877    }
5878}
5879
5880bool PeerManagerImpl::RejectIncomingTxs(const CNode& peer) const
5881{
5882    // block-relay-only peers may never send txs to us
5883    if (peer.IsBlockOnlyConn()) return true;
5884    if (peer.IsFeelerConn()) return true;
5885    // In -blocksonly mode, peers need the 'relay' permission to send txs to us
5886    if (m_opts.ignore_incoming_txs && !peer.HasPermission(NetPermissionFlags::Relay)) return true;
5887    return false;
5888}
5889
5890void PeerManagerImpl::ProcessPong(CNode& pfrom, Peer& peer, const NodeClock::time_point ping_end, DataStream& vRecv)
5891{
5892    uint64_t nonce = 0;
5893    const size_t nAvail{vRecv.size()};
5894    bool bPingFinished = false;
5895    std::string sProblem;
5896
5897    if (nAvail >= sizeof(nonce)) {
5898        vRecv >> nonce;
5899
5900        // Only process pong message if there is an outstanding ping (old ping without nonce should never pong)
5901        if (peer.m_ping_nonce_sent != 0) {
5902            if (nonce == peer.m_ping_nonce_sent) {
5903                // Matching pong received, this ping is no longer outstanding
5904                bPingFinished = true;
5905                const auto ping_time = ping_end - peer.m_ping_start.load();
5906                if (ping_time.count() >= 0) {
5907                    // Let connman know about this successful ping-pong
5908                    pfrom.PongReceived(ping_time);
5909                    if (pfrom.IsPrivateBroadcastConn()) {
5910                        m_tx_for_private_broadcast.NodeConfirmedReception(pfrom.GetId());
5911                        LogDebug(BCLog::PRIVBROADCAST, "Got a PONG (the transaction will probably reach the network), marking for disconnect, %s",
5912                                 pfrom.LogPeer());
5913                        pfrom.fDisconnect = true;
5914                    }
5915                } else {
5916                    // This should never happen
5917                    sProblem = "Timing mishap";
5918                }
5919            } else {
5920                // Nonce mismatches are normal when pings are overlapping
5921                sProblem = "Nonce mismatch";
5922                if (nonce == 0) {
5923                    // This is most likely a bug in another implementation somewhere; cancel this ping
5924                    bPingFinished = true;
5925                    sProblem = "Nonce zero";
5926                }
5927            }
5928        } else {
5929            sProblem = "Unsolicited pong without ping";
5930        }
5931    } else {
5932        // This is most likely a bug in another implementation somewhere; cancel this ping
5933        bPingFinished = true;
5934        sProblem = "Short payload";
5935    }
5936
5937    if (!(sProblem.empty())) {
5938        LogDebug(BCLog::NET, "pong peer=%d: %s, %x expected, %x received, %u bytes\n",
5939                 pfrom.GetId(),
5940                 sProblem,
5941                 peer.m_ping_nonce_sent,
5942                 nonce,
5943                 nAvail);
5944    }
5945    if (bPingFinished) {
5946        peer.m_ping_nonce_sent = 0;
5947    }
5948}
5949
5950bool PeerManagerImpl::SetupAddressRelay(const CNode& node, Peer& peer)
5951{
5952    // We don't participate in addr relay with outbound block-relay-only
5953    // connections to prevent providing adversaries with the additional
5954    // information of addr traffic to infer the link.
5955    if (node.IsBlockOnlyConn()) return false;
5956
5957    // We don't participate in addr relay with feeler connections because
5958    // they are disconnected shortly after the handshake completes,
5959    // before the node will receive the addr response.
5960    if (node.IsFeelerConn()) return false;
5961
5962    if (!peer.m_addr_relay_enabled.exchange(true)) {
5963        // During version message processing (non-block-relay-only outbound peers)
5964        // or on first addr-related message we have received (inbound peers), initialize
5965        // m_addr_known.
5966        peer.m_addr_known = std::make_unique<CRollingBloomFilter>(5000, 0.001);
5967    }
5968
5969    return true;
5970}
5971
5972void PeerManagerImpl::ProcessAddrs(std::string_view msg_type, CNode& pfrom, Peer& peer, std::vector<CAddress>&& vAddr, const std::atomic<bool>& interruptMsgProc)
5973{
5974    AssertLockNotHeld(m_peer_mutex);
5975    AssertLockHeld(g_msgproc_mutex);
5976
5977    if (!SetupAddressRelay(pfrom, peer)) {
5978        LogDebug(BCLog::NET, "ignoring %s message from %s peer=%d\n", msg_type, pfrom.ConnectionTypeAsString(), pfrom.GetId());
5979        return;
5980    }
5981
5982    if (vAddr.size() > MAX_ADDR_TO_SEND)
5983    {
5984        Misbehaving(peer, strprintf("%s message size = %u", msg_type, vAddr.size()));
5985        return;
5986    }
5987
5988    // Store the new addresses
5989    std::vector<CAddress> vAddrOk;
5990
5991    // Update/increment addr rate limiting bucket.
5992    const auto current_time{NodeClock::now()};
5993    if (peer.m_addr_token_bucket < MAX_ADDR_PROCESSING_TOKEN_BUCKET) {
5994        // Don't increment bucket if it's already full
5995        const auto time_diff{current_time - peer.m_addr_token_timestamp};
5996        const double increment{std::max(Ticks<SecondsDouble>(time_diff), 0.0) * MAX_ADDR_RATE_PER_SECOND};
5997        peer.m_addr_token_bucket = std::min<double>(peer.m_addr_token_bucket + increment, MAX_ADDR_PROCESSING_TOKEN_BUCKET);
5998    }
5999    peer.m_addr_token_timestamp = current_time;
6000