Inside Bitcoin

1501    /** Return true if the peer is inactive and should be disconnected. */
1502    bool InactivityCheck(const CNode& node, NodeClock::time_point now) const;
1503
1504    /**
1505     * Generate a collection of sockets to check for IO readiness.
1506     * @param[in] nodes Select from these nodes' sockets.
1507     * @return sockets to check for readiness
1508     */
1509    Sock::EventsPerSock GenerateWaitSockets(std::span<CNode* const> nodes);
1510
1511    /**
1512     * Check connected and listening sockets for IO readiness and process them accordingly.
1513     */
1514    void SocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_total_bytes_sent_mutex, !mutexMsgProc);
1515
1516    /**
1517     * Do the read/write for connected sockets that are ready for IO.
1518     * @param[in] nodes Nodes to process. The socket of each node is checked against `what`.
1519     * @param[in] events_per_sock Sockets that are ready for IO.
1520     */
1521    void SocketHandlerConnected(const std::vector<CNode*>& nodes,
1522                                const Sock::EventsPerSock& events_per_sock)
1523        EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc);
1524
1525    /**
1526     * Accept incoming connections, one from each read-ready listening socket.
1527     * @param[in] events_per_sock Sockets that are ready for IO.
1528     */
1529    void SocketHandlerListening(const Sock::EventsPerSock& events_per_sock)
1530        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
1531
1532    /// \anchor net
1533    void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc, !m_nodes_mutex, !m_reconnections_mutex);
1534    /// \anchor dnsseed
1535    void ThreadDNSAddressSeed() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_nodes_mutex);
1536
1537    uint64_t CalculateKeyedNetGroup(const CNetAddr& ad) const;
1538
1539    /**
1540     * Determine whether we're already connected to a given "host:port".
1541     * Note that for inbound connections, the peer is likely using a random outbound
1542     * port on their side, so this will likely not match any inbound connections.
1543     * @param[in] host String of the form "host[:port]", e.g. "localhost" or "localhost:8333" or "1.2.3.4:8333".
1544     * @return true if connected to `host`.
1545     */
1546    bool AlreadyConnectedToHost(std::string_view host) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
1547
1548    /**
1549     * Determine whether we're already connected to a given address:port.
1550     * Note that for inbound connections, the peer is likely using a random outbound
1551     * port on their side, so this will likely not match any inbound connections.
1552     * @param[in] addr_port Address and port to check.
1553     * @return true if connected to addr_port.
1554     */
1555    bool AlreadyConnectedToAddressPort(const CService& addr_port) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
1556
1557    /**
1558     * Determine whether we're already connected to a given address.
1559     */
1560    bool AlreadyConnectedToAddress(const CNetAddr& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
1561
1562    /**
1563     * Try to find an inbound connection to evict.
1564     * @param[in] evict_tx_relay_peer_only  Whether to only select full relay peers for eviction
1565     * @param[in] protect_peer              Protect peer with node id
1566     * @return                              True if a node was marked for disconnect
1567     */
1568    bool AttemptToEvictConnection(bool evict_tx_relay_peer_only, std::optional<NodeId> protect_peer = std::nullopt) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
1569
1570    /**
1571     * Open a new P2P connection.
1572     * @param[in] addrConnect Address to connect to, if `pszDest` is `nullptr`.
1573     * @param[in] pszDest Address to resolve and connect to.
1574     * @param[in] fCountFailure Increment the number of connection attempts to this address in Addrman.
1575     * @param[in] conn_type Type of the connection to open, must not be `ConnectionType::INBOUND`.
1576     * @param[in] use_v2transport Use P2P encryption, (aka V2 transport, BIP324).
1577     * @param[in] proxy_override Optional proxy to use and override normal proxy selection.
1578     * @return Newly created CNode object or nullptr if the connection failed.
1579     */
1580    CNode* ConnectNode(CAddress addrConnect,
1581                       const char* pszDest,
1582                       bool fCountFailure,
1583                       ConnectionType conn_type,
1584                       bool use_v2transport,
1585                       const std::optional<Proxy>& proxy_override)
1586        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_unused_i2p_sessions_mutex);
1587
1588    void AddWhitelistPermissionFlags(NetPermissionFlags& flags, std::optional<CNetAddr> addr, const std::vector<NetWhitelistPermissions>& ranges) const;
1589
1590    void DeleteNode(CNode* pnode);
1591
1592    NodeId GetNewNodeId();
1593
1594    /** (Try to) send data from node's vSendMsg. Returns (bytes_sent, data_left). */
1595    std::pair<size_t, bool> SocketSendData(CNode& node) const EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend);
1596
1597    void DumpAddresses();
1598
1599    // Network stats
1600    void RecordBytesRecv(uint64_t bytes);
1601    void RecordBytesSent(uint64_t bytes) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
1602
1603    /**
1604     Return reachable networks for which we have no addresses in addrman and therefore
1605     may require loading fixed seeds.
1606     */
1607    std::unordered_set<Network> GetReachableEmptyNetworks() const;
1608
1609    /**
1610     * Return vector of current BLOCK_RELAY peers.
1611     */
1612    std::vector<CAddress> GetCurrentBlockRelayOnlyConns() const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
1613
1614    /**
1615     * Search for a "preferred" network, a reachable network to which we
1616     * currently don't have any OUTBOUND_FULL_RELAY or MANUAL connections.
1617     * There needs to be at least one address in AddrMan for a preferred
1618     * network to be picked.
1619     *
1620     * @param[out]    network        Preferred network, if found.
1621     *
1622     * @return           bool        Whether a preferred network was found.
1623     */
1624    bool MaybePickPreferredNetwork(std::optional<Network>& network) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
1625
1626    // Whether the node should be passed out in ForEach* callbacks
1627    static bool NodeFullyConnected(const CNode* pnode);
1628
1629    uint16_t GetDefaultPort(Network net) const;
1630    uint16_t GetDefaultPort(const std::string& addr) const;
1631
1632    // Network usage totals
1633    mutable Mutex m_total_bytes_sent_mutex;
1634    std::atomic<uint64_t> nTotalBytesRecv{0};
1635    uint64_t nTotalBytesSent GUARDED_BY(m_total_bytes_sent_mutex) {0};
1636
1637    // outbound limit & stats
1638    uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(m_total_bytes_sent_mutex) {0};
1639    std::chrono::seconds nMaxOutboundCycleStartTime GUARDED_BY(m_total_bytes_sent_mutex) {0};
1640    uint64_t nMaxOutboundLimit GUARDED_BY(m_total_bytes_sent_mutex);
1641
1642    // P2P timeout in seconds
1643    std::chrono::seconds m_peer_connect_timeout;
1644
1645    // Whitelisted ranges. Any node connecting from these is automatically
1646    // whitelisted (as well as those connecting to whitelisted binds).
1647    std::vector<NetWhitelistPermissions> vWhitelistedRangeIncoming;
1648    // Whitelisted ranges for outgoing connections.
1649    std::vector<NetWhitelistPermissions> vWhitelistedRangeOutgoing;
1650
1651    unsigned int nSendBufferMaxSize{0};
1652    unsigned int nReceiveFloodSize{0};
1653
1654    std::vector<ListenSocket> vhListenSocket;
1655    std::atomic<bool> fNetworkActive{true};
1656    bool fAddressesInitialized{false};
1657    std::reference_wrapper<AddrMan> addrman;
1658    const NetGroupManager& m_netgroupman;
1659    std::deque<std::string> m_addr_fetches GUARDED_BY(m_addr_fetches_mutex);
1660    Mutex m_addr_fetches_mutex;
1661
1662    // connection string and whether to use v2 p2p
1663    std::vector<AddedNodeParams> m_added_node_params GUARDED_BY(m_added_nodes_mutex);
1664
1665    mutable Mutex m_added_nodes_mutex;
1666    std::vector<CNode*> m_nodes GUARDED_BY(m_nodes_mutex);
1667    std::list<CNode*> m_nodes_disconnected;
1668    mutable Mutex m_nodes_mutex;
1669    std::atomic<NodeId> nLastNodeId{0};
1670    unsigned int nPrevNodeCount{0};
1671
1672    // Stores number of full-tx connections (outbound and manual) per network
1673    std::array<unsigned int, Network::NET_MAX> m_network_conn_counts GUARDED_BY(m_nodes_mutex) = {};
1674
1675    /**
1676     * Cache responses to addr requests to minimize privacy leak.
1677     * Attack example: scraping addrs in real-time may allow an attacker
1678     * to infer new connections of the victim by detecting new records
1679     * with fresh timestamps (per self-announcement).
1680     */
1681    struct CachedAddrResponse {
1682        std::vector<CAddress> m_addrs_response_cache;
1683        std::chrono::microseconds m_cache_entry_expiration{0};
1684    };
1685
1686    /**
1687     * Addr responses stored in different caches
1688     * per (network, local socket) prevent cross-network node identification.
1689     * If a node for example is multi-homed under Tor and IPv6,
1690     * a single cache (or no cache at all) would let an attacker
1691     * to easily detect that it is the same node by comparing responses.
1692     * Indexing by local socket prevents leakage when a node has multiple
1693     * listening addresses on the same network.
1694     *
1695     * The used memory equals to 1000 CAddress records (or around 40 bytes) per
1696     * distinct Network (up to 5) we have/had an inbound peer from,
1697     * resulting in at most ~196 KB. Every separate local socket may
1698     * add up to ~196 KB extra.
1699     */
1700    std::map<uint64_t, CachedAddrResponse> m_addr_response_caches;
1701
1702    /**
1703     * Services this node offers.
1704     *
1705     * This data is replicated in each Peer instance we create.
1706     *
1707     * This data is not marked const, but after being set it should not
1708     * change. Unless AssumeUTXO is started, in which case, the peer
1709     * will be limited until the background chain sync finishes.
1710     *
1711     * \sa Peer::our_services
1712     */
1713    std::atomic<ServiceFlags> m_local_services;
1714
1715    std::unique_ptr<std::counting_semaphore<>> semOutbound;
1716    std::unique_ptr<std::counting_semaphore<>> semAddnode;
1717
1718    /**
1719     * Maximum number of automatic connections permitted, excluding manual
1720     * connections but including inbounds. May be changed by the user and is
1721     * potentially limited by the operating system (number of file descriptors).
1722     */
1723    int m_max_automatic_connections;
1724
1725    /*
1726     * Maximum number of peers by connection type. Might vary from defaults
1727     * based on -maxconnections init value.
1728     */
1729
1730    // How many full-relay (tx, block, addr) outbound peers we want
1731    int m_max_outbound_full_relay;
1732
1733    // How many block-relay only outbound peers we want
1734    // We do not relay tx or addr messages with these peers
1735    int m_max_outbound_block_relay;
1736
1737    int m_max_addnode{MAX_ADDNODE_CONNECTIONS};
1738    int m_max_feeler{MAX_FEELER_CONNECTIONS};
1739    int m_max_automatic_outbound;
1740    int m_max_inbound;
1741    int m_max_inbound_full_relay;
1742
1743    bool m_use_addrman_outgoing;
1744    CClientUIInterface* m_client_interface;
1745    NetEventsInterface* m_msgproc;
1746    /** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */
1747    BanMan* m_banman;
1748
1749    /**
1750     * Addresses that were saved during the previous clean shutdown. We'll