What peer messages mean

5251        if (!filter.IsWithinSizeConstraints())
5252        {
5253            // There is no excuse for sending a too-large filter
5254            Misbehaving(peer, "too-large bloom filter");
5255        } else if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
5256            {
5257                LOCK(tx_relay->m_bloom_filter_mutex);
5258                tx_relay->m_bloom_filter.reset(new CBloomFilter(filter));
5259                tx_relay->m_relay_txs = true;
5260            }
5261            pfrom.m_bloom_filter_loaded = true;
5262            pfrom.m_relays_txs = true;
5263            MaybeDisconnectForTxRelayCapacity(pfrom, msg_type);
5264        }
5265        return;
5266    }
5267
5268    if (msg_type == NetMsgType::FILTERADD) {
5269        if (!(peer.m_our_services & NODE_BLOOM)) {
5270            LogDebug(BCLog::NET, "filteradd received despite not offering bloom services, %s", pfrom.DisconnectMsg());
5271            pfrom.fDisconnect = true;
5272            return;
5273        }
5274        std::vector<unsigned char> vData;
5275        vRecv >> vData;
5276
5277        // Nodes must NEVER send a data item > MAX_SCRIPT_ELEMENT_SIZE bytes (the max size for a script data object,
5278        // and thus, the maximum size any matched object can have) in a filteradd message
5279        bool bad = false;
5280        if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE) {
5281            bad = true;
5282        } else if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
5283            LOCK(tx_relay->m_bloom_filter_mutex);
5284            if (tx_relay->m_bloom_filter) {
5285                tx_relay->m_bloom_filter->insert(vData);
5286            } else {
5287                bad = true;
5288            }
5289        }
5290        if (bad) {
5291            Misbehaving(peer, "bad filteradd message");
5292        }
5293        return;
5294    }
5295
5296    if (msg_type == NetMsgType::FILTERCLEAR) {
5297        if (!(peer.m_our_services & NODE_BLOOM)) {
5298            LogDebug(BCLog::NET, "filterclear received despite not offering bloom services, %s", pfrom.DisconnectMsg());
5299            pfrom.fDisconnect = true;
5300            return;
5301        }
5302        auto tx_relay = peer.GetTxRelay();
5303        if (!tx_relay) return;
5304
5305        {
5306            LOCK(tx_relay->m_bloom_filter_mutex);
5307            tx_relay->m_bloom_filter = nullptr;
5308            tx_relay->m_relay_txs = true;
5309        }
5310        pfrom.m_bloom_filter_loaded = false;
5311        pfrom.m_relays_txs = true;
5312        MaybeDisconnectForTxRelayCapacity(pfrom, msg_type);
5313        return;
5314    }
5315
5316    if (msg_type == NetMsgType::FEEFILTER) {
5317        CAmount newFeeFilter = 0;
5318        vRecv >> newFeeFilter;
5319        if (MoneyRange(newFeeFilter)) {
5320            if (auto tx_relay = peer.GetTxRelay(); tx_relay != nullptr) {
5321                tx_relay->m_fee_filter_received = newFeeFilter;
5322            }
5323            LogDebug(BCLog::NET, "received: feefilter of %s from peer=%d\n", CFeeRate(newFeeFilter).ToString(), pfrom.GetId());
5324        }
5325        return;
5326    }
5327
5328    if (msg_type == NetMsgType::GETCFILTERS) {
5329        ProcessGetCFilters(pfrom, peer, vRecv);
5330        return;
5331    }
5332
5333    if (msg_type == NetMsgType::GETCFHEADERS) {
5334        ProcessGetCFHeaders(pfrom, peer, vRecv);
5335        return;
5336    }
5337
5338    if (msg_type == NetMsgType::GETCFCHECKPT) {
5339        ProcessGetCFCheckPt(pfrom, peer, vRecv);
5340        return;
5341    }
5342
5343    if (msg_type == NetMsgType::NOTFOUND) {
5344        std::vector<CInv> vInv;
5345        vRecv >> vInv;
5346        std::vector<GenTxid> tx_invs;
5347        if (vInv.size() <= node::MAX_PEER_TX_ANNOUNCEMENTS + MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
5348            for (CInv &inv : vInv) {
5349                if (inv.IsGenTxMsg()) {
5350                    tx_invs.emplace_back(ToGenTxid(inv));
5351                }
5352            }
5353        }
5354        LOCK(m_tx_download_mutex);
5355        m_txdownloadman.ReceivedNotFound(pfrom.GetId(), tx_invs);
5356        return;
5357    }
5358
5359    // Ignore unknown message types for extensibility
5360    LogDebug(BCLog::NET, "Unknown message type \"%s\" from peer=%d", SanitizeString(msg_type), pfrom.GetId());
5361    return;
5362}
5363
5364bool PeerManagerImpl::MaybeDiscourageAndDisconnect(CNode& pnode, Peer& peer)
5365{
5366    {
5367        LOCK(peer.m_misbehavior_mutex);
5368
5369        // There's nothing to do if the m_should_discourage flag isn't set
5370        if (!peer.m_should_discourage) return false;
5371
5372        peer.m_should_discourage = false;
5373    } // peer.m_misbehavior_mutex
5374
5375    if (pnode.HasPermission(NetPermissionFlags::NoBan)) {
5376        // We never disconnect or discourage peers for bad behavior if they have NetPermissionFlags::NoBan permission
5377        LogWarning("Not punishing noban peer %d!", peer.m_id);
5378        return false;
5379    }
5380
5381    if (pnode.IsManualConn()) {
5382        // We never disconnect or discourage manual peers for bad behavior
5383        LogWarning("Not punishing manually connected peer %d!", peer.m_id);
5384        return false;
5385    }
5386
5387    if (pnode.IsPrivateBroadcastConn()) {
5388        LogDebug(BCLog::PRIVBROADCAST, "Disconnecting misbehaving private broadcast peer=%d", peer.m_id);
5389        pnode.fDisconnect = true;
5390        return true;
5391    }
5392
5393    if (pnode.addr.IsLocal()) {
5394        // We disconnect local peers for bad behavior but don't discourage (since that would discourage
5395        // all peers on the same local address)
5396        LogDebug(BCLog::NET, "Warning: disconnecting but not discouraging %s peer %d!\n",
5397                 pnode.m_inbound_onion ? "inbound onion" : "local", peer.m_id);
5398        pnode.fDisconnect = true;
5399        return true;
5400    }
5401
5402    // Normal case: Disconnect the peer and discourage all nodes sharing the address
5403    LogDebug(BCLog::NET, "Disconnecting and discouraging peer %d!\n", peer.m_id);
5404    if (m_banman) m_banman->Discourage(pnode.addr);
5405    m_connman.DisconnectNode(CSubNet{pnode.addr}, /*disconnect_private_broadcast=*/false);
5406    return true;
5407}
5408
5409bool PeerManagerImpl::MaybeDisconnectForTxRelayCapacity(CNode& node, const std::string& msg_type, std::optional<NodeId> protect_peer)
5410{
5411    if (!node.IsInboundConn() || !node.m_relays_txs) return false;
5412    if (m_connman.EvictTxPeerIfFull(protect_peer)) return false;
5413
5414    LogDebug(BCLog::NET, "failed to find a tx-relaying eviction candidate - connection dropped after %s message, peer=%d\n", msg_type, node.GetId());
5415    node.fDisconnect = true;
5416    return true;
5417}
5418
5419bool PeerManagerImpl::ProcessMessages(CNode& node, std::atomic<bool>& interruptMsgProc)
5420{
5421    AssertLockNotHeld(m_tx_download_mutex);
5422    AssertLockHeld(g_msgproc_mutex);
5423
5424    PeerRef maybe_peer{GetPeerRef(node.GetId())};
5425    if (maybe_peer == nullptr) return false;
5426    Peer& peer{*maybe_peer};
5427
5428    // For outbound connections, ensure that the initial VERSION message
5429    // has been sent first before processing any incoming messages
5430    if (!node.IsInboundConn() && !peer.m_outbound_version_message_sent) return false;
5431
5432    {
5433        LOCK(peer.m_getdata_requests_mutex);
5434        if (!peer.m_getdata_requests.empty()) {
5435            ProcessGetData(node, peer, interruptMsgProc);
5436        }
5437    }
5438
5439    const bool processed_orphan = ProcessOrphanTx(peer);
5440
5441    if (node.fDisconnect)
5442        return false;
5443
5444    if (processed_orphan) return true;
5445
5446    // this maintains the order of responses
5447    // and prevents m_getdata_requests to grow unbounded
5448    {
5449        LOCK(peer.m_getdata_requests_mutex);
5450        if (!peer.m_getdata_requests.empty()) return true;
5451    }
5452
5453    // Don't bother if send buffer is too full to respond anyway
5454    if (node.fPauseSend) return false;
5455
5456    auto poll_result{node.PollMessage()};
5457    if (!poll_result) {
5458        // No message to process
5459        return false;
5460    }
5461
5462    CNetMessage& msg{poll_result->first};
5463    bool fMoreWork = poll_result->second;
5464
5465    TRACEPOINT(net, inbound_message,
5466        node.GetId(),
5467        node.m_addr_name.c_str(),
5468        node.ConnectionTypeAsString().c_str(),
5469        msg.m_type.c_str(),
5470        msg.m_recv.size(),
5471        msg.m_recv.data()
5472    );
5473
5474    if (m_opts.capture_messages) {
5475        CaptureMessage(node.addr, msg.m_type, MakeUCharSpan(msg.m_recv), /*is_incoming=*/true);
5476    }
5477
5478    try {
5479        ProcessMessage(peer, node, msg.m_type, msg.m_recv, msg.m_time, interruptMsgProc);
5480        if (interruptMsgProc) return false;
5481        {
5482            LOCK(peer.m_getdata_requests_mutex);
5483            if (!peer.m_getdata_requests.empty()) fMoreWork = true;
5484        }
5485        // Does this peer have an orphan ready to reconsider?
5486        // (Note: we may have provided a parent for an orphan provided
5487        //  by another peer that was already processed; in that case,
5488        //  the extra work may not be noticed, possibly resulting in an
5489        //  unnecessary 100ms delay)
5490        LOCK(m_tx_download_mutex);
5491        if (m_txdownloadman.HaveMoreWork(peer.m_id)) fMoreWork = true;
5492    } catch (const std::exception& e) {
5493        LogDebug(BCLog::NET, "%s(%s, %u bytes): Exception '%s' (%s) caught\n", __func__, SanitizeString(msg.m_type), msg.m_message_size, e.what(), typeid(e).name());
5494    } catch (...) {
5495        LogDebug(BCLog::NET, "%s(%s, %u bytes): Unknown exception caught\n", __func__, SanitizeString(msg.m_type), msg.m_message_size);
5496    }
5497
5498    return fMoreWork;
5499}
5500