4001        // Only if this fails, disconnect this peer.
4002        if (MaybeDisconnectForTxRelayCapacity(pfrom, msg_type, /*protect_peer=*/pfrom.GetId())) return;
4003        MakeAndPushMessage(pfrom, NetMsgType::VERACK);
4004
4005        // Potentially mark this peer as a preferred download peer.
4006        {
4007            LOCK(cs_main);
4008            CNodeState* state = State(pfrom.GetId());
4009            state->fPreferredDownload = (!pfrom.IsInboundConn() || pfrom.HasPermission(NetPermissionFlags::NoBan)) && !pfrom.IsAddrFetchConn() && CanServeBlocks(peer);
4010            m_num_preferred_download_peers += state->fPreferredDownload;
4011        }
4012
4013        // Attempt to initialize address relay for outbound peers and use result
4014        // to decide whether to send GETADDR, so that we don't send it to
4015        // inbound, feelers, or outbound block-relay-only peers.
4016        bool send_getaddr{false};
4017        if (!pfrom.IsInboundConn()) {
4018            send_getaddr = SetupAddressRelay(pfrom, peer);
4019        }
4020        if (send_getaddr) {
4021            // Do a one-time address fetch to help populate/update our addrman.
4022            // If we're starting up for the first time, our addrman may be pretty
4023            // empty, so this mechanism is important to help us connect to the network.
4024            // We skip this for block-relay-only peers. We want to avoid
4025            // potentially leaking addr information and we do not want to
4026            // indicate to the peer that we will participate in addr relay.
4027            MakeAndPushMessage(pfrom, NetMsgType::GETADDR);
4028            peer.m_getaddr_sent = true;
4029            // When requesting a getaddr, accept an additional MAX_ADDR_TO_SEND addresses in response
4030            // (bypassing the MAX_ADDR_PROCESSING_TOKEN_BUCKET limit).
4031            peer.m_addr_token_bucket += MAX_ADDR_TO_SEND;
4032        }
4033
4034        if (!pfrom.IsInboundConn()) {
4035            // For non-inbound connections, we update the addrman to record
4036            // connection success so that addrman will have an up-to-date
4037            // notion of which peers are online and available.
4038            //
4039            // While we strive to not leak information about block-relay-only
4040            // connections via the addrman, not moving an address to the tried
4041            // table is also potentially detrimental because new-table entries
4042            // are subject to eviction in the event of addrman collisions.  We
4043            // mitigate the information-leak by never calling
4044            // AddrMan::Connected() on block-relay-only peers; see
4045            // FinalizeNode().
4046            //
4047            // This moves an address from New to Tried table in Addrman,
4048            // resolves tried-table collisions, etc.
4049            m_addrman.Good(pfrom.addr);
4050        }
4051
4052        peer.m_time_offset = NodeSeconds{std::chrono::seconds{nTime}} - Now<NodeSeconds>();
4053        if (!pfrom.IsInboundConn()) {
4054            // Don't use timedata samples from inbound peers to make it
4055            // harder for others to create false warnings about our clock being out of sync.
4056            m_outbound_time_offsets.Add(peer.m_time_offset);
4057            m_outbound_time_offsets.WarnIfOutOfSync();
4058        }
4059
4060        // If the peer is old enough to have the old alert system, send it the final alert.
4061        if (greatest_common_version <= 70012) {
4062            constexpr auto finalAlert{"60010000000000000000000000ffffff7f00000000ffffff7ffeffff7f01ffffff7f00000000ffffff7f00ffffff7f002f555247454e543a20416c657274206b657920636f6d70726f6d697365642c2075706772616465207265717569726564004630440220653febd6410f470f6bae11cad19c48413becb1ac2c17f908fd0fd53bdc3abd5202206d0e9c96fe88d4a0f01ed9dedae2b6f9e00da94cad0fecaae66ecf689bf71b50"_hex};
4063            MakeAndPushMessage(pfrom, "alert", finalAlert);
4064        }
4065
4066        // Feeler connections exist only to verify if address is online.
4067        if (pfrom.IsFeelerConn()) {
4068            LogDebug(BCLog::NET, "feeler connection completed, %s", pfrom.DisconnectMsg());
4069            pfrom.fDisconnect = true;
4070        }
4071        return;
4072    }
4073
4074    if (pfrom.nVersion == 0) {
4075        // Must have a version message before anything else
4076        LogDebug(BCLog::NET, "non-version message before version handshake. Message \"%s\" from peer=%d\n", SanitizeString(msg_type), pfrom.GetId());
4077        return;
4078    }
4079
4080    if (msg_type == NetMsgType::VERACK) {
4081        if (pfrom.fSuccessfullyConnected) {
4082            LogDebug(BCLog::NET, "ignoring redundant verack message from peer=%d\n", pfrom.GetId());
4083            return;
4084        }
4085
4086        auto new_peer_msg = [&]() {
4087            const auto mapped_as{m_connman.GetMappedAS(pfrom.addr)};
4088            return strprintf("New %s peer connected: transport: %s, version: %d, %s%s",
4089                pfrom.ConnectionTypeAsString(),
4090                TransportTypeAsString(pfrom.m_transport->GetInfo().transport_type),
4091                pfrom.nVersion.load(), pfrom.LogPeer(),
4092                (mapped_as ? strprintf(", mapped_as=%d", mapped_as) : ""));
4093        };
4094
4095        // Log successful connections unconditionally for outbound, but not for inbound as those
4096        // can be triggered by an attacker at high rate.
4097        if (pfrom.IsInboundConn()) {
4098            LogDebug(BCLog::NET, "%s", new_peer_msg());
4099        } else {
4100            LogInfo("%s", new_peer_msg());
4101        }
4102
4103        if (auto tx_relay = peer.GetTxRelay()) {
4104            // `TxRelay::m_tx_inventory_to_send` must be empty before the
4105            // version handshake is completed as
4106            // `TxRelay::m_next_inv_send_time` is first initialised in
4107            // `SendMessages` after the verack is received. Any transactions
4108            // received during the version handshake would otherwise
4109            // immediately be advertised without random delay, potentially
4110            // leaking the time of arrival to a spy.
4111            Assume(WITH_LOCK(
4112                tx_relay->m_tx_inventory_mutex,
4113                return tx_relay->m_tx_inventory_to_send.empty() &&
4114                       tx_relay->m_next_inv_send_time == 0s));
4115        }
4116
4117        if (pfrom.IsPrivateBroadcastConn()) {
4118            pfrom.fSuccessfullyConnected = true;
4119            // The peer may intend to later send us NetMsgType::FEEFILTER limiting
4120            // cheap transactions, but we don't wait for that and thus we may send
4121            // them a transaction below their threshold. This is ok because this
4122            // relay logic is designed to work even in cases when the peer drops
4123            // the transaction (due to it being too cheap, or for other reasons).
4124            PushPrivateBroadcastTx(pfrom);
4125            return;
4126        }
4127
4128        if (pfrom.GetCommonVersion() >= SHORT_IDS_BLOCKS_VERSION) {
4129            // Tell our peer we are willing to provide version 2 cmpctblocks.
4130            // However, we do not request new block announcements using
4131            // cmpctblock messages.
4132            // We send this to non-NODE NETWORK peers as well, because
4133            // they may wish to request compact blocks from us
4134            MakeAndPushMessage(pfrom, NetMsgType::SENDCMPCT, /*high_bandwidth=*/false, /*version=*/CMPCTBLOCKS_VERSION);
4135        }
4136
4137        if (m_txreconciliation) {
4138            if (!peer.m_wtxid_relay || !m_txreconciliation->IsPeerRegistered(pfrom.GetId())) {
4139                // We could have optimistically pre-registered/registered the peer. In that case,
4140                // we should forget about the reconciliation state here if this wasn't followed
4141                // by WTXIDRELAY (since WTXIDRELAY can't be announced later).
4142                m_txreconciliation->ForgetPeer(pfrom.GetId());
4143            }
4144        }
4145
4146        {
4147            LOCK2(::cs_main, m_tx_download_mutex);
4148            const CNodeState* state = State(pfrom.GetId());
4149            m_txdownloadman.ConnectedPeer(pfrom.GetId(), node::TxDownloadConnectionInfo {
4150                .m_preferred = state->fPreferredDownload,
4151                .m_relay_permissions = pfrom.HasPermission(NetPermissionFlags::Relay),
4152                .m_wtxid_relay = peer.m_wtxid_relay,
4153            });
4154        }
4155
4156        pfrom.fSuccessfullyConnected = true;
4157        return;
4158    }
4159
4160    if (msg_type == NetMsgType::SENDHEADERS) {
4161        peer.m_prefers_headers = true;
4162        return;
4163    }
4164
4165    if (msg_type == NetMsgType::SENDCMPCT) {
4166        uint8_t sendcmpct_hb{0};
4167        uint64_t sendcmpct_version{0};
4168        vRecv >> sendcmpct_hb >> sendcmpct_version;
4169
4170        // BIP152: the first integer is interpreted as a boolean and MUST have a
4171        // value of either 1 or 0.
4172        if (sendcmpct_hb > 1) {
4173            Misbehaving(peer, "invalid sendcmpct announce field");
4174            return;
4175        }
4176
4177        // Only support compact block relay with witnesses
4178        if (sendcmpct_version != CMPCTBLOCKS_VERSION) return;
4179
4180        LOCK(cs_main);
4181        CNodeState* nodestate = State(pfrom.GetId());
4182        nodestate->m_provides_cmpctblocks = true;
4183        nodestate->m_requested_hb_cmpctblocks = sendcmpct_hb;
4184        // save whether peer selects us as BIP152 high-bandwidth peer
4185        // (receiving sendcmpct(1) signals high-bandwidth, sendcmpct(0) low-bandwidth)
4186        pfrom.m_bip152_highbandwidth_from = sendcmpct_hb;
4187        return;
4188    }
4189
4190    // BIP339 defines feature negotiation of wtxidrelay, which must happen between
4191    // VERSION and VERACK to avoid relay problems from switching after a connection is up.
4192    if (msg_type == NetMsgType::WTXIDRELAY) {
4193        if (pfrom.fSuccessfullyConnected) {
4194            // Disconnect peers that send a wtxidrelay message after VERACK.
4195            LogDebug(BCLog::NET, "wtxidrelay received after verack, %s", pfrom.DisconnectMsg());
4196            pfrom.fDisconnect = true;
4197            return;
4198        }
4199        if (pfrom.GetCommonVersion() >= WTXID_RELAY_VERSION) {
4200            if (!peer.m_wtxid_relay) {
4201                peer.m_wtxid_relay = true;
4202                m_wtxid_relay_peers++;
4203            } else {
4204                LogDebug(BCLog::NET, "ignoring duplicate wtxidrelay from peer=%d\n", pfrom.GetId());
4205            }
4206        } else {
4207            LogDebug(BCLog::NET, "ignoring wtxidrelay due to old common version=%d from peer=%d\n", pfrom.GetCommonVersion(), pfrom.GetId());
4208        }
4209        return;
4210    }
4211
4212    // BIP155 defines feature negotiation of addrv2 and sendaddrv2, which must happen
4213    // between VERSION and VERACK.
4214    if (msg_type == NetMsgType::SENDADDRV2) {
4215        if (pfrom.fSuccessfullyConnected) {
4216            // Disconnect peers that send a SENDADDRV2 message after VERACK.
4217            LogDebug(BCLog::NET, "sendaddrv2 received after verack, %s", pfrom.DisconnectMsg());
4218            pfrom.fDisconnect = true;
4219            return;
4220        }
4221        peer.m_wants_addrv2 = true;
4222        return;
4223    }
4224
4225    if (msg_type == NetMsgType::FEATURE) {
4226        if (pfrom.fSuccessfullyConnected) {
4227            // Disconnect peers that send a FEATURE message after VERACK.
4228            LogDebug(BCLog::NET, "feature received after verack, %s", pfrom.DisconnectMsg());
4229            pfrom.fDisconnect = true;
4230            return;
4231        } else if (pfrom.GetCommonVersion() < FEATURE_VERSION) {
4232            // Disconnect peers that send a FEATURE message without valid version negotiation.
4233            LogDebug(BCLog::NET, "feature received with incompatible version %d, %s", pfrom.GetCommonVersion(), pfrom.DisconnectMsg());
4234            pfrom.fDisconnect = true;
4235            return;
4236        }
4237
4238        std::string feature_id;
4239        DataStream feature_data;
4240        try {
4241            vRecv >> LIMITED_STRING(feature_id, MAX_FEATUREID_LENGTH);
4242            std::vector<unsigned char> feature_data_vec;
4243            vRecv >> LIMITED_VECTOR(feature_data_vec, MAX_FEATUREDATA_LENGTH);
4244            feature_data = DataStream(feature_data_vec);
4245        } catch (const std::exception&) {
4246            feature_id.clear(); // use empty feature_id as error indicator
4247        }
4248        if (feature_id.size() < 4 || !vRecv.empty()) {
4249            LogDebug(BCLog::NET, "invalid feature payload, %s", pfrom.DisconnectMsg());
4250            pfrom.fDisconnect = true;