net.h
1 // Copyright (c) 2009-2010 Satoshi Nakamoto 2 // Copyright (c) 2009-2022 The Bitcoin Core developers 3 // Distributed under the MIT software license, see the accompanying 4 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 5 6 #ifndef BITCOIN_NET_H 7 #define BITCOIN_NET_H 8 9 #include <bip324.h> 10 #include <chainparams.h> 11 #include <common/bloom.h> 12 #include <compat/compat.h> 13 #include <consensus/amount.h> 14 #include <crypto/siphash.h> 15 #include <hash.h> 16 #include <i2p.h> 17 #include <kernel/messagestartchars.h> 18 #include <net_permissions.h> 19 #include <netaddress.h> 20 #include <netbase.h> 21 #include <netgroup.h> 22 #include <node/connection_types.h> 23 #include <node/protocol_version.h> 24 #include <policy/feerate.h> 25 #include <protocol.h> 26 #include <random.h> 27 #include <span.h> 28 #include <streams.h> 29 #include <sync.h> 30 #include <uint256.h> 31 #include <util/check.h> 32 #include <util/sock.h> 33 #include <util/threadinterrupt.h> 34 35 #include <atomic> 36 #include <condition_variable> 37 #include <cstdint> 38 #include <deque> 39 #include <functional> 40 #include <list> 41 #include <map> 42 #include <memory> 43 #include <optional> 44 #include <queue> 45 #include <thread> 46 #include <unordered_set> 47 #include <vector> 48 49 class AddrMan; 50 class BanMan; 51 class CChainParams; 52 class CNode; 53 class CScheduler; 54 struct bilingual_str; 55 56 /** Time after which to disconnect, after waiting for a ping response (or inactivity). */ 57 static constexpr std::chrono::minutes TIMEOUT_INTERVAL{20}; 58 /** Run the feeler connection loop once every 2 minutes. **/ 59 static constexpr auto FEELER_INTERVAL = 2min; 60 /** Run the extra block-relay-only connection loop once every 5 minutes. **/ 61 static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min; 62 /** Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable). */ 63 static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1000 * 1000; 64 /** Maximum length of the user agent string in `version` message */ 65 static const unsigned int MAX_SUBVERSION_LENGTH = 256; 66 /** Maximum number of automatic outgoing nodes over which we'll relay everything (blocks, tx, addrs, etc) */ 67 static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS = 8; 68 /** Maximum number of addnode outgoing nodes */ 69 static const int MAX_ADDNODE_CONNECTIONS = 8; 70 /** Maximum number of block-relay-only outgoing connections */ 71 static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS = 2; 72 /** Maximum number of feeler connections */ 73 static const int MAX_FEELER_CONNECTIONS = 1; 74 /** -listen default */ 75 static const bool DEFAULT_LISTEN = true; 76 /** The maximum number of peer connections to maintain. */ 77 static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 125; 78 /** The default for -maxuploadtarget. 0 = Unlimited */ 79 static const std::string DEFAULT_MAX_UPLOAD_TARGET{"0M"}; 80 /** Default for blocks only*/ 81 static const bool DEFAULT_BLOCKSONLY = false; 82 /** -peertimeout default */ 83 static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60; 84 /** Number of file descriptors required for message capture **/ 85 static const int NUM_FDS_MESSAGE_CAPTURE = 1; 86 /** Interval for ASMap Health Check **/ 87 static constexpr std::chrono::hours ASMAP_HEALTH_CHECK_INTERVAL{24}; 88 89 static constexpr bool DEFAULT_FORCEDNSSEED{false}; 90 static constexpr bool DEFAULT_DNSSEED{true}; 91 static constexpr bool DEFAULT_FIXEDSEEDS{true}; 92 static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000; 93 static const size_t DEFAULT_MAXSENDBUFFER = 1 * 1000; 94 95 static constexpr bool DEFAULT_V2_TRANSPORT{true}; 96 97 typedef int64_t NodeId; 98 99 struct AddedNodeParams { 100 std::string m_added_node; 101 bool m_use_v2transport; 102 }; 103 104 struct AddedNodeInfo { 105 AddedNodeParams m_params; 106 CService resolvedAddress; 107 bool fConnected; 108 bool fInbound; 109 }; 110 111 class CNodeStats; 112 class CClientUIInterface; 113 114 struct CSerializedNetMsg { 115 CSerializedNetMsg() = default; 116 CSerializedNetMsg(CSerializedNetMsg&&) = default; 117 CSerializedNetMsg& operator=(CSerializedNetMsg&&) = default; 118 // No implicit copying, only moves. 119 CSerializedNetMsg(const CSerializedNetMsg& msg) = delete; 120 CSerializedNetMsg& operator=(const CSerializedNetMsg&) = delete; 121 122 CSerializedNetMsg Copy() const 123 { 124 CSerializedNetMsg copy; 125 copy.data = data; 126 copy.m_type = m_type; 127 return copy; 128 } 129 130 std::vector<unsigned char> data; 131 std::string m_type; 132 133 /** Compute total memory usage of this object (own memory + any dynamic memory). */ 134 size_t GetMemoryUsage() const noexcept; 135 }; 136 137 /** 138 * Look up IP addresses from all interfaces on the machine and add them to the 139 * list of local addresses to self-advertise. 140 * The loopback interface is skipped and only the first address from each 141 * interface is used. 142 */ 143 void Discover(); 144 145 uint16_t GetListenPort(); 146 147 enum 148 { 149 LOCAL_NONE, // unknown 150 LOCAL_IF, // address a local interface listens on 151 LOCAL_BIND, // address explicit bound to 152 LOCAL_MAPPED, // address reported by UPnP or NAT-PMP 153 LOCAL_MANUAL, // address explicitly specified (-externalip=) 154 155 LOCAL_MAX 156 }; 157 158 /** Returns a local address that we should advertise to this peer. */ 159 std::optional<CService> GetLocalAddrForPeer(CNode& node); 160 161 bool AddLocal(const CService& addr, int nScore = LOCAL_NONE); 162 bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE); 163 void RemoveLocal(const CService& addr); 164 bool SeenLocal(const CService& addr); 165 bool IsLocal(const CService& addr); 166 CService GetLocalAddress(const CNode& peer); 167 168 extern bool fDiscover; 169 extern bool fListen; 170 171 /** Subversion as sent to the P2P network in `version` messages */ 172 extern std::string strSubVersion; 173 174 struct LocalServiceInfo { 175 int nScore; 176 uint16_t nPort; 177 }; 178 179 extern GlobalMutex g_maplocalhost_mutex; 180 extern std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(g_maplocalhost_mutex); 181 182 extern const std::string NET_MESSAGE_TYPE_OTHER; 183 using mapMsgTypeSize = std::map</* message type */ std::string, /* total bytes */ uint64_t>; 184 185 class CNodeStats 186 { 187 public: 188 NodeId nodeid; 189 std::chrono::seconds m_last_send; 190 std::chrono::seconds m_last_recv; 191 std::chrono::seconds m_last_tx_time; 192 std::chrono::seconds m_last_block_time; 193 std::chrono::seconds m_connected; 194 int64_t nTimeOffset; 195 std::string m_addr_name; 196 int nVersion; 197 std::string cleanSubVer; 198 bool fInbound; 199 // We requested high bandwidth connection to peer 200 bool m_bip152_highbandwidth_to; 201 // Peer requested high bandwidth connection 202 bool m_bip152_highbandwidth_from; 203 int m_starting_height; 204 uint64_t nSendBytes; 205 mapMsgTypeSize mapSendBytesPerMsgType; 206 uint64_t nRecvBytes; 207 mapMsgTypeSize mapRecvBytesPerMsgType; 208 NetPermissionFlags m_permission_flags; 209 std::chrono::microseconds m_last_ping_time; 210 std::chrono::microseconds m_min_ping_time; 211 // Our address, as reported by the peer 212 std::string addrLocal; 213 // Address of this peer 214 CAddress addr; 215 // Bind address of our side of the connection 216 CAddress addrBind; 217 // Network the peer connected through 218 Network m_network; 219 uint32_t m_mapped_as; 220 ConnectionType m_conn_type; 221 /** Transport protocol type. */ 222 TransportProtocolType m_transport_type; 223 /** BIP324 session id string in hex, if any. */ 224 std::string m_session_id; 225 }; 226 227 228 /** Transport protocol agnostic message container. 229 * Ideally it should only contain receive time, payload, 230 * type and size. 231 */ 232 class CNetMessage 233 { 234 public: 235 DataStream m_recv; //!< received message data 236 std::chrono::microseconds m_time{0}; //!< time of message receipt 237 uint32_t m_message_size{0}; //!< size of the payload 238 uint32_t m_raw_message_size{0}; //!< used wire size of the message (including header/checksum) 239 std::string m_type; 240 241 explicit CNetMessage(DataStream&& recv_in) : m_recv(std::move(recv_in)) {} 242 // Only one CNetMessage object will exist for the same message on either 243 // the receive or processing queue. For performance reasons we therefore 244 // delete the copy constructor and assignment operator to avoid the 245 // possibility of copying CNetMessage objects. 246 CNetMessage(CNetMessage&&) = default; 247 CNetMessage(const CNetMessage&) = delete; 248 CNetMessage& operator=(CNetMessage&&) = default; 249 CNetMessage& operator=(const CNetMessage&) = delete; 250 }; 251 252 /** The Transport converts one connection's sent messages to wire bytes, and received bytes back. */ 253 class Transport { 254 public: 255 virtual ~Transport() {} 256 257 struct Info 258 { 259 TransportProtocolType transport_type; 260 std::optional<uint256> session_id; 261 }; 262 263 /** Retrieve information about this transport. */ 264 virtual Info GetInfo() const noexcept = 0; 265 266 // 1. Receiver side functions, for decoding bytes received on the wire into transport protocol 267 // agnostic CNetMessage (message type & payload) objects. 268 269 /** Returns true if the current message is complete (so GetReceivedMessage can be called). */ 270 virtual bool ReceivedMessageComplete() const = 0; 271 272 /** Feed wire bytes to the transport. 273 * 274 * @return false if some bytes were invalid, in which case the transport can't be used anymore. 275 * 276 * Consumed bytes are chopped off the front of msg_bytes. 277 */ 278 virtual bool ReceivedBytes(Span<const uint8_t>& msg_bytes) = 0; 279 280 /** Retrieve a completed message from transport. 281 * 282 * This can only be called when ReceivedMessageComplete() is true. 283 * 284 * If reject_message=true is returned the message itself is invalid, but (other than false 285 * returned by ReceivedBytes) the transport is not in an inconsistent state. 286 */ 287 virtual CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) = 0; 288 289 // 2. Sending side functions, for converting messages into bytes to be sent over the wire. 290 291 /** Set the next message to send. 292 * 293 * If no message can currently be set (perhaps because the previous one is not yet done being 294 * sent), returns false, and msg will be unmodified. Otherwise msg is enqueued (and 295 * possibly moved-from) and true is returned. 296 */ 297 virtual bool SetMessageToSend(CSerializedNetMsg& msg) noexcept = 0; 298 299 /** Return type for GetBytesToSend, consisting of: 300 * - Span<const uint8_t> to_send: span of bytes to be sent over the wire (possibly empty). 301 * - bool more: whether there will be more bytes to be sent after the ones in to_send are 302 * all sent (as signaled by MarkBytesSent()). 303 * - const std::string& m_type: message type on behalf of which this is being sent 304 * ("" for bytes that are not on behalf of any message). 305 */ 306 using BytesToSend = std::tuple< 307 Span<const uint8_t> /*to_send*/, 308 bool /*more*/, 309 const std::string& /*m_type*/ 310 >; 311 312 /** Get bytes to send on the wire, if any, along with other information about it. 313 * 314 * As a const function, it does not modify the transport's observable state, and is thus safe 315 * to be called multiple times. 316 * 317 * @param[in] have_next_message If true, the "more" return value reports whether more will 318 * be sendable after a SetMessageToSend call. It is set by the caller when they know 319 * they have another message ready to send, and only care about what happens 320 * after that. The have_next_message argument only affects this "more" return value 321 * and nothing else. 322 * 323 * Effectively, there are three possible outcomes about whether there are more bytes 324 * to send: 325 * - Yes: the transport itself has more bytes to send later. For example, for 326 * V1Transport this happens during the sending of the header of a 327 * message, when there is a non-empty payload that follows. 328 * - No: the transport itself has no more bytes to send, but will have bytes to 329 * send if handed a message through SetMessageToSend. In V1Transport this 330 * happens when sending the payload of a message. 331 * - Blocked: the transport itself has no more bytes to send, and is also incapable 332 * of sending anything more at all now, if it were handed another 333 * message to send. This occurs in V2Transport before the handshake is 334 * complete, as the encryption ciphers are not set up for sending 335 * messages before that point. 336 * 337 * The boolean 'more' is true for Yes, false for Blocked, and have_next_message 338 * controls what is returned for No. 339 * 340 * @return a BytesToSend object. The to_send member returned acts as a stream which is only 341 * ever appended to. This means that with the exception of MarkBytesSent (which pops 342 * bytes off the front of later to_sends), operations on the transport can only append 343 * to what is being returned. Also note that m_type and to_send refer to data that is 344 * internal to the transport, and calling any non-const function on this object may 345 * invalidate them. 346 */ 347 virtual BytesToSend GetBytesToSend(bool have_next_message) const noexcept = 0; 348 349 /** Report how many bytes returned by the last GetBytesToSend() have been sent. 350 * 351 * bytes_sent cannot exceed to_send.size() of the last GetBytesToSend() result. 352 * 353 * If bytes_sent=0, this call has no effect. 354 */ 355 virtual void MarkBytesSent(size_t bytes_sent) noexcept = 0; 356 357 /** Return the memory usage of this transport attributable to buffered data to send. */ 358 virtual size_t GetSendMemoryUsage() const noexcept = 0; 359 360 // 3. Miscellaneous functions. 361 362 /** Whether upon disconnections, a reconnect with V1 is warranted. */ 363 virtual bool ShouldReconnectV1() const noexcept = 0; 364 }; 365 366 class V1Transport final : public Transport 367 { 368 private: 369 const MessageStartChars m_magic_bytes; 370 const NodeId m_node_id; // Only for logging 371 mutable Mutex m_recv_mutex; //!< Lock for receive state 372 mutable CHash256 hasher GUARDED_BY(m_recv_mutex); 373 mutable uint256 data_hash GUARDED_BY(m_recv_mutex); 374 bool in_data GUARDED_BY(m_recv_mutex); // parsing header (false) or data (true) 375 DataStream hdrbuf GUARDED_BY(m_recv_mutex){}; // partially received header 376 CMessageHeader hdr GUARDED_BY(m_recv_mutex); // complete header 377 DataStream vRecv GUARDED_BY(m_recv_mutex){}; // received message data 378 unsigned int nHdrPos GUARDED_BY(m_recv_mutex); 379 unsigned int nDataPos GUARDED_BY(m_recv_mutex); 380 381 const uint256& GetMessageHash() const EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex); 382 int readHeader(Span<const uint8_t> msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex); 383 int readData(Span<const uint8_t> msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex); 384 385 void Reset() EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex) { 386 AssertLockHeld(m_recv_mutex); 387 vRecv.clear(); 388 hdrbuf.clear(); 389 hdrbuf.resize(24); 390 in_data = false; 391 nHdrPos = 0; 392 nDataPos = 0; 393 data_hash.SetNull(); 394 hasher.Reset(); 395 } 396 397 bool CompleteInternal() const noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex) 398 { 399 AssertLockHeld(m_recv_mutex); 400 if (!in_data) return false; 401 return hdr.nMessageSize == nDataPos; 402 } 403 404 /** Lock for sending state. */ 405 mutable Mutex m_send_mutex; 406 /** The header of the message currently being sent. */ 407 std::vector<uint8_t> m_header_to_send GUARDED_BY(m_send_mutex); 408 /** The data of the message currently being sent. */ 409 CSerializedNetMsg m_message_to_send GUARDED_BY(m_send_mutex); 410 /** Whether we're currently sending header bytes or message bytes. */ 411 bool m_sending_header GUARDED_BY(m_send_mutex) {false}; 412 /** How many bytes have been sent so far (from m_header_to_send, or from m_message_to_send.data). */ 413 size_t m_bytes_sent GUARDED_BY(m_send_mutex) {0}; 414 415 public: 416 explicit V1Transport(const NodeId node_id) noexcept; 417 418 bool ReceivedMessageComplete() const override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex) 419 { 420 AssertLockNotHeld(m_recv_mutex); 421 return WITH_LOCK(m_recv_mutex, return CompleteInternal()); 422 } 423 424 Info GetInfo() const noexcept override; 425 426 bool ReceivedBytes(Span<const uint8_t>& msg_bytes) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex) 427 { 428 AssertLockNotHeld(m_recv_mutex); 429 LOCK(m_recv_mutex); 430 int ret = in_data ? readData(msg_bytes) : readHeader(msg_bytes); 431 if (ret < 0) { 432 Reset(); 433 } else { 434 msg_bytes = msg_bytes.subspan(ret); 435 } 436 return ret >= 0; 437 } 438 439 CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex); 440 441 bool SetMessageToSend(CSerializedNetMsg& msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 442 BytesToSend GetBytesToSend(bool have_next_message) const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 443 void MarkBytesSent(size_t bytes_sent) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 444 size_t GetSendMemoryUsage() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 445 bool ShouldReconnectV1() const noexcept override { return false; } 446 }; 447 448 class V2Transport final : public Transport 449 { 450 private: 451 /** Contents of the version packet to send. BIP324 stipulates that senders should leave this 452 * empty, and receivers should ignore it. Future extensions can change what is sent as long as 453 * an empty version packet contents is interpreted as no extensions supported. */ 454 static constexpr std::array<std::byte, 0> VERSION_CONTENTS = {}; 455 456 /** The length of the V1 prefix to match bytes initially received by responders with to 457 * determine if their peer is speaking V1 or V2. */ 458 static constexpr size_t V1_PREFIX_LEN = 16; 459 460 // The sender side and receiver side of V2Transport are state machines that are transitioned 461 // through, based on what has been received. The receive state corresponds to the contents of, 462 // and bytes received to, the receive buffer. The send state controls what can be appended to 463 // the send buffer and what can be sent from it. 464 465 /** State type that defines the current contents of the receive buffer and/or how the next 466 * received bytes added to it will be interpreted. 467 * 468 * Diagram: 469 * 470 * start(responder) 471 * | 472 * | start(initiator) /---------\ 473 * | | | | 474 * v v v | 475 * KEY_MAYBE_V1 -> KEY -> GARB_GARBTERM -> VERSION -> APP -> APP_READY 476 * | 477 * \-------> V1 478 */ 479 enum class RecvState : uint8_t { 480 /** (Responder only) either v2 public key or v1 header. 481 * 482 * This is the initial state for responders, before data has been received to distinguish 483 * v1 from v2 connections. When that happens, the state becomes either KEY (for v2) or V1 484 * (for v1). */ 485 KEY_MAYBE_V1, 486 487 /** Public key. 488 * 489 * This is the initial state for initiators, during which the other side's public key is 490 * received. When that information arrives, the ciphers get initialized and the state 491 * becomes GARB_GARBTERM. */ 492 KEY, 493 494 /** Garbage and garbage terminator. 495 * 496 * Whenever a byte is received, the last 16 bytes are compared with the expected garbage 497 * terminator. When that happens, the state becomes VERSION. If no matching terminator is 498 * received in 4111 bytes (4095 for the maximum garbage length, and 16 bytes for the 499 * terminator), the connection aborts. */ 500 GARB_GARBTERM, 501 502 /** Version packet. 503 * 504 * A packet is received, and decrypted/verified. If that fails, the connection aborts. The 505 * first received packet in this state (whether it's a decoy or not) is expected to 506 * authenticate the garbage received during the GARB_GARBTERM state as associated 507 * authenticated data (AAD). The first non-decoy packet in this state is interpreted as 508 * version negotiation (currently, that means ignoring the contents, but it can be used for 509 * negotiating future extensions), and afterwards the state becomes APP. */ 510 VERSION, 511 512 /** Application packet. 513 * 514 * A packet is received, and decrypted/verified. If that succeeds, the state becomes 515 * APP_READY and the decrypted contents is kept in m_recv_decode_buffer until it is 516 * retrieved as a message by GetMessage(). */ 517 APP, 518 519 /** Nothing (an application packet is available for GetMessage()). 520 * 521 * Nothing can be received in this state. When the message is retrieved by GetMessage, 522 * the state becomes APP again. */ 523 APP_READY, 524 525 /** Nothing (this transport is using v1 fallback). 526 * 527 * All receive operations are redirected to m_v1_fallback. */ 528 V1, 529 }; 530 531 /** State type that controls the sender side. 532 * 533 * Diagram: 534 * 535 * start(responder) 536 * | 537 * | start(initiator) 538 * | | 539 * v v 540 * MAYBE_V1 -> AWAITING_KEY -> READY 541 * | 542 * \-----> V1 543 */ 544 enum class SendState : uint8_t { 545 /** (Responder only) Not sending until v1 or v2 is detected. 546 * 547 * This is the initial state for responders. The send buffer is empty. 548 * When the receiver determines whether this 549 * is a V1 or V2 connection, the sender state becomes AWAITING_KEY (for v2) or V1 (for v1). 550 */ 551 MAYBE_V1, 552 553 /** Waiting for the other side's public key. 554 * 555 * This is the initial state for initiators. The public key and garbage is sent out. When 556 * the receiver receives the other side's public key and transitions to GARB_GARBTERM, the 557 * sender state becomes READY. */ 558 AWAITING_KEY, 559 560 /** Normal sending state. 561 * 562 * In this state, the ciphers are initialized, so packets can be sent. When this state is 563 * entered, the garbage terminator and version packet are appended to the send buffer (in 564 * addition to the key and garbage which may still be there). In this state a message can be 565 * provided if the send buffer is empty. */ 566 READY, 567 568 /** This transport is using v1 fallback. 569 * 570 * All send operations are redirected to m_v1_fallback. */ 571 V1, 572 }; 573 574 /** Cipher state. */ 575 BIP324Cipher m_cipher; 576 /** Whether we are the initiator side. */ 577 const bool m_initiating; 578 /** NodeId (for debug logging). */ 579 const NodeId m_nodeid; 580 /** Encapsulate a V1Transport to fall back to. */ 581 V1Transport m_v1_fallback; 582 583 /** Lock for receiver-side fields. */ 584 mutable Mutex m_recv_mutex ACQUIRED_BEFORE(m_send_mutex); 585 /** In {VERSION, APP}, the decrypted packet length, if m_recv_buffer.size() >= 586 * BIP324Cipher::LENGTH_LEN. Unspecified otherwise. */ 587 uint32_t m_recv_len GUARDED_BY(m_recv_mutex) {0}; 588 /** Receive buffer; meaning is determined by m_recv_state. */ 589 std::vector<uint8_t> m_recv_buffer GUARDED_BY(m_recv_mutex); 590 /** AAD expected in next received packet (currently used only for garbage). */ 591 std::vector<uint8_t> m_recv_aad GUARDED_BY(m_recv_mutex); 592 /** Buffer to put decrypted contents in, for converting to CNetMessage. */ 593 std::vector<uint8_t> m_recv_decode_buffer GUARDED_BY(m_recv_mutex); 594 /** Current receiver state. */ 595 RecvState m_recv_state GUARDED_BY(m_recv_mutex); 596 597 /** Lock for sending-side fields. If both sending and receiving fields are accessed, 598 * m_recv_mutex must be acquired before m_send_mutex. */ 599 mutable Mutex m_send_mutex ACQUIRED_AFTER(m_recv_mutex); 600 /** The send buffer; meaning is determined by m_send_state. */ 601 std::vector<uint8_t> m_send_buffer GUARDED_BY(m_send_mutex); 602 /** How many bytes from the send buffer have been sent so far. */ 603 uint32_t m_send_pos GUARDED_BY(m_send_mutex) {0}; 604 /** The garbage sent, or to be sent (MAYBE_V1 and AWAITING_KEY state only). */ 605 std::vector<uint8_t> m_send_garbage GUARDED_BY(m_send_mutex); 606 /** Type of the message being sent. */ 607 std::string m_send_type GUARDED_BY(m_send_mutex); 608 /** Current sender state. */ 609 SendState m_send_state GUARDED_BY(m_send_mutex); 610 /** Whether we've sent at least 24 bytes (which would trigger disconnect for V1 peers). */ 611 bool m_sent_v1_header_worth GUARDED_BY(m_send_mutex) {false}; 612 613 /** Change the receive state. */ 614 void SetReceiveState(RecvState recv_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex); 615 /** Change the send state. */ 616 void SetSendState(SendState send_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex); 617 /** Given a packet's contents, find the message type (if valid), and strip it from contents. */ 618 static std::optional<std::string> GetMessageType(Span<const uint8_t>& contents) noexcept; 619 /** Determine how many received bytes can be processed in one go (not allowed in V1 state). */ 620 size_t GetMaxBytesToProcess() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex); 621 /** Put our public key + garbage in the send buffer. */ 622 void StartSendingHandshake() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex); 623 /** Process bytes in m_recv_buffer, while in KEY_MAYBE_V1 state. */ 624 void ProcessReceivedMaybeV1Bytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex); 625 /** Process bytes in m_recv_buffer, while in KEY state. */ 626 bool ProcessReceivedKeyBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex); 627 /** Process bytes in m_recv_buffer, while in GARB_GARBTERM state. */ 628 bool ProcessReceivedGarbageBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex); 629 /** Process bytes in m_recv_buffer, while in VERSION/APP state. */ 630 bool ProcessReceivedPacketBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex); 631 632 public: 633 static constexpr uint32_t MAX_GARBAGE_LEN = 4095; 634 635 /** Construct a V2 transport with securely generated random keys. 636 * 637 * @param[in] nodeid the node's NodeId (only for debug log output). 638 * @param[in] initiating whether we are the initiator side. 639 */ 640 V2Transport(NodeId nodeid, bool initiating) noexcept; 641 642 /** Construct a V2 transport with specified keys and garbage (test use only). */ 643 V2Transport(NodeId nodeid, bool initiating, const CKey& key, Span<const std::byte> ent32, std::vector<uint8_t> garbage) noexcept; 644 645 // Receive side functions. 646 bool ReceivedMessageComplete() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex); 647 bool ReceivedBytes(Span<const uint8_t>& msg_bytes) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex, !m_send_mutex); 648 CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex); 649 650 // Send side functions. 651 bool SetMessageToSend(CSerializedNetMsg& msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 652 BytesToSend GetBytesToSend(bool have_next_message) const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 653 void MarkBytesSent(size_t bytes_sent) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 654 size_t GetSendMemoryUsage() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex); 655 656 // Miscellaneous functions. 657 bool ShouldReconnectV1() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex, !m_send_mutex); 658 Info GetInfo() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex); 659 }; 660 661 struct CNodeOptions 662 { 663 NetPermissionFlags permission_flags = NetPermissionFlags::None; 664 std::unique_ptr<i2p::sam::Session> i2p_sam_session = nullptr; 665 bool prefer_evict = false; 666 size_t recv_flood_size{DEFAULT_MAXRECEIVEBUFFER * 1000}; 667 bool use_v2transport = false; 668 }; 669 670 /** Information about a peer */ 671 class CNode 672 { 673 public: 674 /** Transport serializer/deserializer. The receive side functions are only called under cs_vRecv, while 675 * the sending side functions are only called under cs_vSend. */ 676 const std::unique_ptr<Transport> m_transport; 677 678 const NetPermissionFlags m_permission_flags; 679 680 /** 681 * Socket used for communication with the node. 682 * May not own a Sock object (after `CloseSocketDisconnect()` or during tests). 683 * `shared_ptr` (instead of `unique_ptr`) is used to avoid premature close of 684 * the underlying file descriptor by one thread while another thread is 685 * poll(2)-ing it for activity. 686 * @see https://github.com/bitcoin/bitcoin/issues/21744 for details. 687 */ 688 std::shared_ptr<Sock> m_sock GUARDED_BY(m_sock_mutex); 689 690 /** Sum of GetMemoryUsage of all vSendMsg entries. */ 691 size_t m_send_memusage GUARDED_BY(cs_vSend){0}; 692 /** Total number of bytes sent on the wire to this peer. */ 693 uint64_t nSendBytes GUARDED_BY(cs_vSend){0}; 694 /** Messages still to be fed to m_transport->SetMessageToSend. */ 695 std::deque<CSerializedNetMsg> vSendMsg GUARDED_BY(cs_vSend); 696 Mutex cs_vSend; 697 Mutex m_sock_mutex; 698 Mutex cs_vRecv; 699 700 uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0}; 701 702 std::atomic<std::chrono::seconds> m_last_send{0s}; 703 std::atomic<std::chrono::seconds> m_last_recv{0s}; 704 //! Unix epoch time at peer connection 705 const std::chrono::seconds m_connected; 706 std::atomic<int64_t> nTimeOffset{0}; 707 // Address of this peer 708 const CAddress addr; 709 // Bind address of our side of the connection 710 const CAddress addrBind; 711 const std::string m_addr_name; 712 /** The pszDest argument provided to ConnectNode(). Only used for reconnections. */ 713 const std::string m_dest; 714 //! Whether this peer is an inbound onion, i.e. connected via our Tor onion service. 715 const bool m_inbound_onion; 716 std::atomic<int> nVersion{0}; 717 Mutex m_subver_mutex; 718 /** 719 * cleanSubVer is a sanitized string of the user agent byte array we read 720 * from the wire. This cleaned string can safely be logged or displayed. 721 */ 722 std::string cleanSubVer GUARDED_BY(m_subver_mutex){}; 723 const bool m_prefer_evict{false}; // This peer is preferred for eviction. 724 bool HasPermission(NetPermissionFlags permission) const { 725 return NetPermissions::HasFlag(m_permission_flags, permission); 726 } 727 /** fSuccessfullyConnected is set to true on receiving VERACK from the peer. */ 728 std::atomic_bool fSuccessfullyConnected{false}; 729 // Setting fDisconnect to true will cause the node to be disconnected the 730 // next time DisconnectNodes() runs 731 std::atomic_bool fDisconnect{false}; 732 CSemaphoreGrant grantOutbound; 733 std::atomic<int> nRefCount{0}; 734 735 const uint64_t nKeyedNetGroup; 736 std::atomic_bool fPauseRecv{false}; 737 std::atomic_bool fPauseSend{false}; 738 739 const ConnectionType m_conn_type; 740 741 /** Move all messages from the received queue to the processing queue. */ 742 void MarkReceivedMsgsForProcessing() 743 EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex); 744 745 /** Poll the next message from the processing queue of this connection. 746 * 747 * Returns std::nullopt if the processing queue is empty, or a pair 748 * consisting of the message and a bool that indicates if the processing 749 * queue has more entries. */ 750 std::optional<std::pair<CNetMessage, bool>> PollMessage() 751 EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex); 752 753 /** Account for the total size of a sent message in the per msg type connection stats. */ 754 void AccountForSentBytes(const std::string& msg_type, size_t sent_bytes) 755 EXCLUSIVE_LOCKS_REQUIRED(cs_vSend) 756 { 757 mapSendBytesPerMsgType[msg_type] += sent_bytes; 758 } 759 760 bool IsOutboundOrBlockRelayConn() const { 761 switch (m_conn_type) { 762 case ConnectionType::OUTBOUND_FULL_RELAY: 763 case ConnectionType::BLOCK_RELAY: 764 return true; 765 case ConnectionType::INBOUND: 766 case ConnectionType::MANUAL: 767 case ConnectionType::ADDR_FETCH: 768 case ConnectionType::FEELER: 769 return false; 770 } // no default case, so the compiler can warn about missing cases 771 772 assert(false); 773 } 774 775 bool IsFullOutboundConn() const { 776 return m_conn_type == ConnectionType::OUTBOUND_FULL_RELAY; 777 } 778 779 bool IsManualConn() const { 780 return m_conn_type == ConnectionType::MANUAL; 781 } 782 783 bool IsManualOrFullOutboundConn() const 784 { 785 switch (m_conn_type) { 786 case ConnectionType::INBOUND: 787 case ConnectionType::FEELER: 788 case ConnectionType::BLOCK_RELAY: 789 case ConnectionType::ADDR_FETCH: 790 return false; 791 case ConnectionType::OUTBOUND_FULL_RELAY: 792 case ConnectionType::MANUAL: 793 return true; 794 } // no default case, so the compiler can warn about missing cases 795 796 assert(false); 797 } 798 799 bool IsBlockOnlyConn() const { 800 return m_conn_type == ConnectionType::BLOCK_RELAY; 801 } 802 803 bool IsFeelerConn() const { 804 return m_conn_type == ConnectionType::FEELER; 805 } 806 807 bool IsAddrFetchConn() const { 808 return m_conn_type == ConnectionType::ADDR_FETCH; 809 } 810 811 bool IsInboundConn() const { 812 return m_conn_type == ConnectionType::INBOUND; 813 } 814 815 bool ExpectServicesFromConn() const { 816 switch (m_conn_type) { 817 case ConnectionType::INBOUND: 818 case ConnectionType::MANUAL: 819 case ConnectionType::FEELER: 820 return false; 821 case ConnectionType::OUTBOUND_FULL_RELAY: 822 case ConnectionType::BLOCK_RELAY: 823 case ConnectionType::ADDR_FETCH: 824 return true; 825 } // no default case, so the compiler can warn about missing cases 826 827 assert(false); 828 } 829 830 /** 831 * Get network the peer connected through. 832 * 833 * Returns Network::NET_ONION for *inbound* onion connections, 834 * and CNetAddr::GetNetClass() otherwise. The latter cannot be used directly 835 * because it doesn't detect the former, and it's not the responsibility of 836 * the CNetAddr class to know the actual network a peer is connected through. 837 * 838 * @return network the peer connected through. 839 */ 840 Network ConnectedThroughNetwork() const; 841 842 /** Whether this peer connected through a privacy network. */ 843 [[nodiscard]] bool IsConnectedThroughPrivacyNet() const; 844 845 // We selected peer as (compact blocks) high-bandwidth peer (BIP152) 846 std::atomic<bool> m_bip152_highbandwidth_to{false}; 847 // Peer selected us as (compact blocks) high-bandwidth peer (BIP152) 848 std::atomic<bool> m_bip152_highbandwidth_from{false}; 849 850 /** Whether this peer provides all services that we want. Used for eviction decisions */ 851 std::atomic_bool m_has_all_wanted_services{false}; 852 853 /** Whether we should relay transactions to this peer. This only changes 854 * from false to true. It will never change back to false. */ 855 std::atomic_bool m_relays_txs{false}; 856 857 /** Whether this peer has loaded a bloom filter. Used only in inbound 858 * eviction logic. */ 859 std::atomic_bool m_bloom_filter_loaded{false}; 860 861 /** UNIX epoch time of the last block received from this peer that we had 862 * not yet seen (e.g. not already received from another peer), that passed 863 * preliminary validity checks and was saved to disk, even if we don't 864 * connect the block or it eventually fails connection. Used as an inbound 865 * peer eviction criterium in CConnman::AttemptToEvictConnection. */ 866 std::atomic<std::chrono::seconds> m_last_block_time{0s}; 867 868 /** UNIX epoch time of the last transaction received from this peer that we 869 * had not yet seen (e.g. not already received from another peer) and that 870 * was accepted into our mempool. Used as an inbound peer eviction criterium 871 * in CConnman::AttemptToEvictConnection. */ 872 std::atomic<std::chrono::seconds> m_last_tx_time{0s}; 873 874 /** Last measured round-trip time. Used only for RPC/GUI stats/debugging.*/ 875 std::atomic<std::chrono::microseconds> m_last_ping_time{0us}; 876 877 /** Lowest measured round-trip time. Used as an inbound peer eviction 878 * criterium in CConnman::AttemptToEvictConnection. */ 879 std::atomic<std::chrono::microseconds> m_min_ping_time{std::chrono::microseconds::max()}; 880 881 CNode(NodeId id, 882 std::shared_ptr<Sock> sock, 883 const CAddress& addrIn, 884 uint64_t nKeyedNetGroupIn, 885 uint64_t nLocalHostNonceIn, 886 const CAddress& addrBindIn, 887 const std::string& addrNameIn, 888 ConnectionType conn_type_in, 889 bool inbound_onion, 890 CNodeOptions&& node_opts = {}); 891 CNode(const CNode&) = delete; 892 CNode& operator=(const CNode&) = delete; 893 894 NodeId GetId() const { 895 return id; 896 } 897 898 uint64_t GetLocalNonce() const { 899 return nLocalHostNonce; 900 } 901 902 int GetRefCount() const 903 { 904 assert(nRefCount >= 0); 905 return nRefCount; 906 } 907 908 /** 909 * Receive bytes from the buffer and deserialize them into messages. 910 * 911 * @param[in] msg_bytes The raw data 912 * @param[out] complete Set True if at least one message has been 913 * deserialized and is ready to be processed 914 * @return True if the peer should stay connected, 915 * False if the peer should be disconnected from. 916 */ 917 bool ReceiveMsgBytes(Span<const uint8_t> msg_bytes, bool& complete) EXCLUSIVE_LOCKS_REQUIRED(!cs_vRecv); 918 919 void SetCommonVersion(int greatest_common_version) 920 { 921 Assume(m_greatest_common_version == INIT_PROTO_VERSION); 922 m_greatest_common_version = greatest_common_version; 923 } 924 int GetCommonVersion() const 925 { 926 return m_greatest_common_version; 927 } 928 929 CService GetAddrLocal() const EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex); 930 //! May not be called more than once 931 void SetAddrLocal(const CService& addrLocalIn) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex); 932 933 CNode* AddRef() 934 { 935 nRefCount++; 936 return this; 937 } 938 939 void Release() 940 { 941 nRefCount--; 942 } 943 944 void CloseSocketDisconnect() EXCLUSIVE_LOCKS_REQUIRED(!m_sock_mutex); 945 946 void CopyStats(CNodeStats& stats) EXCLUSIVE_LOCKS_REQUIRED(!m_subver_mutex, !m_addr_local_mutex, !cs_vSend, !cs_vRecv); 947 948 std::string ConnectionTypeAsString() const { return ::ConnectionTypeAsString(m_conn_type); } 949 950 /** A ping-pong round trip has completed successfully. Update latest and minimum ping times. */ 951 void PongReceived(std::chrono::microseconds ping_time) { 952 m_last_ping_time = ping_time; 953 m_min_ping_time = std::min(m_min_ping_time.load(), ping_time); 954 } 955 956 private: 957 const NodeId id; 958 const uint64_t nLocalHostNonce; 959 std::atomic<int> m_greatest_common_version{INIT_PROTO_VERSION}; 960 961 const size_t m_recv_flood_size; 962 std::list<CNetMessage> vRecvMsg; // Used only by SocketHandler thread 963 964 Mutex m_msg_process_queue_mutex; 965 std::list<CNetMessage> m_msg_process_queue GUARDED_BY(m_msg_process_queue_mutex); 966 size_t m_msg_process_queue_size GUARDED_BY(m_msg_process_queue_mutex){0}; 967 968 // Our address, as reported by the peer 969 CService addrLocal GUARDED_BY(m_addr_local_mutex); 970 mutable Mutex m_addr_local_mutex; 971 972 mapMsgTypeSize mapSendBytesPerMsgType GUARDED_BY(cs_vSend); 973 mapMsgTypeSize mapRecvBytesPerMsgType GUARDED_BY(cs_vRecv); 974 975 /** 976 * If an I2P session is created per connection (for outbound transient I2P 977 * connections) then it is stored here so that it can be destroyed when the 978 * socket is closed. I2P sessions involve a data/transport socket (in `m_sock`) 979 * and a control socket (in `m_i2p_sam_session`). For transient sessions, once 980 * the data socket is closed, the control socket is not going to be used anymore 981 * and is just taking up resources. So better close it as soon as `m_sock` is 982 * closed. 983 * Otherwise this unique_ptr is empty. 984 */ 985 std::unique_ptr<i2p::sam::Session> m_i2p_sam_session GUARDED_BY(m_sock_mutex); 986 }; 987 988 /** 989 * Interface for message handling 990 */ 991 class NetEventsInterface 992 { 993 public: 994 /** Mutex for anything that is only accessed via the msg processing thread */ 995 static Mutex g_msgproc_mutex; 996 997 /** Initialize a peer (setup state, queue any initial messages) */ 998 virtual void InitializeNode(CNode& node, ServiceFlags our_services) = 0; 999 1000 /** Handle removal of a peer (clear state) */ 1001 virtual void FinalizeNode(const CNode& node) = 0; 1002 1003 /** 1004 * Callback to determine whether the given set of service flags are sufficient 1005 * for a peer to be "relevant". 1006 */ 1007 virtual bool HasAllDesirableServiceFlags(ServiceFlags services) const = 0; 1008 1009 /** 1010 * Process protocol messages received from a given node 1011 * 1012 * @param[in] pnode The node which we have received messages from. 1013 * @param[in] interrupt Interrupt condition for processing threads 1014 * @return True if there is more work to be done 1015 */ 1016 virtual bool ProcessMessages(CNode* pnode, std::atomic<bool>& interrupt) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0; 1017 1018 /** 1019 * Send queued protocol messages to a given node. 1020 * 1021 * @param[in] pnode The node which we are sending messages to. 1022 * @return True if there is more work to be done 1023 */ 1024 virtual bool SendMessages(CNode* pnode) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0; 1025 1026 1027 protected: 1028 /** 1029 * Protected destructor so that instances can only be deleted by derived classes. 1030 * If that restriction is no longer desired, this should be made public and virtual. 1031 */ 1032 ~NetEventsInterface() = default; 1033 }; 1034 1035 class CConnman 1036 { 1037 public: 1038 1039 struct Options 1040 { 1041 ServiceFlags nLocalServices = NODE_NONE; 1042 int m_max_automatic_connections = 0; 1043 CClientUIInterface* uiInterface = nullptr; 1044 NetEventsInterface* m_msgproc = nullptr; 1045 BanMan* m_banman = nullptr; 1046 unsigned int nSendBufferMaxSize = 0; 1047 unsigned int nReceiveFloodSize = 0; 1048 uint64_t nMaxOutboundLimit = 0; 1049 int64_t m_peer_connect_timeout = DEFAULT_PEER_CONNECT_TIMEOUT; 1050 std::vector<std::string> vSeedNodes; 1051 std::vector<NetWhitelistPermissions> vWhitelistedRangeIncoming; 1052 std::vector<NetWhitelistPermissions> vWhitelistedRangeOutgoing; 1053 std::vector<NetWhitebindPermissions> vWhiteBinds; 1054 std::vector<CService> vBinds; 1055 std::vector<CService> onion_binds; 1056 /// True if the user did not specify -bind= or -whitebind= and thus 1057 /// we should bind on `0.0.0.0` (IPv4) and `::` (IPv6). 1058 bool bind_on_any; 1059 bool m_use_addrman_outgoing = true; 1060 std::vector<std::string> m_specified_outgoing; 1061 std::vector<std::string> m_added_nodes; 1062 bool m_i2p_accept_incoming; 1063 bool whitelist_forcerelay = DEFAULT_WHITELISTFORCERELAY; 1064 bool whitelist_relay = DEFAULT_WHITELISTRELAY; 1065 }; 1066 1067 void Init(const Options& connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_total_bytes_sent_mutex) 1068 { 1069 AssertLockNotHeld(m_total_bytes_sent_mutex); 1070 1071 nLocalServices = connOptions.nLocalServices; 1072 m_max_automatic_connections = connOptions.m_max_automatic_connections; 1073 m_max_outbound_full_relay = std::min(MAX_OUTBOUND_FULL_RELAY_CONNECTIONS, m_max_automatic_connections); 1074 m_max_outbound_block_relay = std::min(MAX_BLOCK_RELAY_ONLY_CONNECTIONS, m_max_automatic_connections - m_max_outbound_full_relay); 1075 m_max_automatic_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + m_max_feeler; 1076 m_max_inbound = std::max(0, m_max_automatic_connections - m_max_automatic_outbound); 1077 m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing; 1078 m_client_interface = connOptions.uiInterface; 1079 m_banman = connOptions.m_banman; 1080 m_msgproc = connOptions.m_msgproc; 1081 nSendBufferMaxSize = connOptions.nSendBufferMaxSize; 1082 nReceiveFloodSize = connOptions.nReceiveFloodSize; 1083 m_peer_connect_timeout = std::chrono::seconds{connOptions.m_peer_connect_timeout}; 1084 { 1085 LOCK(m_total_bytes_sent_mutex); 1086 nMaxOutboundLimit = connOptions.nMaxOutboundLimit; 1087 } 1088 vWhitelistedRangeIncoming = connOptions.vWhitelistedRangeIncoming; 1089 vWhitelistedRangeOutgoing = connOptions.vWhitelistedRangeOutgoing; 1090 { 1091 LOCK(m_added_nodes_mutex); 1092 // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our 1093 // peer doesn't support it or immediately disconnects us for another reason. 1094 const bool use_v2transport(GetLocalServices() & NODE_P2P_V2); 1095 for (const std::string& added_node : connOptions.m_added_nodes) { 1096 m_added_node_params.push_back({added_node, use_v2transport}); 1097 } 1098 } 1099 m_onion_binds = connOptions.onion_binds; 1100 whitelist_forcerelay = connOptions.whitelist_forcerelay; 1101 whitelist_relay = connOptions.whitelist_relay; 1102 } 1103 1104 CConnman(uint64_t seed0, uint64_t seed1, AddrMan& addrman, const NetGroupManager& netgroupman, 1105 const CChainParams& params, bool network_active = true); 1106 1107 ~CConnman(); 1108 1109 bool Start(CScheduler& scheduler, const Options& options) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !m_added_nodes_mutex, !m_addr_fetches_mutex, !mutexMsgProc); 1110 1111 void StopThreads(); 1112 void StopNodes(); 1113 void Stop() 1114 { 1115 StopThreads(); 1116 StopNodes(); 1117 }; 1118 1119 void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc); 1120 bool GetNetworkActive() const { return fNetworkActive; }; 1121 bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; }; 1122 void SetNetworkActive(bool active); 1123 void OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant&& grant_outbound, const char* strDest, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex); 1124 bool CheckIncomingNonce(uint64_t nonce); 1125 void ASMapHealthCheck(); 1126 1127 // alias for thread safety annotations only, not defined 1128 RecursiveMutex& GetNodesMutex() const LOCK_RETURNED(m_nodes_mutex); 1129 1130 bool ForNode(NodeId id, std::function<bool(CNode* pnode)> func); 1131 1132 void PushMessage(CNode* pnode, CSerializedNetMsg&& msg) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex); 1133 1134 using NodeFn = std::function<void(CNode*)>; 1135 void ForEachNode(const NodeFn& func) 1136 { 1137 LOCK(m_nodes_mutex); 1138 for (auto&& node : m_nodes) { 1139 if (NodeFullyConnected(node)) 1140 func(node); 1141 } 1142 }; 1143 1144 void ForEachNode(const NodeFn& func) const 1145 { 1146 LOCK(m_nodes_mutex); 1147 for (auto&& node : m_nodes) { 1148 if (NodeFullyConnected(node)) 1149 func(node); 1150 } 1151 }; 1152 1153 // Addrman functions 1154 /** 1155 * Return all or many randomly selected addresses, optionally by network. 1156 * 1157 * @param[in] max_addresses Maximum number of addresses to return (0 = all). 1158 * @param[in] max_pct Maximum percentage of addresses to return (0 = all). 1159 * @param[in] network Select only addresses of this network (nullopt = all). 1160 * @param[in] filtered Select only addresses that are considered high quality (false = all). 1161 */ 1162 std::vector<CAddress> GetAddresses(size_t max_addresses, size_t max_pct, std::optional<Network> network, const bool filtered = true) const; 1163 /** 1164 * Cache is used to minimize topology leaks, so it should 1165 * be used for all non-trusted calls, for example, p2p. 1166 * A non-malicious call (from RPC or a peer with addr permission) should 1167 * call the function without a parameter to avoid using the cache. 1168 */ 1169 std::vector<CAddress> GetAddresses(CNode& requestor, size_t max_addresses, size_t max_pct); 1170 1171 // This allows temporarily exceeding m_max_outbound_full_relay, with the goal of finding 1172 // a peer that is better than all our current peers. 1173 void SetTryNewOutboundPeer(bool flag); 1174 bool GetTryNewOutboundPeer() const; 1175 1176 void StartExtraBlockRelayPeers(); 1177 1178 // Return the number of outbound peers we have in excess of our target (eg, 1179 // if we previously called SetTryNewOutboundPeer(true), and have since set 1180 // to false, we may have extra peers that we wish to disconnect). This may 1181 // return a value less than (num_outbound_connections - num_outbound_slots) 1182 // in cases where some outbound connections are not yet fully connected, or 1183 // not yet fully disconnected. 1184 int GetExtraFullOutboundCount() const; 1185 // Count the number of block-relay-only peers we have over our limit. 1186 int GetExtraBlockRelayCount() const; 1187 1188 bool AddNode(const AddedNodeParams& add) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex); 1189 bool RemoveAddedNode(const std::string& node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex); 1190 bool AddedNodesContain(const CAddress& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex); 1191 std::vector<AddedNodeInfo> GetAddedNodeInfo(bool include_connected) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex); 1192 1193 /** 1194 * Attempts to open a connection. Currently only used from tests. 1195 * 1196 * @param[in] address Address of node to try connecting to 1197 * @param[in] conn_type ConnectionType::OUTBOUND, ConnectionType::BLOCK_RELAY, 1198 * ConnectionType::ADDR_FETCH or ConnectionType::FEELER 1199 * @param[in] use_v2transport Set to true if node attempts to connect using BIP 324 v2 transport protocol. 1200 * @return bool Returns false if there are no available 1201 * slots for this connection: 1202 * - conn_type not a supported ConnectionType 1203 * - Max total outbound connection capacity filled 1204 * - Max connection capacity for type is filled 1205 */ 1206 bool AddConnection(const std::string& address, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex); 1207 1208 size_t GetNodeCount(ConnectionDirection) const; 1209 uint32_t GetMappedAS(const CNetAddr& addr) const; 1210 void GetNodeStats(std::vector<CNodeStats>& vstats) const; 1211 bool DisconnectNode(const std::string& node); 1212 bool DisconnectNode(const CSubNet& subnet); 1213 bool DisconnectNode(const CNetAddr& addr); 1214 bool DisconnectNode(NodeId id); 1215 1216 //! Used to convey which local services we are offering peers during node 1217 //! connection. 1218 //! 1219 //! The data returned by this is used in CNode construction, 1220 //! which is used to advertise which services we are offering 1221 //! that peer during `net_processing.cpp:PushNodeVersion()`. 1222 ServiceFlags GetLocalServices() const; 1223 1224 uint64_t GetMaxOutboundTarget() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex); 1225 std::chrono::seconds GetMaxOutboundTimeframe() const; 1226 1227 //! check if the outbound target is reached 1228 //! if param historicalBlockServingLimit is set true, the function will 1229 //! response true if the limit for serving historical blocks has been reached 1230 bool OutboundTargetReached(bool historicalBlockServingLimit) const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex); 1231 1232 //! response the bytes left in the current max outbound cycle 1233 //! in case of no limit, it will always response 0 1234 uint64_t GetOutboundTargetBytesLeft() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex); 1235 1236 std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex); 1237 1238 uint64_t GetTotalBytesRecv() const; 1239 uint64_t GetTotalBytesSent() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex); 1240 1241 /** Get a unique deterministic randomizer. */ 1242 CSipHasher GetDeterministicRandomizer(uint64_t id) const; 1243 1244 void WakeMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc); 1245 1246 /** Return true if we should disconnect the peer for failing an inactivity check. */ 1247 bool ShouldRunInactivityChecks(const CNode& node, std::chrono::seconds now) const; 1248 1249 bool MultipleManualOrFullOutboundConns(Network net) const EXCLUSIVE_LOCKS_REQUIRED(m_nodes_mutex); 1250 1251 private: 1252 struct ListenSocket { 1253 public: 1254 std::shared_ptr<Sock> sock; 1255 inline void AddSocketPermissionFlags(NetPermissionFlags& flags) const { NetPermissions::AddFlag(flags, m_permissions); } 1256 ListenSocket(std::shared_ptr<Sock> sock_, NetPermissionFlags permissions_) 1257 : sock{sock_}, m_permissions{permissions_} 1258 { 1259 } 1260 1261 private: 1262 NetPermissionFlags m_permissions; 1263 }; 1264 1265 //! returns the time left in the current max outbound cycle 1266 //! in case of no limit, it will always return 0 1267 std::chrono::seconds GetMaxOutboundTimeLeftInCycle_() const EXCLUSIVE_LOCKS_REQUIRED(m_total_bytes_sent_mutex); 1268 1269 bool BindListenPort(const CService& bindAddr, bilingual_str& strError, NetPermissionFlags permissions); 1270 bool Bind(const CService& addr, unsigned int flags, NetPermissionFlags permissions); 1271 bool InitBinds(const Options& options); 1272 1273 void ThreadOpenAddedConnections() EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_unused_i2p_sessions_mutex, !m_reconnections_mutex); 1274 void AddAddrFetch(const std::string& strDest) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex); 1275 void ProcessAddrFetch() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_unused_i2p_sessions_mutex); 1276 void ThreadOpenConnections(std::vector<std::string> connect) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_added_nodes_mutex, !m_nodes_mutex, !m_unused_i2p_sessions_mutex, !m_reconnections_mutex); 1277 void ThreadMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc); 1278 void ThreadI2PAcceptIncoming(); 1279 void AcceptConnection(const ListenSocket& hListenSocket); 1280 1281 /** 1282 * Create a `CNode` object from a socket that has just been accepted and add the node to 1283 * the `m_nodes` member. 1284 * @param[in] sock Connected socket to communicate with the peer. 1285 * @param[in] permission_flags The peer's permissions. 1286 * @param[in] addr_bind The address and port at our side of the connection. 1287 * @param[in] addr The address and port at the peer's side of the connection. 1288 */ 1289 void CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock, 1290 NetPermissionFlags permission_flags, 1291 const CAddress& addr_bind, 1292 const CAddress& addr); 1293 1294 void DisconnectNodes() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex, !m_nodes_mutex); 1295 void NotifyNumConnectionsChanged(); 1296 /** Return true if the peer is inactive and should be disconnected. */ 1297 bool InactivityCheck(const CNode& node) const; 1298 1299 /** 1300 * Generate a collection of sockets to check for IO readiness. 1301 * @param[in] nodes Select from these nodes' sockets. 1302 * @return sockets to check for readiness 1303 */ 1304 Sock::EventsPerSock GenerateWaitSockets(Span<CNode* const> nodes); 1305 1306 /** 1307 * Check connected and listening sockets for IO readiness and process them accordingly. 1308 */ 1309 void SocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc); 1310 1311 /** 1312 * Do the read/write for connected sockets that are ready for IO. 1313 * @param[in] nodes Nodes to process. The socket of each node is checked against `what`. 1314 * @param[in] events_per_sock Sockets that are ready for IO. 1315 */ 1316 void SocketHandlerConnected(const std::vector<CNode*>& nodes, 1317 const Sock::EventsPerSock& events_per_sock) 1318 EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc); 1319 1320 /** 1321 * Accept incoming connections, one from each read-ready listening socket. 1322 * @param[in] events_per_sock Sockets that are ready for IO. 1323 */ 1324 void SocketHandlerListening(const Sock::EventsPerSock& events_per_sock); 1325 1326 void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc, !m_nodes_mutex, !m_reconnections_mutex); 1327 void ThreadDNSAddressSeed() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_nodes_mutex); 1328 1329 uint64_t CalculateKeyedNetGroup(const CAddress& ad) const; 1330 1331 CNode* FindNode(const CNetAddr& ip); 1332 CNode* FindNode(const std::string& addrName); 1333 CNode* FindNode(const CService& addr); 1334 1335 /** 1336 * Determine whether we're already connected to a given address, in order to 1337 * avoid initiating duplicate connections. 1338 */ 1339 bool AlreadyConnectedToAddress(const CAddress& addr); 1340 1341 bool AttemptToEvictConnection(); 1342 CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex); 1343 void AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr, const std::vector<NetWhitelistPermissions>& ranges) const; 1344 1345 void DeleteNode(CNode* pnode); 1346 1347 NodeId GetNewNodeId(); 1348 1349 /** (Try to) send data from node's vSendMsg. Returns (bytes_sent, data_left). */ 1350 std::pair<size_t, bool> SocketSendData(CNode& node) const EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend); 1351 1352 void DumpAddresses(); 1353 1354 // Network stats 1355 void RecordBytesRecv(uint64_t bytes); 1356 void RecordBytesSent(uint64_t bytes) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex); 1357 1358 /** 1359 Return reachable networks for which we have no addresses in addrman and therefore 1360 may require loading fixed seeds. 1361 */ 1362 std::unordered_set<Network> GetReachableEmptyNetworks() const; 1363 1364 /** 1365 * Return vector of current BLOCK_RELAY peers. 1366 */ 1367 std::vector<CAddress> GetCurrentBlockRelayOnlyConns() const; 1368 1369 /** 1370 * Search for a "preferred" network, a reachable network to which we 1371 * currently don't have any OUTBOUND_FULL_RELAY or MANUAL connections. 1372 * There needs to be at least one address in AddrMan for a preferred 1373 * network to be picked. 1374 * 1375 * @param[out] network Preferred network, if found. 1376 * 1377 * @return bool Whether a preferred network was found. 1378 */ 1379 bool MaybePickPreferredNetwork(std::optional<Network>& network); 1380 1381 // Whether the node should be passed out in ForEach* callbacks 1382 static bool NodeFullyConnected(const CNode* pnode); 1383 1384 uint16_t GetDefaultPort(Network net) const; 1385 uint16_t GetDefaultPort(const std::string& addr) const; 1386 1387 // Network usage totals 1388 mutable Mutex m_total_bytes_sent_mutex; 1389 std::atomic<uint64_t> nTotalBytesRecv{0}; 1390 uint64_t nTotalBytesSent GUARDED_BY(m_total_bytes_sent_mutex) {0}; 1391 1392 // outbound limit & stats 1393 uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(m_total_bytes_sent_mutex) {0}; 1394 std::chrono::seconds nMaxOutboundCycleStartTime GUARDED_BY(m_total_bytes_sent_mutex) {0}; 1395 uint64_t nMaxOutboundLimit GUARDED_BY(m_total_bytes_sent_mutex); 1396 1397 // P2P timeout in seconds 1398 std::chrono::seconds m_peer_connect_timeout; 1399 1400 // Whitelisted ranges. Any node connecting from these is automatically 1401 // whitelisted (as well as those connecting to whitelisted binds). 1402 std::vector<NetWhitelistPermissions> vWhitelistedRangeIncoming; 1403 // Whitelisted ranges for outgoing connections. 1404 std::vector<NetWhitelistPermissions> vWhitelistedRangeOutgoing; 1405 1406 unsigned int nSendBufferMaxSize{0}; 1407 unsigned int nReceiveFloodSize{0}; 1408 1409 std::vector<ListenSocket> vhListenSocket; 1410 std::atomic<bool> fNetworkActive{true}; 1411 bool fAddressesInitialized{false}; 1412 AddrMan& addrman; 1413 const NetGroupManager& m_netgroupman; 1414 std::deque<std::string> m_addr_fetches GUARDED_BY(m_addr_fetches_mutex); 1415 Mutex m_addr_fetches_mutex; 1416 1417 // connection string and whether to use v2 p2p 1418 std::vector<AddedNodeParams> m_added_node_params GUARDED_BY(m_added_nodes_mutex); 1419 1420 mutable Mutex m_added_nodes_mutex; 1421 std::vector<CNode*> m_nodes GUARDED_BY(m_nodes_mutex); 1422 std::list<CNode*> m_nodes_disconnected; 1423 mutable RecursiveMutex m_nodes_mutex; 1424 std::atomic<NodeId> nLastNodeId{0}; 1425 unsigned int nPrevNodeCount{0}; 1426 1427 // Stores number of full-tx connections (outbound and manual) per network 1428 std::array<unsigned int, Network::NET_MAX> m_network_conn_counts GUARDED_BY(m_nodes_mutex) = {}; 1429 1430 /** 1431 * Cache responses to addr requests to minimize privacy leak. 1432 * Attack example: scraping addrs in real-time may allow an attacker 1433 * to infer new connections of the victim by detecting new records 1434 * with fresh timestamps (per self-announcement). 1435 */ 1436 struct CachedAddrResponse { 1437 std::vector<CAddress> m_addrs_response_cache; 1438 std::chrono::microseconds m_cache_entry_expiration{0}; 1439 }; 1440 1441 /** 1442 * Addr responses stored in different caches 1443 * per (network, local socket) prevent cross-network node identification. 1444 * If a node for example is multi-homed under Tor and IPv6, 1445 * a single cache (or no cache at all) would let an attacker 1446 * to easily detect that it is the same node by comparing responses. 1447 * Indexing by local socket prevents leakage when a node has multiple 1448 * listening addresses on the same network. 1449 * 1450 * The used memory equals to 1000 CAddress records (or around 40 bytes) per 1451 * distinct Network (up to 5) we have/had an inbound peer from, 1452 * resulting in at most ~196 KB. Every separate local socket may 1453 * add up to ~196 KB extra. 1454 */ 1455 std::map<uint64_t, CachedAddrResponse> m_addr_response_caches; 1456 1457 /** 1458 * Services this node offers. 1459 * 1460 * This data is replicated in each Peer instance we create. 1461 * 1462 * This data is not marked const, but after being set it should not 1463 * change. 1464 * 1465 * \sa Peer::our_services 1466 */ 1467 ServiceFlags nLocalServices; 1468 1469 std::unique_ptr<CSemaphore> semOutbound; 1470 std::unique_ptr<CSemaphore> semAddnode; 1471 1472 /** 1473 * Maximum number of automatic connections permitted, excluding manual 1474 * connections but including inbounds. May be changed by the user and is 1475 * potentially limited by the operating system (number of file descriptors). 1476 */ 1477 int m_max_automatic_connections; 1478 1479 /* 1480 * Maximum number of peers by connection type. Might vary from defaults 1481 * based on -maxconnections init value. 1482 */ 1483 1484 // How many full-relay (tx, block, addr) outbound peers we want 1485 int m_max_outbound_full_relay; 1486 1487 // How many block-relay only outbound peers we want 1488 // We do not relay tx or addr messages with these peers 1489 int m_max_outbound_block_relay; 1490 1491 int m_max_addnode{MAX_ADDNODE_CONNECTIONS}; 1492 int m_max_feeler{MAX_FEELER_CONNECTIONS}; 1493 int m_max_automatic_outbound; 1494 int m_max_inbound; 1495 1496 bool m_use_addrman_outgoing; 1497 CClientUIInterface* m_client_interface; 1498 NetEventsInterface* m_msgproc; 1499 /** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */ 1500 BanMan* m_banman; 1501 1502 /** 1503 * Addresses that were saved during the previous clean shutdown. We'll 1504 * attempt to make block-relay-only connections to them. 1505 */ 1506 std::vector<CAddress> m_anchors; 1507 1508 /** SipHasher seeds for deterministic randomness */ 1509 const uint64_t nSeed0, nSeed1; 1510 1511 /** flag for waking the message processor. */ 1512 bool fMsgProcWake GUARDED_BY(mutexMsgProc); 1513 1514 std::condition_variable condMsgProc; 1515 Mutex mutexMsgProc; 1516 std::atomic<bool> flagInterruptMsgProc{false}; 1517 1518 /** 1519 * This is signaled when network activity should cease. 1520 * A pointer to it is saved in `m_i2p_sam_session`, so make sure that 1521 * the lifetime of `interruptNet` is not shorter than 1522 * the lifetime of `m_i2p_sam_session`. 1523 */ 1524 CThreadInterrupt interruptNet; 1525 1526 /** 1527 * I2P SAM session. 1528 * Used to accept incoming and make outgoing I2P connections from a persistent 1529 * address. 1530 */ 1531 std::unique_ptr<i2p::sam::Session> m_i2p_sam_session; 1532 1533 std::thread threadDNSAddressSeed; 1534 std::thread threadSocketHandler; 1535 std::thread threadOpenAddedConnections; 1536 std::thread threadOpenConnections; 1537 std::thread threadMessageHandler; 1538 std::thread threadI2PAcceptIncoming; 1539 1540 /** flag for deciding to connect to an extra outbound peer, 1541 * in excess of m_max_outbound_full_relay 1542 * This takes the place of a feeler connection */ 1543 std::atomic_bool m_try_another_outbound_peer; 1544 1545 /** flag for initiating extra block-relay-only peer connections. 1546 * this should only be enabled after initial chain sync has occurred, 1547 * as these connections are intended to be short-lived and low-bandwidth. 1548 */ 1549 std::atomic_bool m_start_extra_block_relay_peers{false}; 1550 1551 /** 1552 * A vector of -bind=<address>:<port>=onion arguments each of which is 1553 * an address and port that are designated for incoming Tor connections. 1554 */ 1555 std::vector<CService> m_onion_binds; 1556 1557 /** 1558 * flag for adding 'forcerelay' permission to whitelisted inbound 1559 * and manual peers with default permissions. 1560 */ 1561 bool whitelist_forcerelay; 1562 1563 /** 1564 * flag for adding 'relay' permission to whitelisted inbound 1565 * and manual peers with default permissions. 1566 */ 1567 bool whitelist_relay; 1568 1569 /** 1570 * Mutex protecting m_i2p_sam_sessions. 1571 */ 1572 Mutex m_unused_i2p_sessions_mutex; 1573 1574 /** 1575 * A pool of created I2P SAM transient sessions that should be used instead 1576 * of creating new ones in order to reduce the load on the I2P network. 1577 * Creating a session in I2P is not cheap, thus if this is not empty, then 1578 * pick an entry from it instead of creating a new session. If connecting to 1579 * a host fails, then the created session is put to this pool for reuse. 1580 */ 1581 std::queue<std::unique_ptr<i2p::sam::Session>> m_unused_i2p_sessions GUARDED_BY(m_unused_i2p_sessions_mutex); 1582 1583 /** 1584 * Mutex protecting m_reconnections. 1585 */ 1586 Mutex m_reconnections_mutex; 1587 1588 /** Struct for entries in m_reconnections. */ 1589 struct ReconnectionInfo 1590 { 1591 CAddress addr_connect; 1592 CSemaphoreGrant grant; 1593 std::string destination; 1594 ConnectionType conn_type; 1595 bool use_v2transport; 1596 }; 1597 1598 /** 1599 * List of reconnections we have to make. 1600 */ 1601 std::list<ReconnectionInfo> m_reconnections GUARDED_BY(m_reconnections_mutex); 1602 1603 /** Attempt reconnections, if m_reconnections non-empty. */ 1604 void PerformReconnections() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex, !m_unused_i2p_sessions_mutex); 1605 1606 /** 1607 * Cap on the size of `m_unused_i2p_sessions`, to ensure it does not 1608 * unexpectedly use too much memory. 1609 */ 1610 static constexpr size_t MAX_UNUSED_I2P_SESSIONS_SIZE{10}; 1611 1612 /** 1613 * RAII helper to atomically create a copy of `m_nodes` and add a reference 1614 * to each of the nodes. The nodes are released when this object is destroyed. 1615 */ 1616 class NodesSnapshot 1617 { 1618 public: 1619 explicit NodesSnapshot(const CConnman& connman, bool shuffle) 1620 { 1621 { 1622 LOCK(connman.m_nodes_mutex); 1623 m_nodes_copy = connman.m_nodes; 1624 for (auto& node : m_nodes_copy) { 1625 node->AddRef(); 1626 } 1627 } 1628 if (shuffle) { 1629 Shuffle(m_nodes_copy.begin(), m_nodes_copy.end(), FastRandomContext{}); 1630 } 1631 } 1632 1633 ~NodesSnapshot() 1634 { 1635 for (auto& node : m_nodes_copy) { 1636 node->Release(); 1637 } 1638 } 1639 1640 const std::vector<CNode*>& Nodes() const 1641 { 1642 return m_nodes_copy; 1643 } 1644 1645 private: 1646 std::vector<CNode*> m_nodes_copy; 1647 }; 1648 1649 const CChainParams& m_params; 1650 1651 friend struct ConnmanTestMsg; 1652 }; 1653 1654 /** Defaults to `CaptureMessageToFile()`, but can be overridden by unit tests. */ 1655 extern std::function<void(const CAddress& addr, 1656 const std::string& msg_type, 1657 Span<const unsigned char> data, 1658 bool is_incoming)> 1659 CaptureMessage; 1660 1661 #endif // BITCOIN_NET_H