Bitcoin Core  27.99.0
P2P Digital Currency
net.h
Go to the documentation of this file.
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>
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 
57 static constexpr std::chrono::minutes TIMEOUT_INTERVAL{20};
59 static constexpr auto FEELER_INTERVAL = 2min;
61 static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min;
63 static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1000 * 1000;
65 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
69 static const int MAX_ADDNODE_CONNECTIONS = 8;
71 static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS = 2;
73 static const int MAX_FEELER_CONNECTIONS = 1;
75 static const bool DEFAULT_LISTEN = true;
77 static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 125;
79 static const std::string DEFAULT_MAX_UPLOAD_TARGET{"0M"};
81 static const bool DEFAULT_BLOCKSONLY = false;
83 static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60;
85 static const int NUM_FDS_MESSAGE_CAPTURE = 1;
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 
100  std::string m_added_node;
102 };
103 
108  bool fInbound;
109 };
110 
111 class CNodeStats;
112 class CClientUIInterface;
113 
115  CSerializedNetMsg() = default;
118  // No implicit copying, only moves.
121 
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 
134  size_t GetMemoryUsage() const noexcept;
135 };
136 
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 
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 
172 extern std::string strSubVersion;
173 
175  int nScore;
176  uint16_t nPort;
177 };
178 
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 
186 {
187 public:
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
201  // Peer requested high bandwidth connection
204  uint64_t nSendBytes;
206  uint64_t nRecvBytes;
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
215  // Bind address of our side of the connection
217  // Network the peer connected through
219  uint32_t m_mapped_as;
224  std::string m_session_id;
225 };
226 
227 
233 {
234 public:
236  std::chrono::microseconds m_time{0};
237  uint32_t m_message_size{0};
238  uint32_t m_raw_message_size{0};
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;
249  CNetMessage& operator=(const CNetMessage&) = delete;
250 };
251 
253 class Transport {
254 public:
255  virtual ~Transport() {}
256 
257  struct Info
258  {
260  std::optional<uint256> session_id;
261  };
262 
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 
270  virtual bool ReceivedMessageComplete() const = 0;
271 
278  virtual bool ReceivedBytes(Span<const uint8_t>& msg_bytes) = 0;
279 
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 
297  virtual bool SetMessageToSend(CSerializedNetMsg& msg) noexcept = 0;
298 
306  using BytesToSend = std::tuple<
307  Span<const uint8_t> /*to_send*/,
308  bool /*more*/,
309  const std::string& /*m_type*/
310  >;
311 
347  virtual BytesToSend GetBytesToSend(bool have_next_message) const noexcept = 0;
348 
355  virtual void MarkBytesSent(size_t bytes_sent) noexcept = 0;
356 
358  virtual size_t GetSendMemoryUsage() const noexcept = 0;
359 
360  // 3. Miscellaneous functions.
361 
363  virtual bool ShouldReconnectV1() const noexcept = 0;
364 };
365 
366 class V1Transport final : public Transport
367 {
368 private:
370  const NodeId m_node_id; // Only for logging
371  mutable Mutex m_recv_mutex;
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 
407  std::vector<uint8_t> m_header_to_send GUARDED_BY(m_send_mutex);
409  CSerializedNetMsg m_message_to_send GUARDED_BY(m_send_mutex);
411  bool m_sending_header GUARDED_BY(m_send_mutex) {false};
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:
454  static constexpr std::array<std::byte, 0> VERSION_CONTENTS = {};
455 
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 
479  enum class RecvState : uint8_t {
485  KEY_MAYBE_V1,
486 
492  KEY,
493 
500  GARB_GARBTERM,
501 
510  VERSION,
511 
517  APP,
518 
523  APP_READY,
524 
528  V1,
529  };
530 
544  enum class SendState : uint8_t {
551  MAYBE_V1,
552 
558  AWAITING_KEY,
559 
566  READY,
567 
571  V1,
572  };
573 
577  const bool m_initiating;
582 
584  mutable Mutex m_recv_mutex ACQUIRED_BEFORE(m_send_mutex);
587  uint32_t m_recv_len GUARDED_BY(m_recv_mutex) {0};
589  std::vector<uint8_t> m_recv_buffer GUARDED_BY(m_recv_mutex);
591  std::vector<uint8_t> m_recv_aad GUARDED_BY(m_recv_mutex);
593  std::vector<uint8_t> m_recv_decode_buffer GUARDED_BY(m_recv_mutex);
595  RecvState m_recv_state GUARDED_BY(m_recv_mutex);
596 
599  mutable Mutex m_send_mutex ACQUIRED_AFTER(m_recv_mutex);
601  std::vector<uint8_t> m_send_buffer GUARDED_BY(m_send_mutex);
603  uint32_t m_send_pos GUARDED_BY(m_send_mutex) {0};
605  std::vector<uint8_t> m_send_garbage GUARDED_BY(m_send_mutex);
607  std::string m_send_type GUARDED_BY(m_send_mutex);
609  SendState m_send_state GUARDED_BY(m_send_mutex);
611  bool m_sent_v1_header_worth GUARDED_BY(m_send_mutex) {false};
612 
614  void SetReceiveState(RecvState recv_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
616  void SetSendState(SendState send_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex);
618  static std::optional<std::string> GetMessageType(Span<const uint8_t>& contents) noexcept;
620  size_t GetMaxBytesToProcess() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
622  void StartSendingHandshake() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex);
624  void ProcessReceivedMaybeV1Bytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex);
626  bool ProcessReceivedKeyBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex);
628  bool ProcessReceivedGarbageBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
630  bool ProcessReceivedPacketBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);
631 
632 public:
633  static constexpr uint32_t MAX_GARBAGE_LEN = 4095;
634 
640  V2Transport(NodeId nodeid, bool initiating) noexcept;
641 
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 
662 {
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 
671 class CNode
672 {
673 public:
676  const std::unique_ptr<Transport> m_transport;
677 
679 
688  std::shared_ptr<Sock> m_sock GUARDED_BY(m_sock_mutex);
689 
691  size_t m_send_memusage GUARDED_BY(cs_vSend){0};
693  uint64_t nSendBytes GUARDED_BY(cs_vSend){0};
695  std::deque<CSerializedNetMsg> vSendMsg GUARDED_BY(cs_vSend);
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};
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
711  const std::string m_addr_name;
713  const std::string m_dest;
715  const bool m_inbound_onion;
716  std::atomic<int> nVersion{0};
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  }
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};
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 
740 
742  void MarkReceivedMsgsForProcessing()
743  EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex);
744 
750  std::optional<std::pair<CNetMessage, bool>> PollMessage()
751  EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex);
752 
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 
761  switch (m_conn_type) {
764  return true;
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 
784  {
785  switch (m_conn_type) {
790  return false;
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) {
820  return false;
824  return true;
825  } // no default case, so the compiler can warn about missing cases
826 
827  assert(false);
828  }
829 
840  Network ConnectedThroughNetwork() const;
841 
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 
851  std::atomic_bool m_has_all_wanted_services{false};
852 
855  std::atomic_bool m_relays_txs{false};
856 
859  std::atomic_bool m_bloom_filter_loaded{false};
860 
866  std::atomic<std::chrono::seconds> m_last_block_time{0s};
867 
872  std::atomic<std::chrono::seconds> m_last_tx_time{0s};
873 
875  std::atomic<std::chrono::microseconds> m_last_ping_time{0us};
876 
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 
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);
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 
949 
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 
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);
971 
972  mapMsgTypeSize mapSendBytesPerMsgType GUARDED_BY(cs_vSend);
973  mapMsgTypeSize mapRecvBytesPerMsgType GUARDED_BY(cs_vRecv);
974 
985  std::unique_ptr<i2p::sam::Session> m_i2p_sam_session GUARDED_BY(m_sock_mutex);
986 };
987 
992 {
993 public:
996 
998  virtual void InitializeNode(CNode& node, ServiceFlags our_services) = 0;
999 
1001  virtual void FinalizeNode(const CNode& node) = 0;
1002 
1007  virtual bool HasAllDesirableServiceFlags(ServiceFlags services) const = 0;
1008 
1016  virtual bool ProcessMessages(CNode* pnode, std::atomic<bool>& interrupt) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0;
1017 
1024  virtual bool SendMessages(CNode* pnode) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0;
1025 
1026 
1027 protected:
1032  ~NetEventsInterface() = default;
1033 };
1034 
1036 {
1037 public:
1038 
1039  struct Options
1040  {
1041  ServiceFlags nLocalServices = NODE_NONE;
1042  int m_max_automatic_connections = 0;
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;
1059  bool m_use_addrman_outgoing = true;
1060  std::vector<std::string> m_specified_outgoing;
1061  std::vector<std::string> m_added_nodes;
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
1162  std::vector<CAddress> GetAddresses(size_t max_addresses, size_t max_pct, std::optional<Network> network, const bool filtered = true) const;
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 
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 
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 
1230  bool OutboundTargetReached(bool historicalBlockServingLimit) const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex);
1231 
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 
1242  CSipHasher GetDeterministicRandomizer(uint64_t id) const;
1243 
1244  void WakeMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
1245 
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;
1256  ListenSocket(std::shared_ptr<Sock> sock_, NetPermissionFlags permissions_)
1257  : sock{sock_}, m_permissions{permissions_}
1258  {
1259  }
1260 
1261  private:
1263  };
1264 
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 
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();
1297  bool InactivityCheck(const CNode& node) const;
1298 
1304  Sock::EventsPerSock GenerateWaitSockets(Span<CNode* const> nodes);
1305 
1309  void SocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc);
1310 
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 
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 
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 
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 
1362  std::unordered_set<Network> GetReachableEmptyNetworks() const;
1363 
1367  std::vector<CAddress> GetCurrentBlockRelayOnlyConns() const;
1368 
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};
1414  std::deque<std::string> m_addr_fetches GUARDED_BY(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 
1421  std::vector<CNode*> m_nodes GUARDED_BY(m_nodes_mutex);
1422  std::list<CNode*> m_nodes_disconnected;
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 
1437  std::vector<CAddress> m_addrs_response_cache;
1438  std::chrono::microseconds m_cache_entry_expiration{0};
1439  };
1440 
1455  std::map<uint64_t, CachedAddrResponse> m_addr_response_caches;
1456 
1468 
1469  std::unique_ptr<CSemaphore> semOutbound;
1470  std::unique_ptr<CSemaphore> semAddnode;
1471 
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
1486 
1487  // How many block-relay only outbound peers we want
1488  // We do not relay tx or addr messages with these peers
1490 
1491  int m_max_addnode{MAX_ADDNODE_CONNECTIONS};
1492  int m_max_feeler{MAX_FEELER_CONNECTIONS};
1495 
1501 
1506  std::vector<CAddress> m_anchors;
1507 
1509  const uint64_t nSeed0, nSeed1;
1510 
1512  bool fMsgProcWake GUARDED_BY(mutexMsgProc);
1513 
1514  std::condition_variable condMsgProc;
1516  std::atomic<bool> flagInterruptMsgProc{false};
1517 
1525 
1531  std::unique_ptr<i2p::sam::Session> m_i2p_sam_session;
1532 
1534  std::thread threadSocketHandler;
1539 
1544 
1549  std::atomic_bool m_start_extra_block_relay_peers{false};
1550 
1555  std::vector<CService> m_onion_binds;
1556 
1562 
1568 
1573 
1581  std::queue<std::unique_ptr<i2p::sam::Session>> m_unused_i2p_sessions GUARDED_BY(m_unused_i2p_sessions_mutex);
1582 
1587 
1590  {
1593  std::string destination;
1596  };
1597 
1601  std::list<ReconnectionInfo> m_reconnections GUARDED_BY(m_reconnections_mutex);
1602 
1604  void PerformReconnections() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex, !m_unused_i2p_sessions_mutex);
1605 
1610  static constexpr size_t MAX_UNUSED_I2P_SESSIONS_SIZE{10};
1611 
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 
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 
1650 
1651  friend struct ConnmanTestMsg;
1652 };
1653 
1655 extern std::function<void(const CAddress& addr,
1656  const std::string& msg_type,
1658  bool is_incoming)>
1660 
1661 #endif // BITCOIN_NET_H
int ret
int flags
Definition: bitcoin-tx.cpp:530
Interrupt(node)
#define Assume(val)
Assume is the identity function.
Definition: check.h:89
Stochastic address manager.
Definition: addrman.h:88
The BIP324 packet cipher, encapsulating its key derivation, stream cipher, and AEAD.
Definition: bip324.h:20
Definition: banman.h:59
A CService with information about it as peer.
Definition: protocol.h:332
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:81
Signals for UI communication.
Definition: interface_ui.h:25
RAII helper to atomically create a copy of m_nodes and add a reference to each of the nodes.
Definition: net.h:1617
NodesSnapshot(const CConnman &connman, bool shuffle)
Definition: net.h:1619
const std::vector< CNode * > & Nodes() const
Definition: net.h:1640
std::vector< CNode * > m_nodes_copy
Definition: net.h:1646
Definition: net.h:1036
bool whitelist_relay
flag for adding 'relay' permission to whitelisted inbound and manual peers with default permissions.
Definition: net.h:1567
std::condition_variable condMsgProc
Definition: net.h:1514
std::thread threadMessageHandler
Definition: net.h:1537
std::vector< NetWhitelistPermissions > vWhitelistedRangeIncoming
Definition: net.h:1402
CClientUIInterface * m_client_interface
Definition: net.h:1497
std::vector< AddedNodeParams > m_added_node_params GUARDED_BY(m_added_nodes_mutex)
void ForEachNode(const NodeFn &func) const
Definition: net.h:1144
RecursiveMutex & GetNodesMutex() const LOCK_RETURNED(m_nodes_mutex)
std::list< ReconnectionInfo > m_reconnections GUARDED_BY(m_reconnections_mutex)
List of reconnections we have to make.
ServiceFlags nLocalServices
Services this node offers.
Definition: net.h:1467
int m_max_inbound
Definition: net.h:1494
const bool use_v2transport(GetLocalServices() &NODE_P2P_V2)
void Stop()
Definition: net.h:1113
int m_max_outbound_block_relay
Definition: net.h:1489
std::thread threadI2PAcceptIncoming
Definition: net.h:1538
int m_max_automatic_outbound
Definition: net.h:1493
std::vector< CNode * > m_nodes GUARDED_BY(m_nodes_mutex)
uint64_t nMaxOutboundLimit GUARDED_BY(m_total_bytes_sent_mutex)
CThreadInterrupt interruptNet
This is signaled when network activity should cease.
Definition: net.h:1524
std::unique_ptr< CSemaphore > semAddnode
Definition: net.h:1470
bool fMsgProcWake GUARDED_BY(mutexMsgProc)
flag for waking the message processor.
int m_max_automatic_connections
Maximum number of automatic connections permitted, excluding manual connections but including inbound...
Definition: net.h:1477
BanMan * m_banman
Pointer to this node's banman.
Definition: net.h:1500
uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(m_total_bytes_sent_mutex)
Definition: net.h:1393
std::thread threadDNSAddressSeed
Definition: net.h:1533
const NetGroupManager & m_netgroupman
Definition: net.h:1413
std::vector< CAddress > m_anchors
Addresses that were saved during the previous clean shutdown.
Definition: net.h:1506
bool whitelist_forcerelay
flag for adding 'forcerelay' permission to whitelisted inbound and manual peers with default permissi...
Definition: net.h:1561
std::chrono::seconds m_peer_connect_timeout
Definition: net.h:1398
std::atomic_bool m_try_another_outbound_peer
flag for deciding to connect to an extra outbound peer, in excess of m_max_outbound_full_relay This t...
Definition: net.h:1543
std::vector< ListenSocket > vhListenSocket
Definition: net.h:1409
std::unique_ptr< CSemaphore > semOutbound
Definition: net.h:1469
std::array< unsigned int, Network::NET_MAX > m_network_conn_counts GUARDED_BY(m_nodes_mutex)
std::thread threadOpenConnections
Definition: net.h:1536
Mutex m_addr_fetches_mutex
Definition: net.h:1415
Mutex m_reconnections_mutex
Mutex protecting m_reconnections.
Definition: net.h:1586
const uint64_t nSeed0
SipHasher seeds for deterministic randomness.
Definition: net.h:1509
RecursiveMutex m_nodes_mutex
Definition: net.h:1423
std::queue< std::unique_ptr< i2p::sam::Session > > m_unused_i2p_sessions GUARDED_BY(m_unused_i2p_sessions_mutex)
A pool of created I2P SAM transient sessions that should be used instead of creating new ones in orde...
std::deque< std::string > m_addr_fetches GUARDED_BY(m_addr_fetches_mutex)
const CChainParams & m_params
Definition: net.h:1649
AddrMan & addrman
Definition: net.h:1412
Mutex mutexMsgProc
Definition: net.h:1515
std::thread threadOpenAddedConnections
Definition: net.h:1535
Mutex m_added_nodes_mutex
Definition: net.h:1420
int m_max_outbound_full_relay
Definition: net.h:1485
Mutex m_unused_i2p_sessions_mutex
Mutex protecting m_i2p_sam_sessions.
Definition: net.h:1572
std::chrono::seconds nMaxOutboundCycleStartTime GUARDED_BY(m_total_bytes_sent_mutex)
Definition: net.h:1394
uint64_t nTotalBytesSent GUARDED_BY(m_total_bytes_sent_mutex)
Definition: net.h:1390
bool GetUseAddrmanOutgoing() const
Definition: net.h:1121
std::list< CNode * > m_nodes_disconnected
Definition: net.h:1422
std::unique_ptr< i2p::sam::Session > m_i2p_sam_session
I2P SAM session.
Definition: net.h:1531
bool m_use_addrman_outgoing
Definition: net.h:1496
std::vector< NetWhitelistPermissions > vWhitelistedRangeOutgoing
Definition: net.h:1404
std::map< uint64_t, CachedAddrResponse > m_addr_response_caches
Addr responses stored in different caches per (network, local socket) prevent cross-network node iden...
Definition: net.h:1455
std::function< void(CNode *)> NodeFn
Definition: net.h:1134
NetEventsInterface * m_msgproc
Definition: net.h:1498
std::vector< CService > m_onion_binds
A vector of -bind=<address>:<port>=onion arguments each of which is an address and port that are desi...
Definition: net.h:1555
std::thread threadSocketHandler
Definition: net.h:1534
A hasher class for Bitcoin's 256-bit hash (double SHA-256).
Definition: hash.h:24
An encapsulated private key.
Definition: key.h:33
Message header.
Definition: protocol.h:29
Network address.
Definition: netaddress.h:112
Transport protocol agnostic message container.
Definition: net.h:233
CNetMessage & operator=(CNetMessage &&)=default
CNetMessage(CNetMessage &&)=default
CNetMessage & operator=(const CNetMessage &)=delete
CNetMessage(DataStream &&recv_in)
Definition: net.h:241
std::string m_type
Definition: net.h:239
DataStream m_recv
received message data
Definition: net.h:235
CNetMessage(const CNetMessage &)=delete
Information about a peer.
Definition: net.h:672
const CAddress addrBind
Definition: net.h:710
bool IsFeelerConn() const
Definition: net.h:803
const std::chrono::seconds m_connected
Unix epoch time at peer connection.
Definition: net.h:705
bool ExpectServicesFromConn() const
Definition: net.h:815
const std::string m_dest
The pszDest argument provided to ConnectNode().
Definition: net.h:713
uint64_t nRecvBytes GUARDED_BY(cs_vRecv)
Definition: net.h:700
bool IsInboundConn() const
Definition: net.h:811
bool HasPermission(NetPermissionFlags permission) const
Definition: net.h:724
bool IsOutboundOrBlockRelayConn() const
Definition: net.h:760
NodeId GetId() const
Definition: net.h:894
bool IsManualConn() const
Definition: net.h:779
const std::string m_addr_name
Definition: net.h:711
void SetCommonVersion(int greatest_common_version)
Definition: net.h:919
std::list< CNetMessage > vRecvMsg
Definition: net.h:962
std::deque< CSerializedNetMsg > vSendMsg GUARDED_BY(cs_vSend)
Messages still to be fed to m_transport->SetMessageToSend.
std::list< CNetMessage > m_msg_process_queue GUARDED_BY(m_msg_process_queue_mutex)
void PongReceived(std::chrono::microseconds ping_time)
A ping-pong round trip has completed successfully.
Definition: net.h:951
size_t m_msg_process_queue_size GUARDED_BY(m_msg_process_queue_mutex)
Definition: net.h:966
bool IsAddrFetchConn() const
Definition: net.h:807
uint64_t GetLocalNonce() const
Definition: net.h:898
const CAddress addr
Definition: net.h:708
CSemaphoreGrant grantOutbound
Definition: net.h:732
mapMsgTypeSize mapSendBytesPerMsgType GUARDED_BY(cs_vSend)
const uint64_t nKeyedNetGroup
Definition: net.h:735
bool IsBlockOnlyConn() const
Definition: net.h:799
int GetCommonVersion() const
Definition: net.h:924
mapMsgTypeSize mapRecvBytesPerMsgType GUARDED_BY(cs_vRecv)
bool IsFullOutboundConn() const
Definition: net.h:775
std::shared_ptr< Sock > m_sock GUARDED_BY(m_sock_mutex)
Socket used for communication with the node.
Mutex m_subver_mutex
Definition: net.h:717
Mutex cs_vSend
Definition: net.h:696
int GetRefCount() const
Definition: net.h:902
Mutex m_msg_process_queue_mutex
Definition: net.h:964
std::unique_ptr< i2p::sam::Session > m_i2p_sam_session GUARDED_BY(m_sock_mutex)
If an I2P session is created per connection (for outbound transient I2P connections) then it is store...
CService addrLocal GUARDED_BY(m_addr_local_mutex)
const ConnectionType m_conn_type
Definition: net.h:739
const size_t m_recv_flood_size
Definition: net.h:961
const uint64_t nLocalHostNonce
Definition: net.h:958
bool IsManualOrFullOutboundConn() const
Definition: net.h:783
const std::unique_ptr< Transport > m_transport
Transport serializer/deserializer.
Definition: net.h:676
const NetPermissionFlags m_permission_flags
Definition: net.h:678
Mutex m_addr_local_mutex
Definition: net.h:970
CNode(const CNode &)=delete
size_t m_send_memusage GUARDED_BY(cs_vSend)
Sum of GetMemoryUsage of all vSendMsg entries.
Definition: net.h:691
const bool m_inbound_onion
Whether this peer is an inbound onion, i.e. connected via our Tor onion service.
Definition: net.h:715
const NodeId id
Definition: net.h:957
Mutex cs_vRecv
Definition: net.h:698
uint64_t nSendBytes GUARDED_BY(cs_vSend)
Total number of bytes sent on the wire to this peer.
Definition: net.h:693
Mutex m_sock_mutex
Definition: net.h:697
void Release()
Definition: net.h:939
CNode & operator=(const CNode &)=delete
std::string cleanSubVer GUARDED_BY(m_subver_mutex)
cleanSubVer is a sanitized string of the user agent byte array we read from the wire.
Definition: net.h:722
std::string m_session_id
BIP324 session id string in hex, if any.
Definition: net.h:224
std::string addrLocal
Definition: net.h:212
CAddress addrBind
Definition: net.h:216
uint64_t nRecvBytes
Definition: net.h:206
std::chrono::microseconds m_last_ping_time
Definition: net.h:209
uint32_t m_mapped_as
Definition: net.h:219
mapMsgTypeSize mapRecvBytesPerMsgType
Definition: net.h:207
bool fInbound
Definition: net.h:198
uint64_t nSendBytes
Definition: net.h:204
std::chrono::seconds m_last_recv
Definition: net.h:190
ConnectionType m_conn_type
Definition: net.h:220
std::chrono::seconds m_last_send
Definition: net.h:189
std::chrono::seconds m_last_tx_time
Definition: net.h:191
CAddress addr
Definition: net.h:214
mapMsgTypeSize mapSendBytesPerMsgType
Definition: net.h:205
std::chrono::microseconds m_min_ping_time
Definition: net.h:210
int64_t nTimeOffset
Definition: net.h:194
TransportProtocolType m_transport_type
Transport protocol type.
Definition: net.h:222
std::chrono::seconds m_connected
Definition: net.h:193
bool m_bip152_highbandwidth_from
Definition: net.h:202
bool m_bip152_highbandwidth_to
Definition: net.h:200
std::string m_addr_name
Definition: net.h:195
int nVersion
Definition: net.h:196
std::chrono::seconds m_last_block_time
Definition: net.h:192
Network m_network
Definition: net.h:218
NodeId nodeid
Definition: net.h:188
std::string cleanSubVer
Definition: net.h:197
int m_starting_height
Definition: net.h:203
NetPermissionFlags m_permission_flags
Definition: net.h:208
Simple class for background tasks that should be run periodically or once "after a while".
Definition: scheduler.h:40
RAII-style semaphore lock.
Definition: sync.h:353
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:531
SipHash-2-4.
Definition: siphash.h:15
A helper class for interruptible sleeps.
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:147
Fast randomness source.
Definition: random.h:145
Different type to mark Mutex at global scope.
Definition: sync.h:140
Interface for message handling.
Definition: net.h:992
static Mutex g_msgproc_mutex
Mutex for anything that is only accessed via the msg processing thread.
Definition: net.h:995
virtual bool SendMessages(CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex)=0
Send queued protocol messages to a given node.
virtual void FinalizeNode(const CNode &node)=0
Handle removal of a peer (clear state)
virtual bool HasAllDesirableServiceFlags(ServiceFlags services) const =0
Callback to determine whether the given set of service flags are sufficient for a peer to be "relevan...
virtual bool ProcessMessages(CNode *pnode, std::atomic< bool > &interrupt) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex)=0
Process protocol messages received from a given node.
~NetEventsInterface()=default
Protected destructor so that instances can only be deleted by derived classes.
virtual void InitializeNode(CNode &node, ServiceFlags our_services)=0
Initialize a peer (setup state, queue any initial messages)
Netgroup manager.
Definition: netgroup.h:16
static void AddFlag(NetPermissionFlags &flags, NetPermissionFlags f)
static bool HasFlag(NetPermissionFlags flags, NetPermissionFlags f)
RAII helper class that manages a socket and closes it automatically when it goes out of scope.
Definition: sock.h:27
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:98
The Transport converts one connection's sent messages to wire bytes, and received bytes back.
Definition: net.h:253
virtual ~Transport()
Definition: net.h:255
std::tuple< Span< const uint8_t >, bool, const std::string & > BytesToSend
Return type for GetBytesToSend, consisting of:
Definition: net.h:310
virtual Info GetInfo() const noexcept=0
Retrieve information about this transport.
CHash256 hasher GUARDED_BY(m_recv_mutex)
DataStream hdrbuf GUARDED_BY(m_recv_mutex)
Definition: net.h:375
bool m_sending_header GUARDED_BY(m_send_mutex)
Whether we're currently sending header bytes or message bytes.
Definition: net.h:411
const NodeId m_node_id
Definition: net.h:370
Mutex m_send_mutex
Lock for sending state.
Definition: net.h:405
CSerializedNetMsg m_message_to_send GUARDED_BY(m_send_mutex)
The data of the message currently being sent.
size_t m_bytes_sent GUARDED_BY(m_send_mutex)
How many bytes have been sent so far (from m_header_to_send, or from m_message_to_send....
Definition: net.h:413
unsigned int nDataPos GUARDED_BY(m_recv_mutex)
bool in_data GUARDED_BY(m_recv_mutex)
uint256 data_hash GUARDED_BY(m_recv_mutex)
const MessageStartChars m_magic_bytes
Definition: net.h:369
unsigned int nHdrPos GUARDED_BY(m_recv_mutex)
DataStream vRecv GUARDED_BY(m_recv_mutex)
Definition: net.h:377
bool CompleteInternal() const noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
Definition: net.h:397
CMessageHeader hdr GUARDED_BY(m_recv_mutex)
std::vector< uint8_t > m_header_to_send GUARDED_BY(m_send_mutex)
The header of the message currently being sent.
Mutex m_recv_mutex
Lock for receive state.
Definition: net.h:371
bool ReceivedMessageComplete() const override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Returns true if the current message is complete (so GetReceivedMessage can be called).
Definition: net.h:418
bool m_sent_v1_header_worth GUARDED_BY(m_send_mutex)
Whether we've sent at least 24 bytes (which would trigger disconnect for V1 peers).
Definition: net.h:611
const NodeId m_nodeid
NodeId (for debug logging).
Definition: net.h:579
BIP324Cipher m_cipher
Cipher state.
Definition: net.h:575
std::vector< uint8_t > m_recv_aad GUARDED_BY(m_recv_mutex)
AAD expected in next received packet (currently used only for garbage).
SendState
State type that controls the sender side.
Definition: net.h:544
V1Transport m_v1_fallback
Encapsulate a V1Transport to fall back to.
Definition: net.h:581
Mutex m_send_mutex ACQUIRED_AFTER(m_recv_mutex)
Lock for sending-side fields.
SendState m_send_state GUARDED_BY(m_send_mutex)
Current sender state.
std::vector< uint8_t > m_send_garbage GUARDED_BY(m_send_mutex)
The garbage sent, or to be sent (MAYBE_V1 and AWAITING_KEY state only).
std::string m_send_type GUARDED_BY(m_send_mutex)
Type of the message being sent.
const bool m_initiating
Whether we are the initiator side.
Definition: net.h:577
std::vector< uint8_t > m_send_buffer GUARDED_BY(m_send_mutex)
The send buffer; meaning is determined by m_send_state.
std::vector< uint8_t > m_recv_buffer GUARDED_BY(m_recv_mutex)
Receive buffer; meaning is determined by m_recv_state.
uint32_t m_recv_len GUARDED_BY(m_recv_mutex)
In {VERSION, APP}, the decrypted packet length, if m_recv_buffer.size() >= BIP324Cipher::LENGTH_LEN.
Definition: net.h:587
uint32_t m_send_pos GUARDED_BY(m_send_mutex)
How many bytes from the send buffer have been sent so far.
Definition: net.h:603
RecvState m_recv_state GUARDED_BY(m_recv_mutex)
Current receiver state.
Mutex m_recv_mutex ACQUIRED_BEFORE(m_send_mutex)
Lock for receiver-side fields.
std::vector< uint8_t > m_recv_decode_buffer GUARDED_BY(m_recv_mutex)
Buffer to put decrypted contents in, for converting to CNetMessage.
RecvState
State type that defines the current contents of the receive buffer and/or how the next received bytes...
Definition: net.h:479
256-bit opaque blob.
Definition: uint256.h:106
std::string ConnectionTypeAsString(ConnectionType conn_type)
Convert ConnectionType enum to a string value.
ConnectionType
Different types of connections to a peer.
@ BLOCK_RELAY
We use block-relay-only connections to help prevent against partition attacks.
@ MANUAL
We open manual connections to addresses that users explicitly requested via the addnode RPC or the -a...
@ OUTBOUND_FULL_RELAY
These are the default connections that we use to connect with the network.
@ FEELER
Feeler connections are short-lived connections made to check that a node is alive.
@ INBOUND
Inbound connections are those initiated by a peer.
@ ADDR_FETCH
AddrFetch connections are short lived connections used to solicit addresses from peers.
TransportProtocolType
Transport layer version.
@ V1
Unencrypted, plaintext protocol.
static CService ip(uint32_t i)
CClientUIInterface uiInterface
#define VERSION
std::array< uint8_t, 4 > MessageStartChars
unsigned int nonce
Definition: miner_tests.cpp:71
Definition: init.h:25
const std::string KEY
Definition: walletdb.cpp:49
uint16_t GetListenPort()
Definition: net.cpp:135
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:77
bool IsLocal(const CService &addr)
check whether a given address is potentially local
Definition: net.cpp:321
void RemoveLocal(const CService &addr)
Definition: net.cpp:302
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:65
static constexpr std::chrono::minutes TIMEOUT_INTERVAL
Time after which to disconnect, after waiting for a ping response (or inactivity).
Definition: net.h:57
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:69
bool AddLocal(const CService &addr, int nScore=LOCAL_NONE)
Definition: net.cpp:269
std::optional< CService > GetLocalAddrForPeer(CNode &node)
Returns a local address that we should advertise to this peer.
Definition: net.cpp:238
bool fDiscover
Definition: net.cpp:115
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:93
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:85
static constexpr bool DEFAULT_FIXEDSEEDS
Definition: net.h:91
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:81
static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH
Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable).
Definition: net.h:63
bool fListen
Definition: net.cpp:116
std::map< CNetAddr, LocalServiceInfo > mapLocalHost GUARDED_BY(g_maplocalhost_mutex)
static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL
Run the extra block-relay-only connection loop once every 5 minutes.
Definition: net.h:61
static const size_t DEFAULT_MAXRECEIVEBUFFER
Definition: net.h:92
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
Definition: net.cpp:119
static const std::string DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:79
const std::string NET_MESSAGE_TYPE_OTHER
Definition: net.cpp:107
std::map< std::string, uint64_t > mapMsgTypeSize
Definition: net.h:183
static constexpr bool DEFAULT_FORCEDNSSEED
Definition: net.h:89
static constexpr bool DEFAULT_DNSSEED
Definition: net.h:90
int64_t NodeId
Definition: net.h:97
CService GetLocalAddress(const CNode &peer)
Definition: net.cpp:218
GlobalMutex g_maplocalhost_mutex
Definition: net.cpp:117
static const int MAX_FEELER_CONNECTIONS
Maximum number of feeler connections.
Definition: net.h:73
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:75
static constexpr std::chrono::hours ASMAP_HEALTH_CHECK_INTERVAL
Interval for ASMap Health Check.
Definition: net.h:87
static constexpr auto FEELER_INTERVAL
Run the feeler connection loop once every 2 minutes.
Definition: net.h:59
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
Definition: net.h:83
static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks,...
Definition: net.h:67
std::function< void(const CAddress &addr, const std::string &msg_type, Span< const unsigned char > data, bool is_incoming)> CaptureMessage
Defaults to CaptureMessageToFile(), but can be overridden by unit tests.
Definition: net.cpp:3882
@ LOCAL_NONE
Definition: net.h:149
@ LOCAL_MAPPED
Definition: net.h:152
@ LOCAL_MANUAL
Definition: net.h:153
@ LOCAL_MAX
Definition: net.h:155
@ LOCAL_BIND
Definition: net.h:151
@ LOCAL_IF
Definition: net.h:150
static constexpr bool DEFAULT_V2_TRANSPORT
Definition: net.h:95
static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS
Maximum number of block-relay-only outgoing connections.
Definition: net.h:71
void Discover()
Look up IP addresses from all interfaces on the machine and add them to the list of local addresses t...
Definition: net.cpp:3034
bool SeenLocal(const CService &addr)
vote for a local address
Definition: net.cpp:310
constexpr bool DEFAULT_WHITELISTFORCERELAY
Default for -whitelistforcerelay.
constexpr bool DEFAULT_WHITELISTRELAY
Default for -whitelistrelay.
NetPermissionFlags
Network
A network type.
Definition: netaddress.h:32
ConnectionDirection
Definition: netbase.h:33
ServiceFlags
nServices flags
Definition: protocol.h:274
@ NODE_NONE
Definition: protocol.h:277
@ NODE_P2P_V2
Definition: protocol.h:295
static const int INIT_PROTO_VERSION
initial proto version, to be increased after version/verack negotiation
void Shuffle(I first, I last, R &&rng)
More efficient than using std::shuffle on a FastRandomContext.
Definition: random.h:265
bool fInbound
Definition: net.h:108
CService resolvedAddress
Definition: net.h:106
AddedNodeParams m_params
Definition: net.h:105
bool fConnected
Definition: net.h:107
std::string m_added_node
Definition: net.h:100
bool m_use_v2transport
Definition: net.h:101
Cache responses to addr requests to minimize privacy leak.
Definition: net.h:1436
std::vector< CAddress > m_addrs_response_cache
Definition: net.h:1437
void AddSocketPermissionFlags(NetPermissionFlags &flags) const
Definition: net.h:1255
ListenSocket(std::shared_ptr< Sock > sock_, NetPermissionFlags permissions_)
Definition: net.h:1256
NetPermissionFlags m_permissions
Definition: net.h:1262
std::shared_ptr< Sock > sock
Definition: net.h:1254
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:1053
std::vector< NetWhitelistPermissions > vWhitelistedRangeIncoming
Definition: net.h:1051
std::vector< CService > onion_binds
Definition: net.h:1055
std::vector< std::string > m_specified_outgoing
Definition: net.h:1060
std::vector< std::string > m_added_nodes
Definition: net.h:1061
std::vector< CService > vBinds
Definition: net.h:1054
bool m_i2p_accept_incoming
Definition: net.h:1062
std::vector< std::string > vSeedNodes
Definition: net.h:1050
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:1058
std::vector< NetWhitelistPermissions > vWhitelistedRangeOutgoing
Definition: net.h:1052
Struct for entries in m_reconnections.
Definition: net.h:1590
CSemaphoreGrant grant
Definition: net.h:1592
ConnectionType conn_type
Definition: net.h:1594
std::string destination
Definition: net.h:1593
CSerializedNetMsg(const CSerializedNetMsg &msg)=delete
CSerializedNetMsg Copy() const
Definition: net.h:122
std::string m_type
Definition: net.h:131
CSerializedNetMsg & operator=(const CSerializedNetMsg &)=delete
CSerializedNetMsg()=default
CSerializedNetMsg(CSerializedNetMsg &&)=default
CSerializedNetMsg & operator=(CSerializedNetMsg &&)=default
std::vector< unsigned char > data
Definition: net.h:130
size_t GetMemoryUsage() const noexcept
Compute total memory usage of this object (own memory + any dynamic memory).
Definition: net.cpp:121
uint16_t nPort
Definition: net.h:176
int nScore
Definition: net.h:175
std::optional< uint256 > session_id
Definition: net.h:260
TransportProtocolType transport_type
Definition: net.h:259
Bilingual messages:
Definition: translation.h:18
#define AssertLockNotHeld(cs)
Definition: sync.h:147
#define LOCK(cs)
Definition: sync.h:257
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:301
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
#define LOCK_RETURNED(x)
Definition: threadsafety.h:47
static TxMempoolInfo GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it)
Definition: txmempool.cpp:809
AssertLockHeld(pool.cs)
assert(!tx.IsCoinBase())