501                addrman.get().Attempt(target_addr, fCountFailure);
502            }
503        } else if (pszDest) {
504            if (const auto name_proxy = GetNameProxy()) {
505                std::string host;
506                uint16_t port{default_port};
507                SplitHostPort(pszDest, port, host);
508                bool proxyConnectionFailed;
509                sock = ConnectThroughProxy(*name_proxy, host, port, proxyConnectionFailed);
510            }
511        }
512        // Check any other resolved address (if any) if we fail to connect
513        if (!sock) {
514            continue;
515        }
516
517        NetPermissionFlags permission_flags = NetPermissionFlags::None;
518        std::vector<NetWhitelistPermissions> whitelist_permissions = conn_type == ConnectionType::MANUAL ? vWhitelistedRangeOutgoing : std::vector<NetWhitelistPermissions>{};
519        AddWhitelistPermissionFlags(permission_flags, target_addr, whitelist_permissions);
520
521        // Add node
522        NodeId id = GetNewNodeId();
523        uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
524        if (!addr_bind.IsValid()) {
525            addr_bind = GetBindAddress(*sock);
526        }
527        uint64_t network_id = GetDeterministicRandomizer(RANDOMIZER_ID_NETWORKKEY)
528                            .Write(target_addr.GetNetClass())
529                            .Write(addr_bind.GetAddrBytes())
530                            // For outbound connections, the port of the bound address is randomly
531                            // assigned by the OS and would therefore not be useful for seeding.
532                            .Write(0)
533                            .Finalize();
534        CNode* pnode = new CNode(id,
535                                std::move(sock),
536                                target_addr,
537                                CalculateKeyedNetGroup(target_addr),
538                                nonce,
539                                addr_bind,
540                                pszDest ? pszDest : "",
541                                conn_type,
542                                /*inbound_onion=*/false,
543                                network_id,
544                                CNodeOptions{
545                                    .permission_flags = permission_flags,
546                                    .proxy_override = proxy_override,
547                                    .i2p_sam_session = std::move(i2p_transient_session),
548                                    .recv_flood_size = nReceiveFloodSize,
549                                    .use_v2transport = use_v2transport,
550                                });
551        pnode->AddRef();
552
553        // We're making a new connection, harvest entropy from the time (and our peer count)
554        RandAddEvent((uint32_t)id);
555
556        return pnode;
557    }
558
559    return nullptr;
560}
561
562void CNode::CloseSocketDisconnect()
563{
564    fDisconnect = true;
565    LOCK(m_sock_mutex);
566    if (m_sock) {
567        LogDebug(BCLog::NET, "Resetting socket for %s", LogPeer());
568        m_sock.reset();
569
570        TRACEPOINT(net, closed_connection,
571            GetId(),
572            m_addr_name.c_str(),
573            ConnectionTypeAsString().c_str(),
574            ConnectedThroughNetwork(),
575            TicksSinceEpoch<std::chrono::seconds>(m_connected));
576    }
577    m_i2p_sam_session.reset();
578}
579
580void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, std::optional<CNetAddr> addr, const std::vector<NetWhitelistPermissions>& ranges) const {
581    for (const auto& subnet : ranges) {
582        if (addr.has_value() && subnet.m_subnet.Match(addr.value())) {
583            NetPermissions::AddFlag(flags, subnet.m_flags);
584        }
585    }
586    if (NetPermissions::HasFlag(flags, NetPermissionFlags::Implicit)) {
587        NetPermissions::ClearFlag(flags, NetPermissionFlags::Implicit);
588        if (whitelist_forcerelay) NetPermissions::AddFlag(flags, NetPermissionFlags::ForceRelay);
589        if (whitelist_relay) NetPermissions::AddFlag(flags, NetPermissionFlags::Relay);
590        NetPermissions::AddFlag(flags, NetPermissionFlags::Mempool);
591        NetPermissions::AddFlag(flags, NetPermissionFlags::NoBan);
592    }
593}
594
595CService CNode::GetAddrLocal() const
596{
597    AssertLockNotHeld(m_addr_local_mutex);
598    LOCK(m_addr_local_mutex);
599    return m_addr_local;
600}
601
602void CNode::SetAddrLocal(const CService& addrLocalIn) {
603    AssertLockNotHeld(m_addr_local_mutex);
604    LOCK(m_addr_local_mutex);
605    if (Assume(!m_addr_local.IsValid())) { // Addr local can only be set once during version msg processing
606        m_addr_local = addrLocalIn;
607    }
608}
609
610Network CNode::ConnectedThroughNetwork() const
611{
612    return m_inbound_onion ? NET_ONION : addr.GetNetClass();
613}
614
615bool CNode::IsConnectedThroughPrivacyNet() const
616{
617    return m_inbound_onion || addr.IsPrivacyNet();
618}
619
620#undef X
621#define X(name) stats.name = name
622void CNode::CopyStats(CNodeStats& stats)
623{
624    stats.nodeid = this->GetId();
625    X(addr);
626    X(addrBind);
627    stats.m_network = ConnectedThroughNetwork();
628    X(m_last_send);
629    X(m_last_recv);
630    X(m_last_tx_time);
631    X(m_last_block_time);
632    X(m_connected);
633    X(m_addr_name);
634    X(nVersion);
635    {
636        LOCK(m_subver_mutex);
637        X(cleanSubVer);
638    }
639    stats.fInbound = IsInboundConn();
640    X(m_bip152_highbandwidth_to);
641    X(m_bip152_highbandwidth_from);
642    {
643        LOCK(cs_vSend);
644        X(mapSendBytesPerMsgType);
645        X(nSendBytes);
646    }
647    {
648        LOCK(cs_vRecv);
649        X(mapRecvBytesPerMsgType);
650        X(nRecvBytes);
651        Transport::Info info = m_transport->GetInfo();
652        stats.m_transport_type = info.transport_type;
653        if (info.session_id) stats.m_session_id = HexStr(*info.session_id);
654    }
655    X(m_permission_flags);
656
657    X(m_last_ping_time);
658    X(m_min_ping_time);
659
660    // Leave string empty if addrLocal invalid (not filled in yet)
661    CService addrLocalUnlocked = GetAddrLocal();
662    stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToStringAddrPort() : "";
663
664    X(m_conn_type);
665}
666#undef X
667
668bool CNode::ReceiveMsgBytes(std::span<const uint8_t> msg_bytes, bool& complete)
669{
670    complete = false;
671    const auto time{NodeClock::now()};
672    LOCK(cs_vRecv);
673    m_last_recv = time;
674    nRecvBytes += msg_bytes.size();
675    while (msg_bytes.size() > 0) {
676        // absorb network data
677        if (!m_transport->ReceivedBytes(msg_bytes)) {
678            // Serious transport problem, disconnect from the peer.
679            return false;
680        }
681
682        if (m_transport->ReceivedMessageComplete()) {
683            // decompose a transport agnostic CNetMessage from the deserializer
684            bool reject_message{false};
685            CNetMessage msg = m_transport->GetReceivedMessage(time, reject_message);
686            if (reject_message) {
687                // Message deserialization failed. Drop the message but don't disconnect the peer.
688                // store the size of the corrupt message
689                mapRecvBytesPerMsgType.at(NET_MESSAGE_TYPE_OTHER) += msg.m_raw_message_size;
690                continue;
691            }
692
693            // Store received bytes per message type.
694            // To prevent a memory DOS, only allow known message types.
695            auto i = mapRecvBytesPerMsgType.find(msg.m_type);
696            if (i == mapRecvBytesPerMsgType.end()) {
697                i = mapRecvBytesPerMsgType.find(NET_MESSAGE_TYPE_OTHER);
698            }
699            assert(i != mapRecvBytesPerMsgType.end());
700            i->second += msg.m_raw_message_size;
701
702            // push the message to the process queue,
703            vRecvMsg.push_back(std::move(msg));
704
705            complete = true;
706        }
707    }
708
709    return true;
710}
711
712std::string CNode::LogPeer() const
713{
714    auto peer_info{strprintf("peer=%d", GetId())};
715    if (fLogIPs) {
716        return strprintf("%s, peeraddr=%s", peer_info, addr.ToStringAddrPort());
717    } else {
718        return peer_info;
719    }
720}
721
722std::string CNode::DisconnectMsg() const
723{
724    return strprintf("disconnecting %s", LogPeer());
725}
726
727V1Transport::V1Transport(const NodeId node_id) noexcept
728    : m_magic_bytes{Params().MessageStart()}, m_node_id{node_id}
729{
730    LOCK(m_recv_mutex);
731    Reset();
732}
733
734Transport::Info V1Transport::GetInfo() const noexcept
735{
736    return {.transport_type = TransportProtocolType::V1, .session_id = {}};
737}
738
739int V1Transport::readHeader(std::span<const uint8_t> msg_bytes)
740{
741    AssertLockHeld(m_recv_mutex);
742    // copy data to temporary parsing buffer
743    unsigned int nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos;
744    unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
745
746    memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy);
747    nHdrPos += nCopy;
748
749    // if header incomplete, exit
750    if (nHdrPos < CMessageHeader::HEADER_SIZE)