What peer messages mean

4251            return;
4252        }
4253
4254        // if (feature_id == NetMsgFeature::FOO) {
4255        //     ...
4256        //     return;
4257        // }
4258
4259        // ignore unknown feature_id
4260        LogDebug(BCLog::NET, "unknown feature advertised: %s", SanitizeString(feature_id));
4261        return;
4262    }
4263
4264    // Received from a peer demonstrating readiness to announce transactions via reconciliations.
4265    // This feature negotiation must happen between VERSION and VERACK to avoid relay problems
4266    // from switching announcement protocols after the connection is up.
4267    if (msg_type == NetMsgType::SENDTXRCNCL) {
4268        if (!m_txreconciliation) {
4269            LogDebug(BCLog::NET, "sendtxrcncl from peer=%d ignored, as our node does not have txreconciliation enabled\n", pfrom.GetId());
4270            return;
4271        }
4272
4273        if (pfrom.fSuccessfullyConnected) {
4274            LogDebug(BCLog::NET, "sendtxrcncl received after verack, %s", pfrom.DisconnectMsg());
4275            pfrom.fDisconnect = true;
4276            return;
4277        }
4278
4279        // Peer must not offer us reconciliations if we specified no tx relay support in VERSION.
4280        if (RejectIncomingTxs(pfrom)) {
4281            LogDebug(BCLog::NET, "sendtxrcncl received to which we indicated no tx relay, %s", pfrom.DisconnectMsg());
4282            pfrom.fDisconnect = true;
4283            return;
4284        }
4285
4286        // Peer must not offer us reconciliations if they specified no tx relay support in VERSION.
4287        // This flag might also be false in other cases, but the RejectIncomingTxs check above
4288        // eliminates them, so that this flag fully represents what we are looking for.
4289        const auto* tx_relay = peer.GetTxRelay();
4290        if (!tx_relay || !WITH_LOCK(tx_relay->m_bloom_filter_mutex, return tx_relay->m_relay_txs)) {
4291            LogDebug(BCLog::NET, "sendtxrcncl received which indicated no tx relay to us, %s", pfrom.DisconnectMsg());
4292            pfrom.fDisconnect = true;
4293            return;
4294        }
4295
4296        uint32_t peer_txreconcl_version;
4297        uint64_t remote_salt;
4298        vRecv >> peer_txreconcl_version >> remote_salt;
4299
4300        const ReconciliationRegisterResult result = m_txreconciliation->RegisterPeer(pfrom.GetId(), pfrom.IsInboundConn(),
4301                                                                                     peer_txreconcl_version, remote_salt);
4302        switch (result) {
4303        case ReconciliationRegisterResult::NOT_FOUND:
4304            LogDebug(BCLog::NET, "Ignore unexpected txreconciliation signal from peer=%d\n", pfrom.GetId());
4305            break;
4306        case ReconciliationRegisterResult::SUCCESS:
4307            break;
4308        case ReconciliationRegisterResult::ALREADY_REGISTERED:
4309            LogDebug(BCLog::NET, "txreconciliation protocol violation (sendtxrcncl received from already registered peer), %s", pfrom.DisconnectMsg());
4310            pfrom.fDisconnect = true;
4311            return;
4312        case ReconciliationRegisterResult::PROTOCOL_VIOLATION:
4313            LogDebug(BCLog::NET, "txreconciliation protocol violation, %s", pfrom.DisconnectMsg());
4314            pfrom.fDisconnect = true;
4315            return;
4316        }
4317        return;
4318    }
4319
4320    if (!pfrom.fSuccessfullyConnected) {
4321        LogDebug(BCLog::NET, "Unsupported message \"%s\" prior to verack from peer=%d\n", SanitizeString(msg_type), pfrom.GetId());
4322        return;
4323    }
4324
4325    if (pfrom.IsPrivateBroadcastConn()) {
4326        if (msg_type != NetMsgType::PONG && msg_type != NetMsgType::GETDATA) {
4327            LogDebug(BCLog::PRIVBROADCAST, "Ignoring incoming message '%s', %s", msg_type, pfrom.LogPeer());
4328            return;
4329        }
4330    }
4331
4332    if (msg_type == NetMsgType::ADDR || msg_type == NetMsgType::ADDRV2) {
4333        const auto ser_params{
4334            msg_type == NetMsgType::ADDRV2 ?
4335            // Set V2 param so that the CNetAddr and CAddress
4336            // unserialize methods know that an address in v2 format is coming.
4337            CAddress::V2_NETWORK :
4338            CAddress::V1_NETWORK,
4339        };
4340
4341        std::vector<CAddress> vAddr;
4342        vRecv >> ser_params(vAddr);
4343        ProcessAddrs(msg_type, pfrom, peer, std::move(vAddr), interruptMsgProc);
4344        return;
4345    }
4346
4347    if (msg_type == NetMsgType::INV) {
4348        std::vector<CInv> vInv;
4349        vRecv >> vInv;
4350        if (vInv.size() > MAX_INV_SZ)
4351        {
4352            Misbehaving(peer, strprintf("inv message size = %u", vInv.size()));
4353            return;
4354        }
4355
4356        const bool reject_tx_invs{RejectIncomingTxs(pfrom)};
4357        std::unordered_set<uint256, SaltedUint256Hasher> seen_txids{0, m_txhash_hasher};
4358        std::unordered_set<uint256, SaltedUint256Hasher> seen_wtxids{0, m_txhash_hasher};
4359
4360        LOCK2(cs_main, m_tx_download_mutex);
4361
4362        const auto current_time{GetTime<std::chrono::microseconds>()};
4363        uint256* best_block{nullptr};
4364
4365        for (CInv& inv : vInv) {
4366            if (interruptMsgProc) return;
4367
4368            // Ignore INVs that don't match wtxidrelay setting.
4369            // Note that orphan parent fetching always uses MSG_TX GETDATAs regardless of the wtxidrelay setting.
4370            // This is fine as no INV messages are involved in that process.
4371            if (peer.m_wtxid_relay) {
4372                if (inv.IsMsgTx()) continue;
4373            } else {
4374                if (inv.IsMsgWtx()) continue;
4375            }
4376
4377            if (inv.IsMsgBlk()) {
4378                const bool fAlreadyHave = AlreadyHaveBlock(inv.hash);
4379                LogDebug(BCLog::NET, "got inv: %s %s peer=%d", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom.GetId());
4380
4381                UpdateBlockAvailability(pfrom.GetId(), inv.hash);
4382                if (!fAlreadyHave && !m_chainman.m_blockman.LoadingBlocks() && !IsBlockRequested(inv.hash)) {
4383                    // Headers-first is the primary method of announcement on
4384                    // the network. If a node fell back to sending blocks by
4385                    // inv, it may be for a re-org, or because we haven't
4386                    // completed initial headers sync. The final block hash
4387                    // provided should be the highest, so send a getheaders and
4388                    // then fetch the blocks we need to catch up.
4389                    best_block = &inv.hash;
4390                }
4391            } else if (inv.IsGenTxMsg()) {
4392                if (reject_tx_invs) {
4393                    LogDebug(BCLog::NET, "transaction (%s) inv sent in violation of protocol, %s", inv.hash.ToString(), pfrom.DisconnectMsg());
4394                    pfrom.fDisconnect = true;
4395                    return;
4396                }
4397                // MSG_WITNESS_TX is treated as a txid, despite only being specified for getdata.
4398                auto& seen_hashes{inv.IsMsgWtx() ? seen_wtxids : seen_txids};
4399                if (!seen_hashes.insert(inv.hash).second) continue;
4400                const GenTxid gtxid = ToGenTxid(inv);
4401                AddKnownTx(peer, inv.hash);
4402
4403                if (!m_chainman.IsInitialBlockDownload()) {
4404                    const bool fAlreadyHave{m_txdownloadman.AddTxAnnouncement(pfrom.GetId(), gtxid, current_time)};
4405                    LogDebug(BCLog::NET, "got inv: %s %s peer=%d", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom.GetId());
4406                }
4407            } else {
4408                LogDebug(BCLog::NET, "Unknown inv type \"%s\" received from peer=%d\n", inv.ToString(), pfrom.GetId());
4409            }
4410        }
4411
4412        if (best_block != nullptr) {
4413            // If we haven't started initial headers-sync with this peer, then
4414            // consider sending a getheaders now. On initial startup, there's a
4415            // reliability vs bandwidth tradeoff, where we are only trying to do
4416            // initial headers sync with one peer at a time, with a long
4417            // timeout (at which point, if the sync hasn't completed, we will
4418            // disconnect the peer and then choose another). In the meantime,
4419            // as new blocks are found, we are willing to add one new peer per
4420            // block to sync with as well, to sync quicker in the case where
4421            // our initial peer is unresponsive (but less bandwidth than we'd
4422            // use if we turned on sync with all peers).
4423            CNodeState& state{*Assert(State(pfrom.GetId()))};
4424            if (state.fSyncStarted || (!peer.m_inv_triggered_getheaders_before_sync && *best_block != m_last_block_inv_triggering_headers_sync)) {
4425                if (MaybeSendGetHeaders(pfrom, GetLocator(m_chainman.m_best_header), peer)) {
4426                    LogDebug(BCLog::NET, "getheaders (%d) %s to peer=%d\n",
4427                            m_chainman.m_best_header->nHeight, best_block->ToString(),
4428                            pfrom.GetId());
4429                }
4430                if (!state.fSyncStarted) {
4431                    peer.m_inv_triggered_getheaders_before_sync = true;
4432                    // Update the last block hash that triggered a new headers
4433                    // sync, so that we don't turn on headers sync with more
4434                    // than 1 new peer every new block.
4435                    m_last_block_inv_triggering_headers_sync = *best_block;
4436                }
4437            }
4438        }
4439
4440        return;
4441    }
4442
4443    if (msg_type == NetMsgType::GETDATA) {
4444        std::vector<CInv> vInv;
4445        vRecv >> vInv;
4446        if (vInv.size() > MAX_INV_SZ)
4447        {
4448            Misbehaving(peer, strprintf("getdata message size = %u", vInv.size()));
4449            return;
4450        }
4451
4452        LogDebug(BCLog::NET, "received getdata (%u invsz) peer=%d\n", vInv.size(), pfrom.GetId());
4453
4454        if (vInv.size() > 0) {
4455            LogDebug(BCLog::NET, "received getdata for: %s peer=%d\n", vInv[0].ToString(), pfrom.GetId());
4456        }
4457
4458        if (pfrom.IsPrivateBroadcastConn()) {
4459            const auto pushed_tx_opt{m_tx_for_private_broadcast.GetTxForNode(pfrom.GetId())};
4460            if (!pushed_tx_opt) {
4461                LogDebug(BCLog::PRIVBROADCAST, "Disconnecting: got GETDATA without sending an INV, %s",
4462                         pfrom.LogPeer());
4463                pfrom.fDisconnect = true;
4464                return;
4465            }
4466
4467            const CTransactionRef& pushed_tx{*pushed_tx_opt};
4468
4469            // The GETDATA request must contain exactly one inv and it must be for the transaction
4470            // that we INVed to the peer earlier.
4471            if (vInv.size() == 1 && vInv[0].IsMsgTx() && vInv[0].hash == pushed_tx->GetHash().ToUint256()) {
4472
4473                MakeAndPushMessage(pfrom, NetMsgType::TX, TX_WITH_WITNESS(*pushed_tx));
4474
4475                peer.m_ping_queued = true; // Ensure a ping will be sent: mimic a request via RPC.
4476                MaybeSendPing(pfrom, peer, NodeClock::now());
4477            } else {
4478                LogDebug(BCLog::PRIVBROADCAST, "Disconnecting: got an unexpected GETDATA message, %s",
4479                         pfrom.LogPeer());
4480                pfrom.fDisconnect = true;
4481            }
4482            return;
4483        }
4484
4485        {
4486            LOCK(peer.m_getdata_requests_mutex);
4487            peer.m_getdata_requests.insert(peer.m_getdata_requests.end(), vInv.begin(), vInv.end());
4488            ProcessGetData(pfrom, peer, interruptMsgProc);
4489        }
4490
4491        return;
4492    }
4493
4494    if (msg_type == NetMsgType::GETBLOCKS) {
4495        CBlockLocator locator;
4496        uint256 hashStop;
4497        vRecv >> locator >> hashStop;
4498
4499        if (locator.vHave.size() > MAX_LOCATOR_SZ) {
4500            LogDebug(BCLog::NET, "getblocks locator size %lld > %d, %s", locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.DisconnectMsg());