Bitcoin ABC  0.26.3
P2P Digital Currency
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2019 The Bitcoin Core developers
3 // Copyright (c) 2017-2019 The Bitcoin developers
4 // Distributed under the MIT software license, see the accompanying
5 // file COPYING or
7 #ifndef BITCOIN_NET_H
8 #define BITCOIN_NET_H
10 #include <avalanche/proofid.h>
12 #include <chainparams.h>
13 #include <common/bloom.h>
14 #include <compat.h>
15 #include <consensus/amount.h>
16 #include <crypto/siphash.h>
17 #include <hash.h>
18 #include <i2p.h>
19 #include <kernel/cs_main.h>
20 #include <logging.h>
21 #include <net_permissions.h>
22 #include <netaddress.h>
23 #include <nodeid.h>
24 #include <protocol.h>
25 #include <pubkey.h>
26 #include <radix.h>
27 #include <random.h>
28 #include <span.h>
29 #include <streams.h>
30 #include <sync.h>
31 #include <threadinterrupt.h>
32 #include <uint256.h>
33 #include <util/check.h>
34 #include <util/time.h>
36 #include <atomic>
37 #include <condition_variable>
38 #include <cstdint>
39 #include <deque>
40 #include <functional>
41 #include <list>
42 #include <map>
43 #include <memory>
44 #include <thread>
45 #include <vector>
47 class AddrMan;
48 class BanMan;
49 class Config;
50 class CNode;
51 class CScheduler;
52 struct bilingual_str;
55 static const bool DEFAULT_WHITELISTRELAY = true;
57 static const bool DEFAULT_WHITELISTFORCERELAY = false;
63 static constexpr std::chrono::minutes TIMEOUT_INTERVAL{20};
65 static constexpr auto FEELER_INTERVAL = 2min;
67 static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min;
69 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
76 static const int MAX_ADDNODE_CONNECTIONS = 8;
78 static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS = 2;
85 static const int MAX_FEELER_CONNECTIONS = 1;
87 static const bool DEFAULT_LISTEN = true;
93 static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 4096;
95 static constexpr uint64_t DEFAULT_MAX_UPLOAD_TARGET = 0;
97 static const bool DEFAULT_BLOCKSONLY = false;
99 static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60;
101 static const int NUM_FDS_MESSAGE_CAPTURE = 1;
103 static const bool DEFAULT_FORCEDNSSEED = false;
104 static const bool DEFAULT_DNSSEED = true;
105 static const bool DEFAULT_FIXEDSEEDS = true;
106 static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
107 static const size_t DEFAULT_MAXSENDBUFFER = 1 * 1000;
110  std::string strAddedNode;
113  bool fInbound;
114 };
116 struct CNodeStats;
117 class CClientUIInterface;
120  CSerializedNetMsg() = default;
123  // No copying, only moves.
124  CSerializedNetMsg(const CSerializedNetMsg &msg) = delete;
128  CSerializedNetMsg copy;
129 = data;
130  copy.m_type = m_type;
131  return copy;
132  }
134  std::vector<uint8_t> data;
135  std::string m_type;
136 };
138 const std::vector<std::string> CONNECTION_TYPE_DOC{
139  "outbound-full-relay (default automatic connections)",
140  "block-relay-only (does not relay transactions or addresses)",
141  "inbound (initiated by the peer)",
142  "manual (added via addnode RPC or -addnode/-connect configuration options)",
143  "addr-fetch (short-lived automatic connection for soliciting addresses)",
144  "feeler (short-lived automatic connection for testing addresses)"};
151 enum class ConnectionType {
173  MANUAL,
191  FEELER,
217 };
220 std::string ConnectionTypeAsString(ConnectionType conn_type);
228 void Discover();
230 uint16_t GetListenPort();
232 enum {
233  // unknown
235  // address a local interface listens on
237  // address explicit bound to
239  // address reported by UPnP or NAT-PMP
241  // address explicitly specified (-externalip=)
245 };
247 bool IsPeerAddrLocalGood(CNode *pnode);
249 std::optional<CService> GetLocalAddrForPeer(CNode &node);
255 void SetReachable(enum Network net, bool reachable);
257 bool IsReachable(enum Network net);
259 bool IsReachable(const CNetAddr &addr);
261 bool AddLocal(const CService &addr, int nScore = LOCAL_NONE);
262 bool AddLocal(const CNetAddr &addr, int nScore = LOCAL_NONE);
263 void RemoveLocal(const CService &addr);
264 bool SeenLocal(const CService &addr);
265 bool IsLocal(const CService &addr);
266 bool GetLocal(CService &addr, const CNetAddr *paddrPeer = nullptr);
267 CService GetLocalAddress(const CNetAddr &addrPeer);
269 extern bool fDiscover;
270 extern bool fListen;
273  int nScore;
274  uint16_t nPort;
275 };
278 extern std::map<CNetAddr, LocalServiceInfo>
281 extern const std::string NET_MESSAGE_COMMAND_OTHER;
282 // Command, total bytes
283 typedef std::map<std::string, uint64_t> mapMsgCmdSize;
290 struct CNodeStats {
292  std::chrono::seconds m_last_send;
293  std::chrono::seconds m_last_recv;
294  std::chrono::seconds m_last_tx_time;
295  std::chrono::seconds m_last_proof_time;
296  std::chrono::seconds m_last_block_time;
297  std::chrono::seconds m_connected;
298  int64_t nTimeOffset;
299  std::string m_addr_name;
300  int nVersion;
301  std::string cleanSubVer;
302  bool fInbound;
306  uint64_t nSendBytes;
308  uint64_t nRecvBytes;
311  std::chrono::microseconds m_last_ping_time;
312  std::chrono::microseconds m_min_ping_time;
313  // Our address, as reported by the peer
314  std::string addrLocal;
315  // Address of this peer
317  // Bind address of our side of the connection
319  // Network the peer connected through
321  uint32_t m_mapped_as;
323  std::optional<double> m_availabilityScore;
324 };
331 class CNetMessage {
332 public:
336  std::chrono::microseconds m_time{0};
337  bool m_valid_netmagic = false;
338  bool m_valid_header = false;
339  bool m_valid_checksum = false;
341  uint32_t m_message_size{0};
343  uint32_t m_raw_message_size{0};
344  std::string m_type;
346  CNetMessage(CDataStream &&recv_in) : m_recv(std::move(recv_in)) {}
348  void SetVersion(int nVersionIn) { m_recv.SetVersion(nVersionIn); }
349 };
357 public:
358  // returns true if the current deserialization is complete
359  virtual bool Complete() const = 0;
360  // set the serialization context version
361  virtual void SetVersion(int version) = 0;
363  virtual int Read(const Config &config, Span<const uint8_t> &msg_bytes) = 0;
364  // decomposes a message from the context
365  virtual CNetMessage GetMessage(const Config &config,
366  std::chrono::microseconds time) = 0;
368 };
371 private:
372  mutable CHash256 hasher;
375  // Parsing header (false) or data (true)
376  bool in_data;
377  // Partially received header.
379  // Complete header.
381  // Received message data.
383  uint32_t nHdrPos;
384  uint32_t nDataPos;
386  const uint256 &GetMessageHash() const;
387  int readHeader(const Config &config, Span<const uint8_t> msg_bytes);
388  int readData(Span<const uint8_t> msg_bytes);
390  void Reset() {
391  vRecv.clear();
392  hdrbuf.clear();
393  hdrbuf.resize(24);
394  in_data = false;
395  nHdrPos = 0;
396  nDataPos = 0;
397  data_hash.SetNull();
398  hasher.Reset();
399  }
401 public:
403  const CMessageHeader::MessageMagic &pchMessageStartIn, int nTypeIn,
404  int nVersionIn)
405  : hdrbuf(nTypeIn, nVersionIn), hdr(pchMessageStartIn),
406  vRecv(nTypeIn, nVersionIn) {
407  Reset();
408  }
410  bool Complete() const override {
411  if (!in_data) {
412  return false;
413  }
415  return (hdr.nMessageSize == nDataPos);
416  }
418  void SetVersion(int nVersionIn) override {
419  hdrbuf.SetVersion(nVersionIn);
420  vRecv.SetVersion(nVersionIn);
421  }
422  int Read(const Config &config, Span<const uint8_t> &msg_bytes) override {
423  int ret = in_data ? readData(msg_bytes) : readHeader(config, msg_bytes);
424  if (ret < 0) {
425  Reset();
426  } else {
427  msg_bytes = msg_bytes.subspan(ret);
428  }
429  return ret;
430  }
432  CNetMessage GetMessage(const Config &config,
433  std::chrono::microseconds time) override;
434 };
440 public:
441  // prepare message for transport (header construction, error-correction
442  // computation, payload encryption, etc.)
443  virtual void prepareForTransport(const Config &config,
444  CSerializedNetMsg &msg,
445  std::vector<uint8_t> &header) = 0;
446  virtual ~TransportSerializer() {}
447 };
450 public:
451  void prepareForTransport(const Config &config, CSerializedNetMsg &msg,
452  std::vector<uint8_t> &header) override;
453 };
456 class CNode {
457  friend class CConnman;
458  friend struct ConnmanTestMsg;
460 public:
461  std::unique_ptr<TransportDeserializer> m_deserializer;
462  std::unique_ptr<TransportSerializer> m_serializer;
464  // socket
467  size_t nSendSize GUARDED_BY(cs_vSend){0};
469  size_t nSendOffset GUARDED_BY(cs_vSend){0};
470  uint64_t nSendBytes GUARDED_BY(cs_vSend){0};
471  std::deque<std::vector<uint8_t>> vSendMsg GUARDED_BY(cs_vSend);
477  std::list<CNetMessage> vProcessMsg GUARDED_BY(cs_vProcessMsg);
478  size_t nProcessQueueSize{0};
480  uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0};
482  std::atomic<std::chrono::seconds> m_last_send{0s};
483  std::atomic<std::chrono::seconds> m_last_recv{0s};
485  const std::chrono::seconds m_connected;
486  std::atomic<int64_t> nTimeOffset{0};
487  // Address of this peer
488  const CAddress addr;
489  // Bind address of our side of the connection
491  const std::string m_addr_name;
494  const bool m_inbound_onion;
495  std::atomic<int> nVersion{0};
496  // The nonce provided by the remote host.
497  uint64_t nRemoteHostNonce{0};
498  // The extra entropy provided by the remote host.
499  uint64_t nRemoteExtraEntropy{0};
505  std::string cleanSubVer GUARDED_BY(m_subver_mutex){};
506  // This peer is preferred for eviction.
507  bool m_prefer_evict{false};
508  bool HasPermission(NetPermissionFlags permission) const {
509  return NetPermissions::HasFlag(m_permissionFlags, permission);
510  }
511  std::atomic_bool fSuccessfullyConnected{false};
512  // Setting fDisconnect to true will cause the node to be disconnected the
513  // next time DisconnectNodes() runs
514  std::atomic_bool fDisconnect{false};
516  std::atomic<int> nRefCount{0};
518  const uint64_t nKeyedNetGroup;
519  std::atomic_bool fPauseRecv{false};
520  std::atomic_bool fPauseSend{false};
523  switch (m_conn_type) {
527  return true;
532  return false;
533  } // no default case, so the compiler can warn about missing cases
535  assert(false);
536  }
538  bool IsFullOutboundConn() const {
541  }
543  bool IsManualConn() const { return m_conn_type == ConnectionType::MANUAL; }
545  bool IsBlockOnlyConn() const {
547  }
549  bool IsFeelerConn() const { return m_conn_type == ConnectionType::FEELER; }
551  bool IsAddrFetchConn() const {
553  }
555  bool IsInboundConn() const {
557  }
561  }
563  bool ExpectServicesFromConn() const {
564  switch (m_conn_type) {
568  return false;
573  return true;
574  } // no default case, so the compiler can warn about missing cases
576  assert(false);
577  }
592  // We selected peer as (compact blocks) high-bandwidth peer (BIP152)
593  std::atomic<bool> m_bip152_highbandwidth_to{false};
594  // Peer selected us as (compact blocks) high-bandwidth peer (BIP152)
595  std::atomic<bool> m_bip152_highbandwidth_from{false};
601  std::atomic_bool m_has_all_wanted_services{false};
609  std::atomic_bool m_relays_txs{false};
615  std::atomic_bool m_bloom_filter_loaded{false};
617  // True if we know this peer is using Avalanche (at least polling)
618  std::atomic<bool> m_avalanche_enabled{false};
621  // Pubkey used to verify signatures on Avalanche messages from this peer
622  std::optional<CPubKey> m_avalanche_pubkey GUARDED_BY(cs_avalanche_pubkey);
625  void invsPolled(uint32_t count);
628  void invsVoted(uint32_t count);
646  void updateAvailabilityScore(double decayFactor);
647  double getAvailabilityScore() const;
649  // Store the next time we will consider a getavaaddr message from this peer
650  std::chrono::seconds m_nextGetAvaAddr{0};
652  // The last time the node sent us a faulty message
653  std::atomic<std::chrono::seconds> m_avalanche_last_message_fault{0s};
654  // How much faulty messages did this node accumulate
666  std::atomic<std::chrono::seconds> m_last_block_time{0s};
674  std::atomic<std::chrono::seconds> m_last_tx_time{0s};
682  std::atomic<std::chrono::seconds> m_last_proof_time{0s};
685  std::atomic<std::chrono::microseconds> m_last_ping_time{0us};
691  std::atomic<std::chrono::microseconds> m_min_ping_time{
692  std::chrono::microseconds::max()};
694  CNode(NodeId id, SOCKET hSocketIn, const CAddress &addrIn,
695  uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn,
696  uint64_t nLocalExtraEntropyIn, const CAddress &addrBindIn,
697  const std::string &addrNameIn, ConnectionType conn_type_in,
698  bool inbound_onion);
699  ~CNode();
700  CNode(const CNode &) = delete;
701  CNode &operator=(const CNode &) = delete;
707  void PongReceived(std::chrono::microseconds ping_time) {
708  m_last_ping_time = ping_time;
709  m_min_ping_time = std::min(m_min_ping_time.load(), ping_time);
710  }
712  NodeId GetId() const { return id; }
714  uint64_t GetLocalNonce() const { return nLocalHostNonce; }
715  uint64_t GetLocalExtraEntropy() const { return nLocalExtraEntropy; }
717  int GetRefCount() const {
718  assert(nRefCount >= 0);
719  return nRefCount;
720  }
731  bool ReceiveMsgBytes(const Config &config, Span<const uint8_t> msg_bytes,
732  bool &complete) EXCLUSIVE_LOCKS_REQUIRED(!cs_vRecv);
734  void SetCommonVersion(int greatest_common_version) {
736  m_greatest_common_version = greatest_common_version;
737  }
742  void SetAddrLocal(const CService &addrLocalIn)
746  nRefCount++;
747  return this;
748  }
750  void Release() { nRefCount--; }
754  void copyStats(CNodeStats &stats)
758  std::string ConnectionTypeAsString() const {
760  }
762 private:
763  const NodeId id;
764  const uint64_t nLocalHostNonce;
765  const uint64_t nLocalExtraEntropy;
770  // Used only by SocketHandler thread
771  std::list<CNetMessage> vRecvMsg;
773  // Our address, as reported by the peer
782  std::atomic<uint64_t> invCounters{0};
785  std::atomic<double> availabilityScore{0.};
787  mapMsgCmdSize mapSendBytesPerMsgCmd GUARDED_BY(cs_vSend);
788  mapMsgCmdSize mapRecvBytesPerMsgCmd GUARDED_BY(cs_vRecv);
789 };
795 public:
802  virtual void InitializeNode(const Config &config, CNode &node,
803  ServiceFlags our_services) = 0;
806  virtual void FinalizeNode(const Config &config, const CNode &node) = 0;
817  virtual bool ProcessMessages(const Config &config, CNode *pnode,
818  std::atomic<bool> &interrupt)
828  virtual bool SendMessages(const Config &config, CNode *pnode)
831 protected:
837  ~NetEventsInterface() = default;
838 };
840 namespace {
841 struct CConnmanTest;
842 }
844 class NetEventsInterface;
845 class CConnman {
846 public:
849  CONNECTIONS_IN = (1U << 0),
850  CONNECTIONS_OUT = (1U << 1),
852  };
854  struct Options {
860  int nMaxAddnode = 0;
861  int nMaxFeeler = 0;
863  std::vector<NetEventsInterface *> m_msgproc;
864  BanMan *m_banman = nullptr;
865  unsigned int nSendBufferMaxSize = 0;
866  unsigned int nReceiveFloodSize = 0;
867  uint64_t nMaxOutboundLimit = 0;
869  std::vector<std::string> vSeedNodes;
870  std::vector<NetWhitelistPermissions> vWhitelistedRange;
871  std::vector<NetWhitebindPermissions> vWhiteBinds;
872  std::vector<CService> vBinds;
873  std::vector<CService> onion_binds;
878  std::vector<std::string> m_specified_outgoing;
879  std::vector<std::string> m_added_nodes;
881  };
883  void Init(const Options &connOptions)
885  nLocalServices = connOptions.nLocalServices;
886  nMaxConnections = connOptions.nMaxConnections;
887  m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing;
888  nMaxAddnode = connOptions.nMaxAddnode;
889  nMaxFeeler = connOptions.nMaxFeeler;
890  {
891  // Lock cs_main to prevent a potential race with the peer validation
892  // logic thread.
893  LOCK(::cs_main);
895  std::min(connOptions.m_max_outbound_full_relay,
896  connOptions.nMaxConnections);
897  m_max_avalanche_outbound = connOptions.m_max_avalanche_outbound;
898  m_max_outbound_block_relay = connOptions.m_max_outbound_block_relay;
902  }
903  m_client_interface = connOptions.uiInterface;
904  m_banman = connOptions.m_banman;
905  m_msgproc = connOptions.m_msgproc;
906  nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
907  nReceiveFloodSize = connOptions.nReceiveFloodSize;
909  std::chrono::seconds{connOptions.m_peer_connect_timeout};
910  {
912  nMaxOutboundLimit = connOptions.nMaxOutboundLimit;
913  }
914  vWhitelistedRange = connOptions.vWhitelistedRange;
915  {
917  m_added_nodes = connOptions.m_added_nodes;
918  }
919  m_onion_binds = connOptions.onion_binds;
920  }
922  CConnman(const Config &configIn, uint64_t seed0, uint64_t seed1,
923  AddrMan &addrmanIn, bool network_active = true);
924  ~CConnman();
926  bool Start(CScheduler &scheduler, const Options &options)
930  void StopThreads();
931  void StopNodes();
932  void Stop() {
933  StopThreads();
934  StopNodes();
935  };
938  bool GetNetworkActive() const { return fNetworkActive; };
940  void SetNetworkActive(bool active);
941  void OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure,
942  CSemaphoreGrant *grantOutbound,
943  const char *strDest, ConnectionType conn_type);
944  bool CheckIncomingNonce(uint64_t nonce);
946  bool ForNode(NodeId id, std::function<bool(CNode *pnode)> func);
948  void PushMessage(CNode *pnode, CSerializedNetMsg &&msg);
950  using NodeFn = std::function<void(CNode *)>;
951  void ForEachNode(const NodeFn &func) {
953  for (auto &&node : m_nodes) {
954  if (NodeFullyConnected(node)) {
955  func(node);
956  }
957  }
958  };
960  void ForEachNode(const NodeFn &func) const {
962  for (auto &&node : m_nodes) {
963  if (NodeFullyConnected(node)) {
964  func(node);
965  }
966  }
967  };
969  // Addrman functions
980  std::vector<CAddress> GetAddresses(size_t max_addresses, size_t max_pct,
981  std::optional<Network> network) const;
988  std::vector<CAddress> GetAddresses(CNode &requestor, size_t max_addresses,
989  size_t max_pct);
991  // This allows temporarily exceeding m_max_outbound_full_relay, with the
992  // goal of finding a peer that is better than all our current peers.
993  void SetTryNewOutboundPeer(bool flag);
994  bool GetTryNewOutboundPeer() const;
997  LogPrint(BCLog::NET, "net: enabling extra block-relay-only peers\n");
999  }
1001  // Return the number of outbound peers we have in excess of our target (eg,
1002  // if we previously called SetTryNewOutboundPeer(true), and have since set
1003  // to false, we may have extra peers that we wish to disconnect). This may
1004  // return a value less than (num_outbound_connections - num_outbound_slots)
1005  // in cases where some outbound connections are not yet fully connected, or
1006  // not yet fully disconnected.
1007  int GetExtraFullOutboundCount() const;
1008  // Count the number of block-relay-only peers we have over our limit.
1009  int GetExtraBlockRelayCount() const;
1011  bool AddNode(const std::string &node)
1013  bool RemoveAddedNode(const std::string &node)
1015  std::vector<AddedNodeInfo> GetAddedNodeInfo() const
1032  bool AddConnection(const std::string &address, ConnectionType conn_type);
1034  size_t GetNodeCount(NumConnections num) const;
1035  void GetNodeStats(std::vector<CNodeStats> &vstats) const;
1036  bool DisconnectNode(const std::string &node);
1037  bool DisconnectNode(const CSubNet &subnet);
1038  bool DisconnectNode(const CNetAddr &addr);
1039  bool DisconnectNode(NodeId id);
1049  uint64_t GetMaxOutboundTarget() const;
1050  std::chrono::seconds GetMaxOutboundTimeframe() const;
1055  bool OutboundTargetReached(bool historicalBlockServingLimit) const;
1059  uint64_t GetOutboundTargetBytesLeft() const;
1063  std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const;
1065  uint64_t GetTotalBytesRecv() const;
1066  uint64_t GetTotalBytesSent() const;
1069  CSipHasher GetDeterministicRandomizer(uint64_t id) const;
1071  unsigned int GetReceiveFloodSize() const;
1079  bool ShouldRunInactivityChecks(const CNode &node,
1080  std::chrono::seconds now) const;
1082 private:
1083  struct ListenSocket {
1084  public:
1087  NetPermissions::AddFlag(flags, m_permissions);
1088  }
1089  ListenSocket(SOCKET socket_, NetPermissionFlags permissions_)
1090  : socket(socket_), m_permissions(permissions_) {}
1092  private:
1094  };
1096  bool BindListenPort(const CService &bindAddr, bilingual_str &strError,
1097  NetPermissionFlags permissions);
1098  bool Bind(const CService &addr, unsigned int flags,
1099  NetPermissionFlags permissions);
1100  bool InitBinds(const Options &options);
1104  void AddAddrFetch(const std::string &strDest)
1107  void
1108  ThreadOpenConnections(std::vector<std::string> connect,
1109  std::function<void(const CAddress &, ConnectionType)>
1110  mockOpenConnection)
1114  void ThreadI2PAcceptIncoming();
1115  void AcceptConnection(const ListenSocket &hListenSocket);
1125  void CreateNodeFromAcceptedSocket(SOCKET hSocket,
1126  NetPermissionFlags permissionFlags,
1127  const CAddress &addr_bind,
1128  const CAddress &addr);
1130  void DisconnectNodes();
1133  bool InactivityCheck(const CNode &node) const;
1134  bool GenerateSelectSet(std::set<SOCKET> &recv_set,
1135  std::set<SOCKET> &send_set,
1136  std::set<SOCKET> &error_set);
1137  void SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set,
1138  std::set<SOCKET> &error_set);
1141  void ThreadDNSAddressSeed()
1144  uint64_t CalculateKeyedNetGroup(const CAddress &ad) const;
1146  CNode *FindNode(const CNetAddr &ip);
1147  CNode *FindNode(const CSubNet &subNet);
1148  CNode *FindNode(const std::string &addrName);
1149  CNode *FindNode(const CService &addr);
1155  bool AlreadyConnectedToAddress(const CAddress &addr);
1157  bool AttemptToEvictConnection();
1158  CNode *ConnectNode(CAddress addrConnect, const char *pszDest,
1159  bool fCountFailure, ConnectionType conn_type);
1161  const CNetAddr &addr) const;
1163  void DeleteNode(CNode *pnode);
1165  NodeId GetNewNodeId();
1167  size_t SocketSendData(CNode &node) const
1168  EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend);
1169  void DumpAddresses();
1171  // Network stats
1172  void RecordBytesRecv(uint64_t bytes);
1173  void RecordBytesSent(uint64_t bytes);
1178  std::vector<CAddress> GetCurrentBlockRelayOnlyConns() const;
1180  // Whether the node should be passed out in ForEach* callbacks
1181  static bool NodeFullyConnected(const CNode *pnode);
1183  const Config *config;
1185  // Network usage totals
1187  std::atomic<uint64_t> nTotalBytesRecv{0};
1188  uint64_t nTotalBytesSent GUARDED_BY(cs_totalBytesSent){0};
1190  // outbound limit & stats
1191  uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(cs_totalBytesSent){0};
1192  std::chrono::seconds
1193  nMaxOutboundCycleStartTime GUARDED_BY(cs_totalBytesSent){0};
1194  uint64_t nMaxOutboundLimit GUARDED_BY(cs_totalBytesSent);
1196  // P2P timeout in seconds
1197  std::chrono::seconds m_peer_connect_timeout;
1199  // Whitelisted ranges. Any node connecting from these is automatically
1200  // whitelisted (as well as those connecting to whitelisted binds).
1201  std::vector<NetWhitelistPermissions> vWhitelistedRange;
1203  unsigned int nSendBufferMaxSize{0};
1204  unsigned int nReceiveFloodSize{0};
1206  std::vector<ListenSocket> vhListenSocket;
1207  std::atomic<bool> fNetworkActive{true};
1210  std::deque<std::string> m_addr_fetches GUARDED_BY(m_addr_fetches_mutex);
1212  std::vector<std::string> m_added_nodes GUARDED_BY(m_added_nodes_mutex);
1214  std::vector<CNode *> m_nodes GUARDED_BY(m_nodes_mutex);
1215  std::list<CNode *> m_nodes_disconnected;
1217  std::atomic<NodeId> nLastNodeId{0};
1218  unsigned int nPrevNodeCount{0};
1227  std::vector<CAddress> m_addrs_response_cache;
1228  std::chrono::microseconds m_cache_entry_expiration{0};
1229  };
1245  std::map<uint64_t, CachedAddrResponse> m_addr_response_caches;
1259  std::unique_ptr<CSemaphore> semOutbound;
1260  std::unique_ptr<CSemaphore> semAddnode;
1263  // How many full-relay (tx, block, addr) outbound peers we want
1266  // How many block-relay only outbound peers we want
1267  // We do not relay tx or addr messages with these peers
1270  // How many avalanche enabled outbound peers we want
1278  // FIXME m_msgproc is a terrible name
1279  std::vector<NetEventsInterface *> m_msgproc;
1290  std::vector<CAddress> m_anchors;
1293  const uint64_t nSeed0, nSeed1;
1296  bool fMsgProcWake GUARDED_BY(mutexMsgProc);
1298  std::condition_variable condMsgProc;
1300  std::atomic<bool> flagInterruptMsgProc{false};
1314  std::unique_ptr<i2p::sam::Session> m_i2p_sam_session;
1317  std::thread threadSocketHandler;
1334  std::atomic_bool m_start_extra_block_relay_peers{false};
1340  std::vector<CService> m_onion_binds;
1342  friend struct ::CConnmanTest;
1343  friend struct ConnmanTestMsg;
1344 };
1346 std::string getSubVersionEB(uint64_t MaxBlockSize);
1347 std::string userAgent(const Config &config);
1350 void CaptureMessageToFile(const CAddress &addr, const std::string &msg_type,
1351  Span<const uint8_t> data, bool is_incoming);
1356 extern std::function<void(const CAddress &addr, const std::string &msg_type,
1357  Span<const uint8_t> data, bool is_incoming)>
1362  std::chrono::seconds m_connected;
1363  std::chrono::microseconds m_min_ping_time;
1364  std::chrono::seconds m_last_block_time;
1365  std::chrono::seconds m_last_proof_time;
1366  std::chrono::seconds m_last_tx_time;
1370  uint64_t nKeyedNetGroup;
1375 };
1384 [[nodiscard]] std::optional<NodeId>
1385 SelectNodeToEvict(std::vector<NodeEvictionCandidate> &&vEvictionCandidates);
1410  std::vector<NodeEvictionCandidate> &vEvictionCandidates);
1412 #endif // BITCOIN_NET_H
int flags
Definition: bitcoin-tx.cpp:533
#define Assume(val)
Assume is the identity function.
Definition: check.h:97
Stochastic address manager.
Definition: addrman.h:69
Definition: banman.h:58
A CService with information about it as peer.
Definition: protocol.h:442
Signals for UI communication.
Definition: ui_interface.h:24
Definition: net.h:845
void CreateNodeFromAcceptedSocket(SOCKET hSocket, NetPermissionFlags permissionFlags, const CAddress &addr_bind, const CAddress &addr)
Create a CNode object from a socket that has just been accepted and add the node to the m_nodes membe...
Definition: net.cpp:1291
std::condition_variable condMsgProc
Definition: net.h:1298
size_t GetNodeCount(NumConnections num) const
Definition: net.cpp:3249
uint64_t nTotalBytesSent GUARDED_BY(cs_totalBytesSent)
Definition: net.h:1188
std::chrono::seconds nMaxOutboundCycleStartTime GUARDED_BY(cs_totalBytesSent)
Definition: net.h:1193
std::thread threadMessageHandler
Definition: net.h:1320
void ForEachNode(const NodeFn &func)
Definition: net.h:951
std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const
returns the time in second left in the current max outbound cycle in case of no limit,...
Definition: net.cpp:3351
bool OutboundTargetReached(bool historicalBlockServingLimit) const
check if the outbound target is reached.
Definition: net.cpp:3367
CClientUIInterface * m_client_interface
Definition: net.h:1277
size_t SocketSendData(CNode &node) const EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend)
Definition: net.cpp:822
void ThreadMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
Definition: net.cpp:2610
void ForEachNode(const NodeFn &func) const
Definition: net.h:960
bool ForNode(NodeId id, std::function< bool(CNode *pnode)> func)
Definition: net.cpp:3539
bool AddConnection(const std::string &address, ConnectionType conn_type)
Attempts to open a connection.
Definition: net.cpp:1414
CNode * ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type)
Definition: net.cpp:422
void DeleteNode(CNode *pnode)
Definition: net.cpp:3145
bool RemoveAddedNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:3237
bool AttemptToEvictConnection()
Try to find a connection to evict when the node is full.
Definition: net.cpp:1209
bool GetNetworkActive() const
Definition: net.h:938
bool AlreadyConnectedToAddress(const CAddress &addr)
Determine whether we're already connected to a given address, in order to avoid initiating duplicate ...
Definition: net.cpp:390
int m_max_outbound
Definition: net.h:1275
ServiceFlags nLocalServices
Services this node offers.
Definition: net.h:1257
bool GetTryNewOutboundPeer() const
Definition: net.cpp:2069
void Stop()
Definition: net.h:932
int m_max_outbound_block_relay
Definition: net.h:1268
std::thread threadI2PAcceptIncoming
Definition: net.h:1321
void SetTryNewOutboundPeer(bool flag)
Definition: net.cpp:2073
std::atomic< bool > flagInterruptMsgProc
Definition: net.h:1300
unsigned int GetReceiveFloodSize() const
Definition: net.cpp:3414
void ThreadOpenAddedConnections() EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:2529
void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
Definition: net.cpp:3056
void ThreadDNSAddressSeed() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex
Definition: net.cpp:1907
void SocketEvents(std::set< SOCKET > &recv_set, std::set< SOCKET > &send_set, std::set< SOCKET > &error_set)
Definition: net.cpp:1677
NodeId GetNewNodeId()
Definition: net.cpp:2867
CThreadInterrupt interruptNet
This is signaled when network activity should cease.
Definition: net.h:1308
std::unique_ptr< CSemaphore > semAddnode
Definition: net.h:1260
bool Start(CScheduler &scheduler, const Options &options) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex
Definition: net.cpp:2920
std::atomic< NodeId > nLastNodeId
Definition: net.h:1217
void RecordBytesSent(uint64_t bytes)
Definition: net.cpp:3327
bool fMsgProcWake GUARDED_BY(mutexMsgProc)
flag for waking the message processor.
std::vector< std::string > m_added_nodes GUARDED_BY(m_added_nodes_mutex)
int GetExtraBlockRelayCount() const
Definition: net.cpp:2101
void WakeMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
Definition: net.cpp:1899
BanMan * m_banman
Pointer to this node's banman.
Definition: net.h:1284
uint64_t GetOutboundTargetBytesLeft() const
response the bytes left in the current max outbound cycle in case of no limit, it will always respons...
Definition: net.cpp:3390
std::thread threadDNSAddressSeed
Definition: net.h:1316
void ThreadI2PAcceptIncoming()
Definition: net.cpp:2676
const uint64_t nSeed1
Definition: net.h:1293
void StartExtraBlockRelayPeers()
Definition: net.h:996
std::vector< CAddress > m_anchors
Addresses that were saved during the previous clean shutdown.
Definition: net.h:1290
std::chrono::seconds GetMaxOutboundTimeframe() const
Definition: net.cpp:3347
friend struct ConnmanTestMsg
Definition: net.h:1343
unsigned int nPrevNodeCount
Definition: net.h:1218
void NotifyNumConnectionsChanged()
Definition: net.cpp:1513
ServiceFlags GetLocalServices() const
Used to convey which local services we are offering peers during node connection.
Definition: net.cpp:3410
bool DisconnectNode(const std::string &node)
Definition: net.cpp:3278
std::chrono::seconds m_peer_connect_timeout
Definition: net.h:1197
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.
Definition: net.h:1327
bool InitBinds(const Options &options)
Definition: net.cpp:2893
void AddAddrFetch(const std::string &strDest) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex)
Definition: net.cpp:131
uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(cs_totalBytesSent)
Definition: net.h:1191
std::vector< ListenSocket > vhListenSocket
Definition: net.h:1206
std::vector< CAddress > GetCurrentBlockRelayOnlyConns() const
Return vector of current BLOCK_RELAY peers.
Definition: net.cpp:2460
CSipHasher GetDeterministicRandomizer(uint64_t id) const
Get a unique deterministic randomizer.
Definition: net.cpp:3551
uint64_t GetMaxOutboundTarget() const
Definition: net.cpp:3342
std::unique_ptr< CSemaphore > semOutbound
Definition: net.h:1259
std::vector< NetWhitelistPermissions > vWhitelistedRange
Definition: net.h:1201
RecursiveMutex cs_totalBytesSent
Definition: net.h:1186
bool Bind(const CService &addr, unsigned int flags, NetPermissionFlags permissions)
Definition: net.cpp:2871
std::thread threadOpenConnections
Definition: net.h:1319
Definition: net.h:847
Definition: net.h:849
Definition: net.h:848
Definition: net.h:851
Definition: net.h:850
Mutex m_addr_fetches_mutex
Definition: net.h:1211
bool InactivityCheck(const CNode &node) const
Return true if the peer is inactive and should be disconnected.
Definition: net.cpp:1532
CNode * FindNode(const CNetAddr &ip)
Definition: net.cpp:350
void GetNodeStats(std::vector< CNodeStats > &vstats) const
Definition: net.cpp:3267
std::vector< AddedNodeInfo > GetAddedNodeInfo() const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:2472
const uint64_t nSeed0
SipHasher seeds for deterministic randomness.
Definition: net.h:1293
unsigned int nReceiveFloodSize
Definition: net.h:1204
int GetExtraFullOutboundCount() const
Definition: net.cpp:2085
uint64_t GetTotalBytesRecv() const
Definition: net.cpp:3401
RecursiveMutex m_nodes_mutex
Definition: net.h:1216
static bool NodeFullyConnected(const CNode *pnode)
Definition: net.cpp:3490
void ProcessAddrFetch() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex)
Definition: net.cpp:2051
int nMaxConnections
Definition: net.h:1261
CConnman(const Config &configIn, uint64_t seed0, uint64_t seed1, AddrMan &addrmanIn, bool network_active=true)
Definition: net.cpp:2856
std::vector< CAddress > GetAddresses(size_t max_addresses, size_t max_pct, std::optional< Network > network) const
Return all or many randomly selected addresses, optionally by network.
Definition: net.cpp:3159
std::deque< std::string > m_addr_fetches GUARDED_BY(m_addr_fetches_mutex)
std::function< void(CNode *)> NodeFn
Definition: net.h:950
void SetNetworkActive(bool active)
Definition: net.cpp:2842
std::list< CNode * > m_nodes_disconnected
Definition: net.h:1215
void OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *strDest, ConnectionType conn_type)
Definition: net.cpp:2561
void AddWhitelistPermissionFlags(NetPermissionFlags &flags, const CNetAddr &addr) const
Definition: net.cpp:566
bool GenerateSelectSet(std::set< SOCKET > &recv_set, std::set< SOCKET > &send_set, std::set< SOCKET > &error_set)
Definition: net.cpp:1572
AddrMan & addrman
Definition: net.h:1209
void SocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
Definition: net.cpp:1760
uint64_t CalculateKeyedNetGroup(const CAddress &ad) const
Definition: net.cpp:3555
Mutex mutexMsgProc
Definition: net.h:1299
bool fAddressesInitialized
Definition: net.h:1208
Definition: net.cpp:3153
void StopThreads()
Definition: net.cpp:3079
bool AddNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:3225
std::thread threadOpenAddedConnections
Definition: net.h:1318
Mutex m_added_nodes_mutex
Definition: net.h:1213
std::vector< CNode * > m_nodes GUARDED_BY(m_nodes_mutex)
const Config * config
Definition: net.h:1183
void Init(const Options &connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.h:883
bool CheckIncomingNonce(uint64_t nonce)
Definition: net.cpp:395
int m_max_outbound_full_relay
Definition: net.h:1264
int nMaxAddnode
Definition: net.h:1273
void RecordBytesRecv(uint64_t bytes)
Definition: net.cpp:3323
bool ShouldRunInactivityChecks(const CNode &node, std::chrono::seconds now) const
Return true if we should disconnect the peer for failing an inactivity check.
Definition: net.cpp:1527
void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
Definition: net.cpp:1891
void PushMessage(CNode *pnode, CSerializedNetMsg &&msg)
Definition: net.cpp:3494
void StopNodes()
Definition: net.cpp:3100
bool GetUseAddrmanOutgoing() const
Definition: net.h:939
unsigned int nSendBufferMaxSize
Definition: net.h:1203
std::unique_ptr< i2p::sam::Session > m_i2p_sam_session
I2P SAM session.
Definition: net.h:1314
bool m_use_addrman_outgoing
Definition: net.h:1276
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:1245
uint64_t nMaxOutboundLimit GUARDED_BY(cs_totalBytesSent)
std::atomic< uint64_t > nTotalBytesRecv
Definition: net.h:1187
std::atomic< bool > fNetworkActive
Definition: net.h:1207
std::atomic_bool m_start_extra_block_relay_peers
flag for initiating extra block-relay-only peer connections.
Definition: net.h:1334
void DisconnectNodes()
Definition: net.cpp:1463
void DumpAddresses()
Definition: net.cpp:2042
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:1340
int nMaxFeeler
Definition: net.h:1274
std::vector< NetEventsInterface * > m_msgproc
Definition: net.h:1279
std::thread threadSocketHandler
Definition: net.h:1317
uint64_t GetTotalBytesSent() const
Definition: net.cpp:3405
void ThreadOpenConnections(std::vector< std::string > connect, std::function< void(const CAddress &, ConnectionType)> mockOpenConnection) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex
Definition: net.cpp:2115
void AcceptConnection(const ListenSocket &hListenSocket)
Definition: net.cpp:1263
bool BindListenPort(const CService &bindAddr, bilingual_str &strError, NetPermissionFlags permissions)
Definition: net.cpp:2714
int m_max_avalanche_outbound
Definition: net.h:1271
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:177
void SetVersion(int n)
Definition: streams.h:338
void resize(size_type n, value_type c=value_type{})
Definition: streams.h:225
void clear()
Definition: streams.h:233
A hasher class for Bitcoin's 256-bit hash (double SHA-256).
Definition: hash.h:22
CHash256 & Reset()
Definition: hash.h:41
Message header.
Definition: protocol.h:34
uint32_t nMessageSize
Definition: protocol.h:71
std::array< uint8_t, MESSAGE_START_SIZE > MessageMagic
Definition: protocol.h:46
Network address.
Definition: netaddress.h:121
Transport protocol agnostic message container.
Definition: net.h:331
CNetMessage(CDataStream &&recv_in)
Definition: net.h:346
uint32_t m_message_size
size of the payload
Definition: net.h:341
std::chrono::microseconds m_time
time of message receipt
Definition: net.h:336
CDataStream m_recv
received message data
Definition: net.h:334
void SetVersion(int nVersionIn)
Definition: net.h:348
uint32_t m_raw_message_size
used wire size of the message (including header/checksum)
Definition: net.h:343
std::string m_type
Definition: net.h:344
bool m_valid_checksum
Definition: net.h:339
bool m_valid_header
Definition: net.h:338
bool m_valid_netmagic
Definition: net.h:337
Information about a peer.
Definition: net.h:456
RecursiveMutex cs_vProcessMsg
Definition: net.h:476
Mutex cs_avalanche_pubkey
Definition: net.h:620
const CAddress addrBind
Definition: net.h:490
bool IsFeelerConn() const
Definition: net.h:549
mapMsgCmdSize mapSendBytesPerMsgCmd GUARDED_BY(cs_vSend)
const std::chrono::seconds m_connected
Unix epoch time at peer connection.
Definition: net.h:485
bool ExpectServicesFromConn() const
Definition: net.h:563
bool m_prefer_evict
Definition: net.h:507
std::atomic< int > nVersion
Definition: net.h:495
std::atomic_bool m_has_all_wanted_services
Whether this peer provides all services that we want.
Definition: net.h:601
uint64_t nRecvBytes GUARDED_BY(cs_vRecv)
Definition: net.h:480
std::atomic< double > availabilityScore
The last computed score.
Definition: net.h:785
bool IsInboundConn() const
Definition: net.h:555
bool HasPermission(NetPermissionFlags permission) const
Definition: net.h:508
std::atomic_bool fPauseRecv
Definition: net.h:519
bool IsOutboundOrBlockRelayConn() const
Definition: net.h:522
NodeId GetId() const
Definition: net.h:712
bool IsManualConn() const
Definition: net.h:543
std::atomic< int64_t > nTimeOffset
Definition: net.h:486
const std::string m_addr_name
Definition: net.h:491
mapMsgCmdSize mapRecvBytesPerMsgCmd GUARDED_BY(cs_vRecv)
std::string ConnectionTypeAsString() const
Definition: net.h:758
std::deque< std::vector< uint8_t > > vSendMsg GUARDED_BY(cs_vSend)
void SetCommonVersion(int greatest_common_version)
Definition: net.h:734
std::atomic< bool > m_bip152_highbandwidth_to
Definition: net.h:593
std::list< CNetMessage > vRecvMsg
Definition: net.h:771
size_t nProcessQueueSize
Definition: net.h:478
std::atomic_bool m_relays_txs
Whether we should relay transactions to this peer (their version message did not include fRelay=false...
Definition: net.h:609
std::atomic< bool > m_bip152_highbandwidth_from
Definition: net.h:595
void PongReceived(std::chrono::microseconds ping_time)
A ping-pong round trip has completed successfully.
Definition: net.h:707
std::atomic_bool fSuccessfullyConnected
Definition: net.h:511
bool IsAddrFetchConn() const
Definition: net.h:551
uint64_t GetLocalNonce() const
Definition: net.h:714
const CAddress addr
Definition: net.h:488
void SetAddrLocal(const CService &addrLocalIn) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex)
May not be called more than once.
Definition: net.cpp:602
CSemaphoreGrant grantOutbound
Definition: net.h:515
Mutex cs_hSocket
Definition: net.h:473
const uint64_t nKeyedNetGroup
Definition: net.h:518
friend struct ConnmanTestMsg
Definition: net.h:458
std::atomic< int > nRefCount
Definition: net.h:516
std::atomic< int > m_greatest_common_version
Definition: net.h:767
bool IsBlockOnlyConn() const
Definition: net.h:545
int GetCommonVersion() const
Definition: net.h:738
bool IsFullOutboundConn() const
Definition: net.h:538
uint64_t nRemoteHostNonce
Definition: net.h:497
std::unique_ptr< TransportSerializer > m_serializer
Definition: net.h:462
Mutex m_subver_mutex
cleanSubVer is a sanitized string of the user agent byte array we read from the wire.
Definition: net.h:504
Mutex cs_vSend
Definition: net.h:472
std::atomic_bool fPauseSend
Definition: net.h:520
SOCKET hSocket GUARDED_BY(cs_hSocket)
std::chrono::seconds m_nextGetAvaAddr
Definition: net.h:650
uint64_t nRemoteExtraEntropy
Definition: net.h:499
int GetRefCount() const
Definition: net.h:717
uint64_t GetLocalExtraEntropy() const
Definition: net.h:715
SteadyMilliseconds m_last_poll
Definition: net.h:657
std::list< CNetMessage > vProcessMsg GUARDED_BY(cs_vProcessMsg)
void CloseSocketDisconnect() EXCLUSIVE_LOCKS_REQUIRED(!cs_hSocket)
Definition: net.cpp:557
std::optional< CPubKey > m_avalanche_pubkey GUARDED_BY(cs_avalanche_pubkey)
std::unique_ptr< TransportDeserializer > m_deserializer
Definition: net.h:461
double getAvailabilityScore() const
Definition: net.cpp:3441
size_t nSendOffset GUARDED_BY(cs_vSend)
Offset inside the first vSendMsg already sent.
Definition: net.h:469
NetPermissionFlags m_permissionFlags
Definition: net.h:769
std::atomic_bool m_bloom_filter_loaded
Whether this peer has loaded a bloom filter.
Definition: net.h:615
CService addrLocal GUARDED_BY(m_addr_local_mutex)
const ConnectionType m_conn_type
Definition: net.h:766
Network ConnectedThroughNetwork() const
Get network the peer connected through.
Definition: net.cpp:614
void copyStats(CNodeStats &stats) EXCLUSIVE_LOCKS_REQUIRED(!m_subver_mutex
Definition: net.cpp:618
const uint64_t nLocalHostNonce
Definition: net.h:764
std::atomic< std::chrono::microseconds > m_last_ping_time
Last measured round-trip time.
Definition: net.h:685
void updateAvailabilityScore(double decayFactor)
The availability score is calculated using an exponentially weighted average.
Definition: net.cpp:3426
size_t nSendSize GUARDED_BY(cs_vSend)
Total size of all vSendMsg entries.
Definition: net.h:467
std::atomic< std::chrono::seconds > m_avalanche_last_message_fault
Definition: net.h:653
const uint64_t nLocalExtraEntropy
Definition: net.h:765
bool ReceiveMsgBytes(const Config &config, Span< const uint8_t > msg_bytes, bool &complete) EXCLUSIVE_LOCKS_REQUIRED(!cs_vRecv)
Receive bytes from the buffer and deserialize them into messages.
Definition: net.cpp:666
void invsPolled(uint32_t count)
The node was polled for count invs.
Definition: net.cpp:3418
Mutex m_addr_local_mutex
Definition: net.h:774
CNode(const CNode &)=delete
const bool m_inbound_onion
Whether this peer is an inbound onion, i.e.
Definition: net.h:494
std::atomic< std::chrono::microseconds > m_min_ping_time
Lowest measured round-trip time.
Definition: net.h:691
const NodeId id
Definition: net.h:763
std::atomic< int > m_avalanche_message_fault_counter
Definition: net.h:655
std::atomic< std::chrono::seconds > m_last_proof_time
UNIX epoch time of the last proof received from this peer that we had not yet seen (e....
Definition: net.h:682
Mutex cs_vRecv
Definition: net.h:474
std::atomic< bool > m_avalanche_enabled
Definition: net.h:618
std::atomic< std::chrono::seconds > m_last_block_time
UNIX epoch time of the last block received from this peer that we had not yet seen (e....
Definition: net.h:666
Definition: net.cpp:3486
uint64_t nSendBytes GUARDED_BY(cs_vSend)
Definition: net.h:470
std::atomic< uint64_t > invCounters
The inventories polled and voted counters since last score computation, stored as a pair of uint32_t ...
Definition: net.h:782
std::atomic_bool fDisconnect
Definition: net.h:514
std::atomic< std::chrono::seconds > m_last_recv
Definition: net.h:483
CNode(NodeId id, SOCKET hSocketIn, const CAddress &addrIn, uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn, uint64_t nLocalExtraEntropyIn, const CAddress &addrBindIn, const std::string &addrNameIn, ConnectionType conn_type_in, bool inbound_onion)
Definition: net.cpp:3447
std::atomic< std::chrono::seconds > m_last_tx_time
UNIX epoch time of the last transaction received from this peer that we had not yet seen (e....
Definition: net.h:674
CService GetAddrLocal() const EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex)
Definition: net.cpp:596
void invsVoted(uint32_t count)
The node voted for count invs.
Definition: net.cpp:3422
std::atomic< std::chrono::seconds > m_last_send
Definition: net.h:482
bool IsAvalancheOutboundConnection() const
Definition: net.h:559
void Release()
Definition: net.h:750
CNode & operator=(const CNode &)=delete
std::string cleanSubVer GUARDED_BY(m_subver_mutex)
Definition: net.h:505
CNode * AddRef()
Definition: net.h:745
Simple class for background tasks that should be run periodically or once "after a while".
Definition: scheduler.h:41
RAII-style semaphore lock.
Definition: sync.h:397
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:545
Definition: siphash.h:13
A helper class for interruptible sleeps.
Definition: config.h:17
Different type to mark Mutex at global scope.
Definition: sync.h:144
Interface for message handling.
Definition: net.h:794
static Mutex g_msgproc_mutex
Mutex for anything that is only accessed via the msg processing thread.
Definition: net.h:799
virtual bool ProcessMessages(const Config &config, CNode *pnode, std::atomic< bool > &interrupt) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex)=0
Process protocol messages received from a given node.
virtual bool SendMessages(const Config &config, CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex)=0
Send queued protocol messages to a given node.
virtual void InitializeNode(const Config &config, CNode &node, ServiceFlags our_services)=0
Initialize a peer (setup state, queue any initial messages)
Protected destructor so that instances can only be deleted by derived classes.
virtual void FinalizeNode(const Config &config, const CNode &node)=0
Handle removal of a peer (clear state)
static void AddFlag(NetPermissionFlags &flags, NetPermissionFlags f)
static bool HasFlag(NetPermissionFlags flags, NetPermissionFlags f)
CONSTEXPR_IF_NOT_DEBUG Span< C > subspan(std::size_t offset) const noexcept
Definition: span.h:218
The TransportDeserializer takes care of holding and deserializing the network receive buffer.
Definition: net.h:356
virtual ~TransportDeserializer()
Definition: net.h:367
virtual bool Complete() const =0
virtual CNetMessage GetMessage(const Config &config, std::chrono::microseconds time)=0
virtual void SetVersion(int version)=0
virtual int Read(const Config &config, Span< const uint8_t > &msg_bytes)=0
read and deserialize data, advances msg_bytes data pointer
The TransportSerializer prepares messages for the network transport.
Definition: net.h:439
virtual void prepareForTransport(const Config &config, CSerializedNetMsg &msg, std::vector< uint8_t > &header)=0
virtual ~TransportSerializer()
Definition: net.h:446
CNetMessage GetMessage(const Config &config, std::chrono::microseconds time) override
Definition: net.cpp:763
CDataStream vRecv
Definition: net.h:382
CMessageHeader hdr
Definition: net.h:380
const uint256 & GetMessageHash() const
Definition: net.cpp:754
uint32_t nDataPos
Definition: net.h:384
uint32_t nHdrPos
Definition: net.h:383
int Read(const Config &config, Span< const uint8_t > &msg_bytes) override
read and deserialize data, advances msg_bytes data pointer
Definition: net.h:422
void SetVersion(int nVersionIn) override
Definition: net.h:418
int readData(Span< const uint8_t > msg_bytes)
Definition: net.cpp:737
bool Complete() const override
Definition: net.h:410
int readHeader(const Config &config, Span< const uint8_t > msg_bytes)
Definition: net.cpp:704
CHash256 hasher
Definition: net.h:372
V1TransportDeserializer(const CMessageHeader::MessageMagic &pchMessageStartIn, int nTypeIn, int nVersionIn)
Definition: net.h:402
CDataStream hdrbuf
Definition: net.h:378
uint256 data_hash
Definition: net.h:373
void prepareForTransport(const Config &config, CSerializedNetMsg &msg, std::vector< uint8_t > &header) override
Definition: net.cpp:806
void SetNull()
Definition: uint256.h:41
256-bit opaque blob.
Definition: uint256.h:129
unsigned int SOCKET
Definition: compat.h:40
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:7
#define LogPrint(category,...)
Definition: logging.h:210
Definition: logging.h:40
Definition: init.h:28
Implement std::hash so RCUPtr can be used as a key for maps or sets.
Definition: rcu.h:257
bool IsPeerAddrLocalGood(CNode *pnode)
Definition: net.cpp:236
const std::vector< std::string > CONNECTION_TYPE_DOC
Definition: net.h:138
uint16_t GetListenPort()
Definition: net.cpp:136
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:93
bool IsLocal(const CService &addr)
check whether a given address is potentially local
Definition: net.cpp:345
CService GetLocalAddress(const CNetAddr &addrPeer)
Definition: net.cpp:220
void RemoveLocal(const CService &addr)
Definition: net.cpp:310
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:69
static constexpr std::chrono::minutes TIMEOUT_INTERVAL
Time after which to disconnect, after waiting for a ping response (or inactivity).
Definition: net.h:63
Maximum number of addnode outgoing nodes.
Definition: net.h:76
bool AddLocal(const CService &addr, int nScore=LOCAL_NONE)
Definition: net.cpp:277
std::optional< CService > GetLocalAddrForPeer(CNode &node)
Returns a local address that we should advertise to this peer.
Definition: net.cpp:242
bool fDiscover
Definition: net.cpp:124
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:107
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:101
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:97
Default for -whitelistforcerelay.
Definition: net.h:57
static const bool DEFAULT_FORCEDNSSEED
Definition: net.h:103
bool fListen
Definition: net.cpp:125
Default for -whitelistrelay.
Definition: net.h:55
std::map< CNetAddr, LocalServiceInfo > mapLocalHost GUARDED_BY(g_maplocalhost_mutex)
static constexpr uint64_t DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:95
Run the extra block-relay-only connection loop once every 5 minutes.
Definition: net.h:67
Definition: net.h:106
Definition: net.cpp:111
Maximum number of avalanche enabled outgoing connections by default.
Definition: net.h:83
void SetReachable(enum Network net, bool reachable)
Mark a network as reachable or unreachable (no automatic connects to it)
Definition: net.cpp:316
static const bool DEFAULT_FIXEDSEEDS
Definition: net.h:105
std::function< void(const CAddress &addr, const std::string &msg_type, Span< const uint8_t > data, bool is_incoming)> CaptureMessage
Defaults to CaptureMessageToFile(), but can be overridden by unit tests.
Definition: net.cpp:3642
Different types of connections to a peer.
Definition: net.h:151
We use block-relay-only connections to help prevent against partition attacks.
We open manual connections to addresses that users explicitly inputted via the addnode RPC,...
These are the default connections that we use to connect with the network.
Feeler connections are short-lived connections made to check that a node is alive.
Inbound connections are those initiated by a peer.
Special case of connection to a full relay outbound with avalanche service enabled.
AddrFetch connections are short lived connections used to solicit addresses from peers.
std::map< std::string, uint64_t > mapMsgCmdSize
Definition: net.h:283
std::string getSubVersionEB(uint64_t MaxBlockSize)
This function convert MaxBlockSize from byte to MB with a decimal precision one digit rounded down E....
Definition: net.cpp:3577
GlobalMutex g_maplocalhost_mutex
Definition: net.cpp:126
Maximum number of feeler connections.
Definition: net.h:85
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:87
bool GetLocal(CService &addr, const CNetAddr *paddrPeer=nullptr)
Definition: net.cpp:172
static constexpr auto FEELER_INTERVAL
Run the feeler connection loop once every 2 minutes.
Definition: net.h:65
-peertimeout default
Definition: net.h:99
std::optional< NodeId > SelectNodeToEvict(std::vector< NodeEvictionCandidate > &&vEvictionCandidates)
Select an inbound peer to evict after filtering out (protecting) peers having distinct,...
Definition: net.cpp:1114
void ProtectEvictionCandidatesByRatio(std::vector< NodeEvictionCandidate > &vEvictionCandidates)
Protect desirable or disadvantaged inbound peers from eviction by ratio.
Definition: net.cpp:1019
void CaptureMessageToFile(const CAddress &addr, const std::string &msg_type, Span< const uint8_t > data, bool is_incoming)
Dump binary message to file, with timestamp.
Definition: net.cpp:3611
static const bool DEFAULT_DNSSEED
Definition: net.h:104
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks,...
Definition: net.h:74
std::string ConnectionTypeAsString(ConnectionType conn_type)
Convert ConnectionType enum to a string value.
Definition: net.cpp:575
Definition: net.h:234
Definition: net.h:240
Definition: net.h:242
Definition: net.h:244
Definition: net.h:238
Definition: net.h:236
std::string userAgent(const Config &config)
Definition: net.cpp:3591
Maximum number of block-relay-only outgoing connections.
Definition: net.h:78
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:2789
bool IsReachable(enum Network net)
Definition: net.cpp:324
bool SeenLocal(const CService &addr)
vote for a local address
Definition: net.cpp:334
A network type.
Definition: netaddress.h:44
int64_t NodeId
Definition: nodeid.h:10
nServices flags.
Definition: protocol.h:335
Definition: protocol.h:338
bool fInbound
Definition: net.h:113
CService resolvedAddress
Definition: net.h:111
bool fConnected
Definition: net.h:112
std::string strAddedNode
Definition: net.h:110
Cache responses to addr requests to minimize privacy leak.
Definition: net.h:1226
std::chrono::microseconds m_cache_entry_expiration
Definition: net.h:1228
std::vector< CAddress > m_addrs_response_cache
Definition: net.h:1227
void AddSocketPermissionFlags(NetPermissionFlags &flags) const
Definition: net.h:1086
ListenSocket(SOCKET socket_, NetPermissionFlags permissions_)
Definition: net.h:1089
NetPermissionFlags m_permissions
Definition: net.h:1093
int m_max_outbound_block_relay
Definition: net.h:858
unsigned int nReceiveFloodSize
Definition: net.h:866
int m_max_outbound_full_relay
Definition: net.h:857
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:871
uint64_t nMaxOutboundLimit
Definition: net.h:867
std::vector< NetWhitelistPermissions > vWhitelistedRange
Definition: net.h:870
CClientUIInterface * uiInterface
Definition: net.h:862
int m_max_avalanche_outbound
Definition: net.h:859
std::vector< CService > onion_binds
Definition: net.h:873
int nMaxFeeler
Definition: net.h:861
std::vector< std::string > m_specified_outgoing
Definition: net.h:878
int nMaxConnections
Definition: net.h:856
ServiceFlags nLocalServices
Definition: net.h:855
std::vector< std::string > m_added_nodes
Definition: net.h:879
int64_t m_peer_connect_timeout
Definition: net.h:868
std::vector< CService > vBinds
Definition: net.h:872
unsigned int nSendBufferMaxSize
Definition: net.h:865
bool m_i2p_accept_incoming
Definition: net.h:880
std::vector< std::string > vSeedNodes
Definition: net.h:869
BanMan * m_banman
Definition: net.h:864
bool m_use_addrman_outgoing
Definition: net.h:877
std::vector< NetEventsInterface * > m_msgproc
Definition: net.h:863
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:876
int nMaxAddnode
Definition: net.h:860
POD that contains various stats about a node.
Definition: net.h:290
std::string addrLocal
Definition: net.h:314
CAddress addrBind
Definition: net.h:318
uint64_t nRecvBytes
Definition: net.h:308
mapMsgCmdSize mapSendBytesPerMsgCmd
Definition: net.h:307
std::chrono::microseconds m_last_ping_time
Definition: net.h:311
uint32_t m_mapped_as
Definition: net.h:321
bool fInbound
Definition: net.h:302
uint64_t nSendBytes
Definition: net.h:306
std::chrono::seconds m_last_recv
Definition: net.h:293
std::optional< double > m_availabilityScore
Definition: net.h:323
std::chrono::seconds m_last_proof_time
Definition: net.h:295
ConnectionType m_conn_type
Definition: net.h:322
std::chrono::seconds m_last_send
Definition: net.h:292
std::chrono::seconds m_last_tx_time
Definition: net.h:294
CAddress addr
Definition: net.h:316
std::chrono::microseconds m_min_ping_time
Definition: net.h:312
int64_t nTimeOffset
Definition: net.h:298
std::chrono::seconds m_connected
Definition: net.h:297
bool m_bip152_highbandwidth_from
Definition: net.h:304
bool m_bip152_highbandwidth_to
Definition: net.h:303
std::string m_addr_name
Definition: net.h:299
mapMsgCmdSize mapRecvBytesPerMsgCmd
Definition: net.h:309
int nVersion
Definition: net.h:300
std::chrono::seconds m_last_block_time
Definition: net.h:296
Network m_network
Definition: net.h:320
NodeId nodeid
Definition: net.h:291
NetPermissionFlags m_permissionFlags
Definition: net.h:310
std::string cleanSubVer
Definition: net.h:301
int m_starting_height
Definition: net.h:305
CSerializedNetMsg(const CSerializedNetMsg &msg)=delete
CSerializedNetMsg Copy() const
Definition: net.h:127
std::vector< uint8_t > data
Definition: net.h:134
std::string m_type
Definition: net.h:135
CSerializedNetMsg & operator=(const CSerializedNetMsg &)=delete
CSerializedNetMsg(CSerializedNetMsg &&)=default
CSerializedNetMsg & operator=(CSerializedNetMsg &&)=default
uint16_t nPort
Definition: net.h:274
int nScore
Definition: net.h:273
std::chrono::seconds m_last_tx_time
Definition: net.h:1366
Network m_network
Definition: net.h:1373
double availabilityScore
Definition: net.h:1374
std::chrono::seconds m_connected
Definition: net.h:1362
std::chrono::seconds m_last_block_time
Definition: net.h:1364
bool fRelevantServices
Definition: net.h:1367
std::chrono::microseconds m_min_ping_time
Definition: net.h:1363
std::chrono::seconds m_last_proof_time
Definition: net.h:1365
uint64_t nKeyedNetGroup
Definition: net.h:1370
Bilingual messages:
Definition: translation.h:17
#define LOCK(cs)
Definition: sync.h:306
static int count
Definition: tests.c:31
Definition: threadsafety.h:56
std::chrono::time_point< std::chrono::steady_clock, std::chrono::milliseconds > SteadyMilliseconds
Definition: time.h:31
static const int INIT_PROTO_VERSION
initial proto version, to be increased after version/verack negotiation
Definition: version.h:14