net.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_NET_H
#define BITCOIN_NET_H
 
#include <bip324.h>
#include <chainparams.h>
#include <common/bloom.h>
#include <compat/compat.h>
#include <consensus/amount.h>
#include <crypto/siphash.h>
#include <hash.h>
#include <i2p.h>
#include <kernel/messagestartchars.h>
#include <net_permissions.h>
#include <netaddress.h>
#include <netbase.h>
#include <netgroup.h>
#include <node/connection_types.h>
#include <node/protocol_version.h>
#include <policy/feerate.h>
#include <protocol.h>
#include <random.h>
#include <semaphore_grant.h>
#include <span.h>
#include <streams.h>
#include <sync.h>
#include <uint256.h>
#include <util/check.h>
#include <util/sock.h>
#include <util/threadinterrupt.h>
 
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <deque>
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <optional>
#include <queue>
#include <string_view>
#include <thread>
#include <unordered_set>
#include <vector>
 
class AddrMan;
class BanMan;
class CChainParams;
class CNode;
class CScheduler;
struct bilingual_str;
 
inline constexpr std::chrono::minutes TIMEOUT_INTERVAL{20};
inline constexpr auto FEELER_INTERVAL = 2min;
inline constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min;
inline constexpr unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1000 * 1000;
inline constexpr unsigned int MAX_SUBVERSION_LENGTH = 256;
inline constexpr int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS = 8;
inline constexpr int MAX_ADDNODE_CONNECTIONS = 8;
inline constexpr int MAX_BLOCK_RELAY_ONLY_CONNECTIONS = 2;
inline constexpr int MAX_FEELER_CONNECTIONS = 1;
inline constexpr size_t MAX_PRIVATE_BROADCAST_CONNECTIONS{64};
inline constexpr bool DEFAULT_LISTEN = true;
inline constexpr unsigned int DEFAULT_MAX_PEER_CONNECTIONS{200};
inline constexpr int DEFAULT_FULL_RELAY_INBOUND_PCT{50};
inline const std::string DEFAULT_MAX_UPLOAD_TARGET{"0M"};
inline constexpr bool DEFAULT_BLOCKSONLY = false;
inline constexpr int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60;
inline constexpr bool DEFAULT_PRIVATE_BROADCAST{false};
inline constexpr int NUM_FDS_MESSAGE_CAPTURE = 1;
inline constexpr std::chrono::hours ASMAP_HEALTH_CHECK_INTERVAL{24};
 
inline constexpr bool DEFAULT_FORCEDNSSEED{false};
inline constexpr bool DEFAULT_DNSSEED{true};
inline constexpr bool DEFAULT_FIXEDSEEDS{true};
inline constexpr size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
inline constexpr size_t DEFAULT_MAXSENDBUFFER    = 1 * 1000;
 
inline constexpr bool DEFAULT_V2_TRANSPORT{true};
 
typedef int64_t NodeId;
 
struct AddedNodeParams {
    std::string m_added_node;
    bool m_use_v2transport;
};
 
struct AddedNodeInfo {
    AddedNodeParams m_params;
    CService resolvedAddress;
    bool fConnected;
    bool fInbound;
};
 
class CNodeStats;
class CClientUIInterface;
 
struct CSerializedNetMsg {
    CSerializedNetMsg() = default;
    CSerializedNetMsg(CSerializedNetMsg&&) = default;
    CSerializedNetMsg& operator=(CSerializedNetMsg&&) = default;
    // No implicit copying, only moves.
    CSerializedNetMsg(const CSerializedNetMsg& msg) = delete;
    CSerializedNetMsg& operator=(const CSerializedNetMsg&) = delete;
 
    CSerializedNetMsg Copy() const
    {
        CSerializedNetMsg copy;
        copy.data = data;
        copy.m_type = m_type;
        return copy;
    }
 
    std::vector<unsigned char> data;
    std::string m_type;
 
    size_t GetMemoryUsage() const noexcept;
};
 
void Discover();
 
uint16_t GetListenPort();
 
enum
{
    LOCAL_NONE,   // unknown
    LOCAL_IF,     // address a local interface listens on
    LOCAL_BIND,   // address explicit bound to
    LOCAL_MAPPED, // address reported by PCP
    LOCAL_MANUAL, // address explicitly specified (-externalip=)
 
    LOCAL_MAX
};
 
std::optional<CService> GetLocalAddrForPeer(CNode& node);
 
void ClearLocal();
bool AddLocal(const CService& addr, int nScore = LOCAL_NONE, bool add_even_if_unreachable = false);
bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE, bool add_even_if_unreachable = false);
void RemoveLocal(const CService& addr);
bool SeenLocal(const CService& addr);
bool IsLocal(const CService& addr);
CService GetLocalAddress(const CNode& peer);
 
extern bool fDiscover;
extern bool fListen;
 
extern std::string strSubVersion;
 
struct LocalServiceInfo {
    int nScore;
    uint16_t nPort;
};
 
extern GlobalMutex g_maplocalhost_mutex;
extern std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(g_maplocalhost_mutex);
 
extern const std::string NET_MESSAGE_TYPE_OTHER;
using mapMsgTypeSize = std::map</* message type */ std::string, /* total bytes */ uint64_t>;
 
class CNodeStats
{
public:
    NodeId nodeid;
    NodeClock::time_point m_last_send;
    NodeClock::time_point m_last_recv;
    std::chrono::seconds m_last_tx_time;
    std::chrono::seconds m_last_block_time;
    NodeClock::time_point m_connected;
    std::string m_addr_name;
    int nVersion;
    std::string cleanSubVer;
    bool fInbound;
    // We requested high bandwidth connection to peer
    bool m_bip152_highbandwidth_to;
    // Peer requested high bandwidth connection
    bool m_bip152_highbandwidth_from;
    uint64_t nSendBytes;
    mapMsgTypeSize mapSendBytesPerMsgType;
    uint64_t nRecvBytes;
    mapMsgTypeSize mapRecvBytesPerMsgType;
    NetPermissionFlags m_permission_flags;
    NodeClock::duration m_last_ping_time;
    NodeClock::duration m_min_ping_time;
    // Our address, as reported by the peer
    std::string addrLocal;
    // Address of this peer
    CAddress addr;
    // Bind address of our side of the connection
    CService addrBind;
    // Network the peer connected through
    Network m_network;
    uint32_t m_mapped_as;
    ConnectionType m_conn_type;
    TransportProtocolType m_transport_type;
    std::string m_session_id;
};
 
 
class CNetMessage
{
public:
    DataStream m_recv;                   
    NodeClock::time_point m_time{NodeClock::epoch};
    uint32_t m_message_size{0};          
    uint32_t m_raw_message_size{0};      
    std::string m_type;
 
    explicit CNetMessage(DataStream&& recv_in) : m_recv(std::move(recv_in)) {}
    // Only one CNetMessage object will exist for the same message on either
    // the receive or processing queue. For performance reasons we therefore
    // delete the copy constructor and assignment operator to avoid the
    // possibility of copying CNetMessage objects.
    CNetMessage(CNetMessage&&) = default;
    CNetMessage(const CNetMessage&) = delete;
    CNetMessage& operator=(CNetMessage&&) = default;
    CNetMessage& operator=(const CNetMessage&) = delete;
 
    size_t GetMemoryUsage() const noexcept;
};
 
class Transport {
public:
    virtual ~Transport() = default;
 
    struct Info
    {
        TransportProtocolType transport_type;
        std::optional<uint256> session_id;
    };
 
    virtual Info GetInfo() const noexcept = 0;
 
    // 1. Receiver side functions, for decoding bytes received on the wire into transport protocol
    // agnostic CNetMessage (message type & payload) objects.
 
    virtual bool ReceivedMessageComplete() const = 0;
 
    virtual bool ReceivedBytes(std::span<const uint8_t>& msg_bytes) = 0;
 
    virtual CNetMessage GetReceivedMessage(NodeClock::time_point time, bool& reject_message) = 0;
 
    // 2. Sending side functions, for converting messages into bytes to be sent over the wire.
 
    virtual bool SetMessageToSend(CSerializedNetMsg& msg) noexcept = 0;
 
    using BytesToSend = std::tuple<
        std::span<const uint8_t> /*to_send*/,
        bool /*more*/,
        const std::string& /*m_type*/
    >;
 
    virtual BytesToSend GetBytesToSend(bool have_next_message) const noexcept = 0;
 
    virtual void MarkBytesSent(size_t bytes_sent) noexcept = 0;
 
    virtual size_t GetSendMemoryUsage() const noexcept = 0;
 
    // 3. Miscellaneous functions.
 
    virtual bool ShouldReconnectV1() const noexcept = 0;
};
 
class V1Transport final : public Transport
{
private:
    const MessageStartChars m_magic_bytes;
    const NodeId m_node_id; // Only for logging
    mutable Mutex m_recv_mutex; 
    mutable CHash256 hasher GUARDED_BY(m_recv_mutex);
    mutable uint256 data_hash GUARDED_BY(m_recv_mutex);
    bool in_data GUARDED_BY(m_recv_mutex); // parsing header (false) or data (true)
    DataStream hdrbuf GUARDED_BY(m_recv_mutex){}; // partially received header
    CMessageHeader hdr GUARDED_BY(m_recv_mutex); // complete header
    DataStream vRecv GUARDED_BY(m_recv_mutex){}; // received message data
    unsigned int nHdrPos GUARDED_BY(m_recv_mutex);
    unsigned int nDataPos GUARDED_BY(m_recv_mutex);
 
    const uint256& GetMessageHash() const EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
    int readHeader(std::span<const uint8_t> msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
    int readData(std::span<const uint8_t> msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
 
    void Reset() EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex) {
        AssertLockHeld(m_recv_mutex);
        vRecv.clear();
        hdrbuf.clear();
        hdrbuf.resize(24);
        in_data = false;
        nHdrPos = 0;
        nDataPos = 0;
        data_hash.SetNull();
        hasher.Reset();
    }
 
    bool CompleteInternal() const noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
    {
        AssertLockHeld(m_recv_mutex);
        if (!in_data) return false;
        return hdr.nMessageSize == nDataPos;
    }
 
    mutable Mutex m_send_mutex;
    std::vector<uint8_t> m_header_to_send GUARDED_BY(m_send_mutex);
    CSerializedNetMsg m_message_to_send GUARDED_BY(m_send_mutex);
    bool m_sending_header GUARDED_BY(m_send_mutex) {false};
    size_t m_bytes_sent GUARDED_BY(m_send_mutex) {0};
 
public:
    explicit V1Transport(NodeId node_id) noexcept;
 
    bool ReceivedMessageComplete() const override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
    {
        AssertLockNotHeld(m_recv_mutex);
        return WITH_LOCK(m_recv_mutex, return CompleteInternal());
    }
 
    Info GetInfo() const noexcept override;
 
    bool ReceivedBytes(std::span<const uint8_t>& msg_bytes) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
    {
        AssertLockNotHeld(m_recv_mutex);
        LOCK(m_recv_mutex);
        int ret = in_data ? readData(msg_bytes) : readHeader(msg_bytes);
        if (ret < 0) {
            Reset();
        } else {
            msg_bytes = msg_bytes.subspan(ret);
        }
        return ret >= 0;
    }
 
    CNetMessage GetReceivedMessage(NodeClock::time_point time, bool& reject_message) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);
 
    bool SetMessageToSend(CSerializedNetMsg& msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
    BytesToSend GetBytesToSend(bool have_next_message) const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
    void MarkBytesSent(size_t bytes_sent) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
    size_t GetSendMemoryUsage() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
    bool ShouldReconnectV1() const noexcept override { return false; }
};
 
class V2Transport final : public Transport
{
private:
    static constexpr std::array<std::byte, 0> VERSION_CONTENTS = {};
 
    static constexpr size_t V1_PREFIX_LEN = 16;
 
    // The sender side and receiver side of V2Transport are state machines that are transitioned
    // through, based on what has been received. The receive state corresponds to the contents of,
    // and bytes received to, the receive buffer. The send state controls what can be appended to
    // the send buffer and what can be sent from it.
 
    enum class RecvState : uint8_t {
        KEY_MAYBE_V1,
 
        KEY,
 
        GARB_GARBTERM,
 
        VERSION,
 
        APP,
 
        APP_READY,
 
        V1,
    };
 
    enum class SendState : uint8_t {
        MAYBE_V1,
 
        AWAITING_KEY,
 
        READY,
 
        V1,
    };
 
    BIP324Cipher m_cipher;
    const bool m_initiating;
    const NodeId m_nodeid;
    V1Transport m_v1_fallback;
 
    mutable Mutex m_recv_mutex ACQUIRED_BEFORE(m_send_mutex);
    uint32_t m_recv_len GUARDED_BY(m_recv_mutex) {0};
    std::vector<uint8_t> m_recv_buffer GUARDED_BY(m_recv_mutex);
    std::vector<uint8_t> m_recv_aad GUARDED_BY(m_recv_mutex);
    std::vector<uint8_t> m_recv_decode_buffer GUARDED_BY(m_recv_mutex);
    RecvState m_recv_state GUARDED_BY(m_recv_mutex);
 
    mutable Mutex m_send_mutex ACQUIRED_AFTER(m_recv_mutex);
    std::vector<uint8_t> m_send_buffer GUARDED_BY(m_send_mutex);
    uint32_t m_send_pos GUARDED_BY(m_send_mutex) {0};
    std::vector<uint8_t> m_send_garbage GUARDED_BY(m_send_mutex);
    std::string m_send_type GUARDED_BY(m_send_mutex);
    SendState m_send_state GUARDED_BY(m_send_mutex);
    bool m_sent_v1_header_worth GUARDED_BY(m_send_mutex) {false};
 
    void SetReceiveState(RecvState recv_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
    void SetSendState(SendState send_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex);
    static std::optional<std::string> GetMessageType(std::span<const uint8_t>& contents) noexcept;
    size_t GetMaxBytesToProcess() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
    void StartSendingHandshake() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex);
    void ProcessReceivedMaybeV1Bytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex);
    bool ProcessReceivedKeyBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex);
    bool ProcessReceivedGarbageBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
    bool ProcessReceivedPacketBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
 
public:
    static constexpr uint32_t MAX_GARBAGE_LEN = 4095;
 
    V2Transport(NodeId nodeid, bool initiating) noexcept;
 
    V2Transport(NodeId nodeid, bool initiating, const CKey& key, std::span<const std::byte> ent32, std::vector<uint8_t> garbage) noexcept;
 
    // Receive side functions.
    bool ReceivedMessageComplete() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);
    bool ReceivedBytes(std::span<const uint8_t>& msg_bytes) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex, !m_send_mutex);
    CNetMessage GetReceivedMessage(NodeClock::time_point time, bool& reject_message) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);
 
    // Send side functions.
    bool SetMessageToSend(CSerializedNetMsg& msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
    BytesToSend GetBytesToSend(bool have_next_message) const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
    void MarkBytesSent(size_t bytes_sent) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
    size_t GetSendMemoryUsage() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);
 
    // Miscellaneous functions.
    bool ShouldReconnectV1() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex, !m_send_mutex);
    Info GetInfo() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);
};
 
struct CNodeOptions
{
    NetPermissionFlags permission_flags = NetPermissionFlags::None;
    std::optional<Proxy> proxy_override = {};
    std::unique_ptr<i2p::sam::Session> i2p_sam_session = nullptr;
    bool prefer_evict = false;
    size_t recv_flood_size{DEFAULT_MAXRECEIVEBUFFER * 1000};
    bool use_v2transport = false;
};
 
class CNode
{
public:
    const std::unique_ptr<Transport> m_transport;
 
    const NetPermissionFlags m_permission_flags;
 
    std::shared_ptr<Sock> m_sock GUARDED_BY(m_sock_mutex);
 
    size_t m_send_memusage GUARDED_BY(cs_vSend){0};
    uint64_t nSendBytes GUARDED_BY(cs_vSend){0};
    std::deque<CSerializedNetMsg> vSendMsg GUARDED_BY(cs_vSend);
    Mutex cs_vSend;
    Mutex m_sock_mutex;
    Mutex cs_vRecv;
 
    uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0};
 
    std::atomic<NodeClock::time_point> m_last_send{NodeClock::epoch};
    std::atomic<NodeClock::time_point> m_last_recv{NodeClock::epoch};
    const NodeClock::time_point m_connected;
 
    const std::optional<Proxy> m_proxy_override;
 
    // Address of this peer
    const CAddress addr;
    // Bind address of our side of the connection
    const CService addrBind;
    const std::string m_addr_name;
    const std::string m_dest;
    const bool m_inbound_onion;
    std::atomic<int> nVersion{0};
    Mutex m_subver_mutex;
    std::string cleanSubVer GUARDED_BY(m_subver_mutex){};
    const bool m_prefer_evict{false}; // This peer is preferred for eviction.
    bool HasPermission(NetPermissionFlags permission) const {
        return NetPermissions::HasFlag(m_permission_flags, permission);
    }
    std::atomic_bool fSuccessfullyConnected{false};
    // Setting fDisconnect to true will cause the node to be disconnected the
    // next time DisconnectNodes() runs
    std::atomic_bool fDisconnect{false};
    CountingSemaphoreGrant<> grantOutbound;
    std::atomic<int> nRefCount{0};
 
    const uint64_t nKeyedNetGroup;
    std::atomic_bool fPauseRecv{false};
    std::atomic_bool fPauseSend{false};
 
    const uint64_t m_network_key;
 
    const ConnectionType m_conn_type;
 
    void MarkReceivedMsgsForProcessing()
        EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex);
 
    std::optional<std::pair<CNetMessage, bool>> PollMessage()
        EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex);
 
    void AccountForSentBytes(const std::string& msg_type, size_t sent_bytes)
        EXCLUSIVE_LOCKS_REQUIRED(cs_vSend)
    {
        mapSendBytesPerMsgType[msg_type] += sent_bytes;
    }
 
    bool IsOutboundOrBlockRelayConn() const {
        switch (m_conn_type) {
            case ConnectionType::OUTBOUND_FULL_RELAY:
            case ConnectionType::BLOCK_RELAY:
                return true;
            case ConnectionType::INBOUND:
            case ConnectionType::MANUAL:
            case ConnectionType::ADDR_FETCH:
            case ConnectionType::FEELER:
            case ConnectionType::PRIVATE_BROADCAST:
                return false;
        } // no default case, so the compiler can warn about missing cases
 
        assert(false);
    }
 
    bool IsFullOutboundConn() const {
        return m_conn_type == ConnectionType::OUTBOUND_FULL_RELAY;
    }
 
    bool IsManualConn() const {
        return m_conn_type == ConnectionType::MANUAL;
    }
 
    bool IsManualOrFullOutboundConn() const
    {
        switch (m_conn_type) {
        case ConnectionType::INBOUND:
        case ConnectionType::FEELER:
        case ConnectionType::BLOCK_RELAY:
        case ConnectionType::ADDR_FETCH:
        case ConnectionType::PRIVATE_BROADCAST:
                return false;
        case ConnectionType::OUTBOUND_FULL_RELAY:
        case ConnectionType::MANUAL:
                return true;
        } // no default case, so the compiler can warn about missing cases
 
        assert(false);
    }
 
    bool IsBlockOnlyConn() const {
        return m_conn_type == ConnectionType::BLOCK_RELAY;
    }
 
    bool IsFeelerConn() const {
        return m_conn_type == ConnectionType::FEELER;
    }
 
    bool IsAddrFetchConn() const {
        return m_conn_type == ConnectionType::ADDR_FETCH;
    }
 
    bool IsPrivateBroadcastConn() const
    {
        return m_conn_type == ConnectionType::PRIVATE_BROADCAST;
    }
 
    int AdvertisedVersion() const
    {
        return IsPrivateBroadcastConn() ? WTXID_RELAY_VERSION : PROTOCOL_VERSION;
    }
 
    bool IsInboundConn() const {
        return m_conn_type == ConnectionType::INBOUND;
    }
 
    bool ExpectServicesFromConn() const {
        switch (m_conn_type) {
            case ConnectionType::INBOUND:
            case ConnectionType::MANUAL:
            case ConnectionType::FEELER:
                return false;
            case ConnectionType::OUTBOUND_FULL_RELAY:
            case ConnectionType::BLOCK_RELAY:
            case ConnectionType::ADDR_FETCH:
            case ConnectionType::PRIVATE_BROADCAST:
                return true;
        } // no default case, so the compiler can warn about missing cases
 
        assert(false);
    }
 
    Network ConnectedThroughNetwork() const;
 
    [[nodiscard]] bool IsConnectedThroughPrivacyNet() const;
 
    // We selected peer as (compact blocks) high-bandwidth peer (BIP152)
    std::atomic<bool> m_bip152_highbandwidth_to{false};
    // Peer selected us as (compact blocks) high-bandwidth peer (BIP152)
    std::atomic<bool> m_bip152_highbandwidth_from{false};
 
    std::atomic_bool m_has_all_wanted_services{false};
 
    std::atomic_bool m_relays_txs{false};
 
    std::atomic_bool m_bloom_filter_loaded{false};
 
    std::atomic<std::chrono::seconds> m_last_block_time{0s};
 
    std::atomic<std::chrono::seconds> m_last_tx_time{0s};
 
    std::atomic<NodeClock::duration> m_last_ping_time{0us};
 
    std::atomic<NodeClock::duration> m_min_ping_time{NodeClock::duration::max()};
 
    CNode(NodeId id,
          std::shared_ptr<Sock> sock,
          const CAddress& addrIn,
          uint64_t nKeyedNetGroupIn,
          uint64_t nLocalHostNonceIn,
          const CService& addrBindIn,
          const std::string& addrNameIn,
          ConnectionType conn_type_in,
          bool inbound_onion,
          uint64_t network_key,
          CNodeOptions&& node_opts = {});
    CNode(const CNode&) = delete;
    CNode& operator=(const CNode&) = delete;
 
    NodeId GetId() const {
        return id;
    }
 
    uint64_t GetLocalNonce() const {
        return nLocalHostNonce;
    }
 
    int GetRefCount() const
    {
        assert(nRefCount >= 0);
        return nRefCount;
    }
 
    bool ReceiveMsgBytes(std::span<const uint8_t> msg_bytes, bool& complete) EXCLUSIVE_LOCKS_REQUIRED(!cs_vRecv);
 
    void SetCommonVersion(int greatest_common_version)
    {
        Assume(m_greatest_common_version == INIT_PROTO_VERSION);
        m_greatest_common_version = greatest_common_version;
    }
    int GetCommonVersion() const
    {
        return m_greatest_common_version;
    }
 
    CService GetAddrLocal() const EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex);
    void SetAddrLocal(const CService& addrLocalIn) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex);
 
    CNode* AddRef()
    {
        nRefCount++;
        return this;
    }
 
    void Release()
    {
        nRefCount--;
    }
 
    void CloseSocketDisconnect() EXCLUSIVE_LOCKS_REQUIRED(!m_sock_mutex);
 
    void CopyStats(CNodeStats& stats) EXCLUSIVE_LOCKS_REQUIRED(!m_subver_mutex, !m_addr_local_mutex, !cs_vSend, !cs_vRecv);
 
    std::string ConnectionTypeAsString() const { return ::ConnectionTypeAsString(m_conn_type); }
 
    std::string LogPeer() const;
 
    std::string DisconnectMsg() const;
 
    void PongReceived(NodeClock::duration ping_time)
    {
        m_last_ping_time = ping_time;
        m_min_ping_time = std::min(m_min_ping_time.load(), ping_time);
    }
 
private:
    const NodeId id;
    const uint64_t nLocalHostNonce;
    std::atomic<int> m_greatest_common_version{INIT_PROTO_VERSION};
 
    const size_t m_recv_flood_size;
    std::list<CNetMessage> vRecvMsg; // Used only by SocketHandler thread
 
    Mutex m_msg_process_queue_mutex;
    std::list<CNetMessage> m_msg_process_queue GUARDED_BY(m_msg_process_queue_mutex);
    size_t m_msg_process_queue_size GUARDED_BY(m_msg_process_queue_mutex){0};
 
    // Our address, as reported by the peer
    CService m_addr_local GUARDED_BY(m_addr_local_mutex);
    mutable Mutex m_addr_local_mutex;
 
    mapMsgTypeSize mapSendBytesPerMsgType GUARDED_BY(cs_vSend);
    mapMsgTypeSize mapRecvBytesPerMsgType GUARDED_BY(cs_vRecv);
 
    std::unique_ptr<i2p::sam::Session> m_i2p_sam_session GUARDED_BY(m_sock_mutex);
};
 
class NetEventsInterface
{
public:
    static Mutex g_msgproc_mutex;
 
    virtual void InitializeNode(const CNode& node, ServiceFlags our_services) = 0;
 
    virtual void FinalizeNode(const CNode& node) = 0;
 
    virtual bool HasAllDesirableServiceFlags(ServiceFlags services) const = 0;
 
    virtual bool ProcessMessages(CNode& node, std::atomic<bool>& interrupt) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0;
 
    virtual bool SendMessages(CNode& node) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0;
 
 
protected:
    ~NetEventsInterface() = default;
};
 
class CConnman
{
public:
 
    struct Options
    {
        ServiceFlags m_local_services = NODE_NONE;
        int m_max_automatic_connections = DEFAULT_MAX_PEER_CONNECTIONS;
        int m_full_relay_inbound_percent = DEFAULT_FULL_RELAY_INBOUND_PCT;
        CClientUIInterface* uiInterface = nullptr;
        NetEventsInterface* m_msgproc = nullptr;
        BanMan* m_banman = nullptr;
        unsigned int nSendBufferMaxSize = 0;
        unsigned int nReceiveFloodSize = 0;
        uint64_t nMaxOutboundLimit = 0;
        int64_t m_peer_connect_timeout = DEFAULT_PEER_CONNECT_TIMEOUT;
        std::vector<std::string> vSeedNodes;
        std::vector<NetWhitelistPermissions> vWhitelistedRangeIncoming;
        std::vector<NetWhitelistPermissions> vWhitelistedRangeOutgoing;
        std::vector<NetWhitebindPermissions> vWhiteBinds;
        std::vector<CService> vBinds;
        std::vector<CService> onion_binds;
        bool bind_on_any;
        bool m_use_addrman_outgoing = true;
        std::vector<std::string> m_specified_outgoing;
        std::vector<std::string> m_added_nodes;
        bool m_i2p_accept_incoming;
        bool whitelist_forcerelay = DEFAULT_WHITELISTFORCERELAY;
        bool whitelist_relay = DEFAULT_WHITELISTRELAY;
        bool m_capture_messages = false;
    };
 
    void Init(const Options& connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_total_bytes_sent_mutex)
    {
        AssertLockNotHeld(m_total_bytes_sent_mutex);
 
        m_local_services = connOptions.m_local_services;
        m_max_automatic_connections = connOptions.m_max_automatic_connections;
        m_max_outbound_full_relay = std::min(MAX_OUTBOUND_FULL_RELAY_CONNECTIONS, m_max_automatic_connections);
        m_max_outbound_block_relay = std::min(MAX_BLOCK_RELAY_ONLY_CONNECTIONS, m_max_automatic_connections - m_max_outbound_full_relay);
        m_max_automatic_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + m_max_feeler;
        m_max_inbound = std::max(0, m_max_automatic_connections - m_max_automatic_outbound);
        m_max_inbound_full_relay = std::max(0, static_cast<int>(connOptions.m_full_relay_inbound_percent / 100.0 * m_max_inbound));
        m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing;
        m_client_interface = connOptions.uiInterface;
        m_banman = connOptions.m_banman;
        m_msgproc = connOptions.m_msgproc;
        nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
        nReceiveFloodSize = connOptions.nReceiveFloodSize;
        m_peer_connect_timeout = std::chrono::seconds{connOptions.m_peer_connect_timeout};
        {
            LOCK(m_total_bytes_sent_mutex);
            nMaxOutboundLimit = connOptions.nMaxOutboundLimit;
        }
        vWhitelistedRangeIncoming = connOptions.vWhitelistedRangeIncoming;
        vWhitelistedRangeOutgoing = connOptions.vWhitelistedRangeOutgoing;
        {
            LOCK(m_added_nodes_mutex);
            // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our
            // peer doesn't support it or immediately disconnects us for another reason.
            const bool use_v2transport(GetLocalServices() & NODE_P2P_V2);
            for (const std::string& added_node : connOptions.m_added_nodes) {
                m_added_node_params.push_back({added_node, use_v2transport});
            }
        }
        m_onion_binds = connOptions.onion_binds;
        whitelist_forcerelay = connOptions.whitelist_forcerelay;
        whitelist_relay = connOptions.whitelist_relay;
        m_capture_messages = connOptions.m_capture_messages;
    }
 
    // test only
    void SetCaptureMessages(bool cap) { m_capture_messages = cap; }
 
    CConnman(uint64_t seed0,
             uint64_t seed1,
             AddrMan& addrman,
             const NetGroupManager& netgroupman,
             const CChainParams& params,
             bool network_active = true,
             std::shared_ptr<CThreadInterrupt> interrupt_net = std::make_shared<CThreadInterrupt>());
 
    ~CConnman();
 
    bool Start(CScheduler& scheduler, const Options& options) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !m_added_nodes_mutex, !m_addr_fetches_mutex, !mutexMsgProc);
 
    void StopThreads();
    void StopNodes() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_reconnections_mutex);
    void Stop() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_reconnections_mutex)
    {
        AssertLockNotHeld(m_nodes_mutex);
        AssertLockNotHeld(m_reconnections_mutex);
        StopThreads();
        StopNodes();
    };
 
    void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
    bool GetNetworkActive() const { return fNetworkActive; };
    bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; };
    void SetNetworkActive(bool active);
 
    bool OpenNetworkConnection(const CAddress& addrConnect,
                               bool fCountFailure,
                               CountingSemaphoreGrant<>&& grant_outbound,
                               const char* pszDest,
                               ConnectionType conn_type,
                               bool use_v2transport,
                               const std::optional<Proxy>& proxy_override)
        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_unused_i2p_sessions_mutex);
 
    class PrivateBroadcast
    {
    public:
        std::atomic_bool m_outbound_tor_ok_at_least_once{false};
 
        std::counting_semaphore<> m_sem_conn_max{MAX_PRIVATE_BROADCAST_CONNECTIONS};
 
        std::optional<Network> PickNetwork(std::optional<Proxy>& proxy) const;
 
        size_t NumToOpen() const;
 
        void NumToOpenAdd(size_t n);
 
        size_t NumToOpenSub(size_t n);
 
        void NumToOpenWait() const;
 
    protected:
        std::optional<Proxy> ProxyForIPv4or6() const;
 
        std::atomic_size_t m_num_to_open{0};
 
        friend struct ConnmanTestMsg;
    } m_private_broadcast;
 
    bool CheckIncomingNonce(uint64_t nonce) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    void ASMapHealthCheck();
 
    // alias for thread safety annotations only, not defined
    Mutex& GetNodesMutex() const LOCK_RETURNED(m_nodes_mutex);
 
    bool ForNode(NodeId id, std::function<bool(CNode* pnode)> func) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    void PushMessage(CNode* pnode, CSerializedNetMsg&& msg) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
 
    using NodeFn = std::function<void(CNode*)>;
    void ForEachNode(const NodeFn& func) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex)
    {
        LOCK(m_nodes_mutex);
        for (auto&& node : m_nodes) {
            if (NodeFullyConnected(node))
                func(node);
        }
    };
 
    void ForEachNode(const NodeFn& func) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex)
    {
        LOCK(m_nodes_mutex);
        for (auto&& node : m_nodes) {
            if (NodeFullyConnected(node))
                func(node);
        }
    };
 
    // Addrman functions
    std::vector<CAddress> GetAddressesUnsafe(size_t max_addresses, size_t max_pct, std::optional<Network> network, bool filtered = true) const;
    std::vector<CAddress> GetAddresses(CNode& requestor, size_t max_addresses, size_t max_pct);
 
    // This allows temporarily exceeding m_max_outbound_full_relay, with the goal of finding
    // a peer that is better than all our current peers.
    void SetTryNewOutboundPeer(bool flag);
    bool GetTryNewOutboundPeer() const;
 
    void StartExtraBlockRelayPeers();
 
    // Count the number of full-relay peer we have.
    int GetFullOutboundConnCount() const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    // Return the number of outbound peers we have in excess of our target (eg,
    // if we previously called SetTryNewOutboundPeer(true), and have since set
    // to false, we may have extra peers that we wish to disconnect). This may
    // return a value less than (num_outbound_connections - num_outbound_slots)
    // in cases where some outbound connections are not yet fully connected, or
    // not yet fully disconnected.
    int GetExtraFullOutboundCount() const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    // Count the number of block-relay-only peers we have over our limit.
    int GetExtraBlockRelayCount() const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    bool EvictTxPeerIfFull(std::optional<NodeId> protect_peer = std::nullopt) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    bool AddNode(const AddedNodeParams& add) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);
    bool RemoveAddedNode(std::string_view node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);
    bool AddedNodesContain(const CAddress& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);
    std::vector<AddedNodeInfo> GetAddedNodeInfo(bool include_connected) const
        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_nodes_mutex);
 
    bool AddConnection(const std::string& address, ConnectionType conn_type, bool use_v2transport)
        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_unused_i2p_sessions_mutex);
 
    size_t GetNodeCount(ConnectionDirection) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    std::map<CNetAddr, LocalServiceInfo> getNetLocalAddresses() const;
    uint32_t GetMappedAS(const CNetAddr& addr) const;
    void GetNodeStats(std::vector<CNodeStats>& vstats) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    bool DisconnectNode(std::string_view node) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    bool DisconnectNode(const CSubNet& subnet) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    bool DisconnectNode(const CNetAddr& addr) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    bool DisconnectNode(NodeId id) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    ServiceFlags GetLocalServices() const;
 
    void AddLocalServices(ServiceFlags services) { m_local_services = ServiceFlags(m_local_services | services); };
    void RemoveLocalServices(ServiceFlags services) { m_local_services = ServiceFlags(m_local_services & ~services); }
 
    uint64_t GetMaxOutboundTarget() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
    std::chrono::seconds GetMaxOutboundTimeframe() const;
 
    bool OutboundTargetReached(bool historicalBlockServingLimit) const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
 
    uint64_t GetOutboundTargetBytesLeft() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
 
    std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
 
    uint64_t GetTotalBytesRecv() const;
    uint64_t GetTotalBytesSent() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
 
    CSipHasher GetDeterministicRandomizer(uint64_t id) const;
 
    void WakeMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
 
    bool ShouldRunInactivityChecks(const CNode& node, NodeClock::time_point now) const;
 
    bool MultipleManualOrFullOutboundConns(Network net) const EXCLUSIVE_LOCKS_REQUIRED(m_nodes_mutex);
 
private:
    struct ListenSocket {
    public:
        std::shared_ptr<Sock> sock;
        inline void AddSocketPermissionFlags(NetPermissionFlags& flags) const { NetPermissions::AddFlag(flags, m_permissions); }
        ListenSocket(std::shared_ptr<Sock> sock_, NetPermissionFlags permissions_)
            : sock{sock_}, m_permissions{permissions_}
        {
        }
 
    private:
        NetPermissionFlags m_permissions;
    };
 
    std::chrono::seconds GetMaxOutboundTimeLeftInCycle_() const EXCLUSIVE_LOCKS_REQUIRED(m_total_bytes_sent_mutex);
 
    bool BindListenPort(const CService& bindAddr, bilingual_str& strError, NetPermissionFlags permissions);
    bool Bind(const CService& addr, unsigned int flags, NetPermissionFlags permissions);
    bool InitBinds(const Options& options);
 
    void ThreadOpenAddedConnections() EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex,
                                                               !m_nodes_mutex,
                                                               !m_reconnections_mutex,
                                                               !m_unused_i2p_sessions_mutex);
 
    void AddAddrFetch(const std::string& strDest) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex);
 
    void ProcessAddrFetch() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex,
                                                     !m_nodes_mutex,
                                                     !m_unused_i2p_sessions_mutex);
 
    void ThreadOpenConnections(std::vector<std::string> connect, std::span<const std::string> seed_nodes)
        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex,
                                 !m_addr_fetches_mutex,
                                 !m_nodes_mutex,
                                 !m_reconnections_mutex,
                                 !m_unused_i2p_sessions_mutex);
 
    void ThreadMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !mutexMsgProc);
    void ThreadI2PAcceptIncoming() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    void ThreadPrivateBroadcast() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_unused_i2p_sessions_mutex);
    void AcceptConnection(const ListenSocket& hListenSocket) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    void CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
                                      NetPermissionFlags permission_flags,
                                      const CService& addr_bind,
                                      const CService& addr)
        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    void DisconnectNodes() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex, !m_nodes_mutex);
    void NotifyNumConnectionsChanged() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
    bool InactivityCheck(const CNode& node, NodeClock::time_point now) const;
 
    Sock::EventsPerSock GenerateWaitSockets(std::span<CNode* const> nodes);
 
    void SocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_total_bytes_sent_mutex, !mutexMsgProc);
 
    void SocketHandlerConnected(const std::vector<CNode*>& nodes,
                                const Sock::EventsPerSock& events_per_sock)
        EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc);
 
    void SocketHandlerListening(const Sock::EventsPerSock& events_per_sock)
        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc, !m_nodes_mutex, !m_reconnections_mutex);
    void ThreadDNSAddressSeed() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_nodes_mutex);
 
    uint64_t CalculateKeyedNetGroup(const CNetAddr& ad) const;
 
    bool AlreadyConnectedToHost(std::string_view host) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    bool AlreadyConnectedToAddressPort(const CService& addr_port) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    bool AlreadyConnectedToAddress(const CNetAddr& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    bool AttemptToEvictConnection(bool evict_tx_relay_peer_only, std::optional<NodeId> protect_peer = std::nullopt) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    CNode* ConnectNode(CAddress addrConnect,
                       const char* pszDest,
                       bool fCountFailure,
                       ConnectionType conn_type,
                       bool use_v2transport,
                       const std::optional<Proxy>& proxy_override)
        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_unused_i2p_sessions_mutex);
 
    void AddWhitelistPermissionFlags(NetPermissionFlags& flags, std::optional<CNetAddr> addr, const std::vector<NetWhitelistPermissions>& ranges) const;
 
    void DeleteNode(CNode* pnode);
 
    NodeId GetNewNodeId();
 
    std::pair<size_t, bool> SocketSendData(CNode& node) const EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend);
 
    void DumpAddresses();
 
    // Network stats
    void RecordBytesRecv(uint64_t bytes);
    void RecordBytesSent(uint64_t bytes) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
 
    std::unordered_set<Network> GetReachableEmptyNetworks() const;
 
    std::vector<CAddress> GetCurrentBlockRelayOnlyConns() const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    bool MaybePickPreferredNetwork(std::optional<Network>& network) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
    // Whether the node should be passed out in ForEach* callbacks
    static bool NodeFullyConnected(const CNode* pnode);
 
    uint16_t GetDefaultPort(Network net) const;
    uint16_t GetDefaultPort(const std::string& addr) const;
 
    // Network usage totals
    mutable Mutex m_total_bytes_sent_mutex;
    std::atomic<uint64_t> nTotalBytesRecv{0};
    uint64_t nTotalBytesSent GUARDED_BY(m_total_bytes_sent_mutex) {0};
 
    // outbound limit & stats
    uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(m_total_bytes_sent_mutex) {0};
    std::chrono::seconds nMaxOutboundCycleStartTime GUARDED_BY(m_total_bytes_sent_mutex) {0};
    uint64_t nMaxOutboundLimit GUARDED_BY(m_total_bytes_sent_mutex);
 
    // P2P timeout in seconds
    std::chrono::seconds m_peer_connect_timeout;
 
    // Whitelisted ranges. Any node connecting from these is automatically
    // whitelisted (as well as those connecting to whitelisted binds).
    std::vector<NetWhitelistPermissions> vWhitelistedRangeIncoming;
    // Whitelisted ranges for outgoing connections.
    std::vector<NetWhitelistPermissions> vWhitelistedRangeOutgoing;
 
    unsigned int nSendBufferMaxSize{0};
    unsigned int nReceiveFloodSize{0};
 
    std::vector<ListenSocket> vhListenSocket;
    std::atomic<bool> fNetworkActive{true};
    bool fAddressesInitialized{false};
    std::reference_wrapper<AddrMan> addrman;
    const NetGroupManager& m_netgroupman;
    std::deque<std::string> m_addr_fetches GUARDED_BY(m_addr_fetches_mutex);
    Mutex m_addr_fetches_mutex;
 
    // connection string and whether to use v2 p2p
    std::vector<AddedNodeParams> m_added_node_params GUARDED_BY(m_added_nodes_mutex);
 
    mutable Mutex m_added_nodes_mutex;
    std::vector<CNode*> m_nodes GUARDED_BY(m_nodes_mutex);
    std::list<CNode*> m_nodes_disconnected;
    mutable Mutex m_nodes_mutex;
    std::atomic<NodeId> nLastNodeId{0};
    unsigned int nPrevNodeCount{0};
 
    // Stores number of full-tx connections (outbound and manual) per network
    std::array<unsigned int, Network::NET_MAX> m_network_conn_counts GUARDED_BY(m_nodes_mutex) = {};
 
    struct CachedAddrResponse {
        std::vector<CAddress> m_addrs_response_cache;
        std::chrono::microseconds m_cache_entry_expiration{0};
    };
 
    std::map<uint64_t, CachedAddrResponse> m_addr_response_caches;
 
    std::atomic<ServiceFlags> m_local_services;
 
    std::unique_ptr<std::counting_semaphore<>> semOutbound;
    std::unique_ptr<std::counting_semaphore<>> semAddnode;
 
    int m_max_automatic_connections;
 
    /*
     * Maximum number of peers by connection type. Might vary from defaults
     * based on -maxconnections init value.
     */
 
    // How many full-relay (tx, block, addr) outbound peers we want
    int m_max_outbound_full_relay;
 
    // How many block-relay only outbound peers we want
    // We do not relay tx or addr messages with these peers
    int m_max_outbound_block_relay;
 
    int m_max_addnode{MAX_ADDNODE_CONNECTIONS};
    int m_max_feeler{MAX_FEELER_CONNECTIONS};
    int m_max_automatic_outbound;
    int m_max_inbound;
    int m_max_inbound_full_relay;
 
    bool m_use_addrman_outgoing;
    CClientUIInterface* m_client_interface;
    NetEventsInterface* m_msgproc;
    BanMan* m_banman;
 
    std::vector<CAddress> m_anchors;
 
    const uint64_t nSeed0, nSeed1;
 
    bool fMsgProcWake GUARDED_BY(mutexMsgProc);
 
    std::condition_variable condMsgProc;
    Mutex mutexMsgProc;
    std::atomic<bool> flagInterruptMsgProc{false};
 
    const std::shared_ptr<CThreadInterrupt> m_interrupt_net;
 
    std::unique_ptr<i2p::sam::Session> m_i2p_sam_session;
 
    std::thread threadDNSAddressSeed;
    std::thread threadSocketHandler;
    std::thread threadOpenAddedConnections;
    std::thread threadOpenConnections;
    std::thread threadMessageHandler;
    std::thread threadI2PAcceptIncoming;
    std::thread threadPrivateBroadcast;
 
    std::atomic_bool m_try_another_outbound_peer;
 
    std::atomic_bool m_start_extra_block_relay_peers{false};
 
    std::vector<CService> m_onion_binds;
 
    bool whitelist_forcerelay;
 
    bool whitelist_relay;
 
    bool m_capture_messages{false};
 
    Mutex m_unused_i2p_sessions_mutex;
 
    std::queue<std::unique_ptr<i2p::sam::Session>> m_unused_i2p_sessions GUARDED_BY(m_unused_i2p_sessions_mutex);
 
    Mutex m_reconnections_mutex;
 
    struct ReconnectionInfo
    {
        std::optional<Proxy> proxy_override;
        CAddress addr_connect;
        CountingSemaphoreGrant<> grant;
        std::string destination;
        ConnectionType conn_type;
        bool use_v2transport;
    };
 
    std::list<ReconnectionInfo> m_reconnections GUARDED_BY(m_reconnections_mutex);
 
    void PerformReconnections()
        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_reconnections_mutex, !m_unused_i2p_sessions_mutex);
 
    static constexpr size_t MAX_UNUSED_I2P_SESSIONS_SIZE{10};
 
    class NodesSnapshot
    {
    public:
        explicit NodesSnapshot(const CConnman& connman, bool shuffle)
            EXCLUSIVE_LOCKS_REQUIRED(!connman.m_nodes_mutex)
        {
            {
                LOCK(connman.m_nodes_mutex);
                m_nodes_copy = connman.m_nodes;
                for (auto& node : m_nodes_copy) {
                    node->AddRef();
                }
            }
            if (shuffle) {
                std::shuffle(m_nodes_copy.begin(), m_nodes_copy.end(), FastRandomContext{});
            }
        }
 
        ~NodesSnapshot()
        {
            for (auto& node : m_nodes_copy) {
                node->Release();
            }
        }
 
        const std::vector<CNode*>& Nodes() const
        {
            return m_nodes_copy;
        }
 
    private:
        std::vector<CNode*> m_nodes_copy;
    };
 
    const CChainParams& m_params;
 
    friend struct ConnmanTestMsg;
};
 
extern std::function<void(const CAddress& addr,
                          const std::string& msg_type,
                          std::span<const unsigned char> data,
                          bool is_incoming)>
    CaptureMessage;
 
#endif // BITCOIN_NET_H