Inside Bitcoin

1001
1002    /// A ping-pong round trip has completed successfully. Update latest and minimum ping durations.
1003    void PongReceived(NodeClock::duration ping_time)
1004    {
1005        m_last_ping_time = ping_time;
1006        m_min_ping_time = std::min(m_min_ping_time.load(), ping_time);
1007    }
1008
1009private:
1010    const NodeId id;
1011    const uint64_t nLocalHostNonce;
1012    std::atomic<int> m_greatest_common_version{INIT_PROTO_VERSION};
1013
1014    const size_t m_recv_flood_size;
1015    std::list<CNetMessage> vRecvMsg; // Used only by SocketHandler thread
1016
1017    Mutex m_msg_process_queue_mutex;
1018    std::list<CNetMessage> m_msg_process_queue GUARDED_BY(m_msg_process_queue_mutex);
1019    size_t m_msg_process_queue_size GUARDED_BY(m_msg_process_queue_mutex){0};
1020
1021    // Our address, as reported by the peer
1022    CService m_addr_local GUARDED_BY(m_addr_local_mutex);
1023    mutable Mutex m_addr_local_mutex;
1024
1025    mapMsgTypeSize mapSendBytesPerMsgType GUARDED_BY(cs_vSend);
1026    mapMsgTypeSize mapRecvBytesPerMsgType GUARDED_BY(cs_vRecv);
1027
1028    /**
1029     * If an I2P session is created per connection (for outbound transient I2P
1030     * connections) then it is stored here so that it can be destroyed when the
1031     * socket is closed. I2P sessions involve a data/transport socket (in `m_sock`)
1032     * and a control socket (in `m_i2p_sam_session`). For transient sessions, once
1033     * the data socket is closed, the control socket is not going to be used anymore
1034     * and is just taking up resources. So better close it as soon as `m_sock` is
1035     * closed.
1036     * Otherwise this unique_ptr is empty.
1037     */
1038    std::unique_ptr<i2p::sam::Session> m_i2p_sam_session GUARDED_BY(m_sock_mutex);
1039};
1040
1041/**
1042 * Interface for message handling
1043 */
1044class NetEventsInterface
1045{
1046public:
1047    /** Mutex for anything that is only accessed via the msg processing thread */
1048    static Mutex g_msgproc_mutex;
1049
1050    /** Initialize a peer (setup state) */
1051    virtual void InitializeNode(const CNode& node, ServiceFlags our_services) = 0;
1052
1053    /** Handle removal of a peer (clear state) */
1054    virtual void FinalizeNode(const CNode& node) = 0;
1055
1056    /**
1057     * Callback to determine whether the given set of service flags are sufficient
1058     * for a peer to be "relevant".
1059     */
1060    virtual bool HasAllDesirableServiceFlags(ServiceFlags services) const = 0;
1061
1062    /**
1063     * Process protocol messages received from a given node
1064     *
1065     * @param[in]   node            The node which we have received messages from.
1066     * @param[in]   interrupt       Interrupt condition for processing threads
1067     * @return                      True if there is more work to be done
1068     */
1069    virtual bool ProcessMessages(CNode& node, std::atomic<bool>& interrupt) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0;
1070
1071    /**
1072     * Send queued protocol messages to a given node.
1073     *
1074     * @param[in]   node            The node which we are sending messages to.
1075     * @return                      True if there is more work to be done
1076     */
1077    virtual bool SendMessages(CNode& node) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0;
1078
1079
1080protected:
1081    /**
1082     * Protected destructor so that instances can only be deleted by derived classes.
1083     * If that restriction is no longer desired, this should be made public and virtual.
1084     */
1085    ~NetEventsInterface() = default;
1086};
1087
1088class CConnman
1089{
1090public:
1091
1092    struct Options
1093    {
1094        ServiceFlags m_local_services = NODE_NONE;
1095        int m_max_automatic_connections = DEFAULT_MAX_PEER_CONNECTIONS;
1096        int m_full_relay_inbound_percent = DEFAULT_FULL_RELAY_INBOUND_PCT;
1097        CClientUIInterface* uiInterface = nullptr;
1098        NetEventsInterface* m_msgproc = nullptr;
1099        BanMan* m_banman = nullptr;
1100        unsigned int nSendBufferMaxSize = 0;
1101        unsigned int nReceiveFloodSize = 0;
1102        uint64_t nMaxOutboundLimit = 0;
1103        int64_t m_peer_connect_timeout = DEFAULT_PEER_CONNECT_TIMEOUT;
1104        std::vector<std::string> vSeedNodes;
1105        std::vector<NetWhitelistPermissions> vWhitelistedRangeIncoming;
1106        std::vector<NetWhitelistPermissions> vWhitelistedRangeOutgoing;
1107        std::vector<NetWhitebindPermissions> vWhiteBinds;
1108        std::vector<CService> vBinds;
1109        std::vector<CService> onion_binds;
1110        /// True if the user did not specify -bind= or -whitebind= and thus
1111        /// we should bind on `0.0.0.0` (IPv4) and `::` (IPv6).
1112        bool bind_on_any;
1113        bool m_use_addrman_outgoing = true;
1114        std::vector<std::string> m_specified_outgoing;
1115        std::vector<std::string> m_added_nodes;
1116        bool m_i2p_accept_incoming;
1117        bool whitelist_forcerelay = DEFAULT_WHITELISTFORCERELAY;
1118        bool whitelist_relay = DEFAULT_WHITELISTRELAY;
1119        bool m_capture_messages = false;
1120    };
1121
1122    void Init(const Options& connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_total_bytes_sent_mutex)
1123    {
1124        AssertLockNotHeld(m_total_bytes_sent_mutex);
1125
1126        m_local_services = connOptions.m_local_services;
1127        m_max_automatic_connections = connOptions.m_max_automatic_connections;
1128        m_max_outbound_full_relay = std::min(MAX_OUTBOUND_FULL_RELAY_CONNECTIONS, m_max_automatic_connections);
1129        m_max_outbound_block_relay = std::min(MAX_BLOCK_RELAY_ONLY_CONNECTIONS, m_max_automatic_connections - m_max_outbound_full_relay);
1130        m_max_automatic_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + m_max_feeler;
1131        m_max_inbound = std::max(0, m_max_automatic_connections - m_max_automatic_outbound);
1132        m_max_inbound_full_relay = std::max(0, static_cast<int>(connOptions.m_full_relay_inbound_percent / 100.0 * m_max_inbound));
1133        m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing;
1134        m_client_interface = connOptions.uiInterface;
1135        m_banman = connOptions.m_banman;
1136        m_msgproc = connOptions.m_msgproc;
1137        nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
1138        nReceiveFloodSize = connOptions.nReceiveFloodSize;
1139        m_peer_connect_timeout = std::chrono::seconds{connOptions.m_peer_connect_timeout};
1140        {
1141            LOCK(m_total_bytes_sent_mutex);
1142            nMaxOutboundLimit = connOptions.nMaxOutboundLimit;
1143        }
1144        vWhitelistedRangeIncoming = connOptions.vWhitelistedRangeIncoming;
1145        vWhitelistedRangeOutgoing = connOptions.vWhitelistedRangeOutgoing;
1146        {
1147            LOCK(m_added_nodes_mutex);
1148            // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our
1149            // peer doesn't support it or immediately disconnects us for another reason.
1150            const bool use_v2transport(GetLocalServices() & NODE_P2P_V2);
1151            for (const std::string& added_node : connOptions.m_added_nodes) {
1152                m_added_node_params.push_back({added_node, use_v2transport});
1153            }
1154        }
1155        m_onion_binds = connOptions.onion_binds;
1156        whitelist_forcerelay = connOptions.whitelist_forcerelay;
1157        whitelist_relay = connOptions.whitelist_relay;
1158        m_capture_messages = connOptions.m_capture_messages;
1159    }
1160
1161    // test only
1162    void SetCaptureMessages(bool cap) { m_capture_messages = cap; }
1163
1164    CConnman(uint64_t seed0,
1165             uint64_t seed1,
1166             AddrMan& addrman,
1167             const NetGroupManager& netgroupman,
1168             const CChainParams& params,
1169             bool network_active = true,
1170             std::shared_ptr<CThreadInterrupt> interrupt_net = std::make_shared<CThreadInterrupt>());
1171
1172    ~CConnman();
1173
1174    bool Start(CScheduler& scheduler, const Options& options) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !m_added_nodes_mutex, !m_addr_fetches_mutex, !mutexMsgProc);
1175
1176    void StopThreads();
1177    void StopNodes() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_reconnections_mutex);
1178    void Stop() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_reconnections_mutex)
1179    {
1180        AssertLockNotHeld(m_nodes_mutex);
1181        AssertLockNotHeld(m_reconnections_mutex);
1182        StopThreads();
1183        StopNodes();
1184    };
1185
1186    void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
1187    bool GetNetworkActive() const { return fNetworkActive; };
1188    bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; };
1189    void SetNetworkActive(bool active);
1190
1191    /**
1192     * Open a new P2P connection and initialize it with the PeerManager at `m_msgproc`.
1193     * @param[in] addrConnect Address to connect to, if `pszDest` is `nullptr`.
1194     * @param[in] fCountFailure Increment the number of connection attempts to this address in Addrman.
1195     * @param[in] grant_outbound Take ownership of this grant, to be released later when the connection is closed.
1196     * @param[in] pszDest Address to resolve and connect to.
1197     * @param[in] conn_type Type of the connection to open, must not be `ConnectionType::INBOUND`.
1198     * @param[in] use_v2transport Use P2P encryption, (aka V2 transport, BIP324).
1199     * @param[in] proxy_override Optional proxy to use and override normal proxy selection.
1200     * @retval true The connection was opened successfully.
1201     * @retval false The connection attempt failed.
1202     */
1203    bool OpenNetworkConnection(const CAddress& addrConnect,
1204                               bool fCountFailure,
1205                               CountingSemaphoreGrant<>&& grant_outbound,
1206                               const char* pszDest,
1207                               ConnectionType conn_type,
1208                               bool use_v2transport,
1209                               const std::optional<Proxy>& proxy_override)
1210        EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_unused_i2p_sessions_mutex);
1211
1212    /// Group of private broadcast related members.
1213    class PrivateBroadcast
1214    {
1215    public:
1216        /**
1217         * Remember if we ever established at least one outbound connection to a
1218         * Tor peer, including sending and receiving P2P messages. If this is
1219         * true then the Tor proxy indeed works and is a proxy to the Tor network,
1220         * not a misconfigured ordinary SOCKS5 proxy as -proxy or -onion. If that
1221         * is the case, then we assume that connecting to an IPv4 or IPv6 address
1222         * via that proxy will be done through the Tor network and a Tor exit node.
1223         */
1224        std::atomic_bool m_outbound_tor_ok_at_least_once{false};
1225
1226        /**
1227         * Semaphore used to guard against opening too many connections.
1228         * Opening private broadcast connections will be paused if this is equal to 0.
1229         */
1230        std::counting_semaphore<> m_sem_conn_max{MAX_PRIVATE_BROADCAST_CONNECTIONS};
1231
1232        /**
1233         * Choose a network to open a connection to.
1234         * @param[out] proxy Optional proxy to override the normal proxy selection.
1235         * Will be set if !std::nullopt is returned. Could be set to `std::nullopt`
1236         * if there is no need to override the proxy that would be used for connecting
1237         * to the returned network.
1238         * @retval std::nullopt No network could be selected.
1239         * @retval !std::nullopt The network was selected and `proxy` is set (maybe to `std::nullopt`).
1240         */
1241        std::optional<Network> PickNetwork(std::optional<Proxy>& proxy) const;
1242
1243        /// Get the pending number of connections to open.
1244        size_t NumToOpen() const;
1245
1246        /**
1247         * Increment the number of new connections of type `ConnectionType::PRIVATE_BROADCAST`
1248         * to be opened by `CConnman::ThreadPrivateBroadcast()`.
1249         * @param[in] n Increment by this number.
1250         */