src/net.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 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 "addrdb.h"
  10 #include "addrman.h"
  11 #include "amount.h"
  12 #include "bloom.h"
  13 #include "compat.h"
  14 #include "hash.h"
  15 #include "limitedmap.h"
  16 #include "netaddress.h"
  17 #include "policy/feerate.h"
  18 #include "protocol.h"
  19 #include "random.h"
  20 #include "streams.h"
  21 #include "sync.h"
  22 #include "uint256.h"
  23 #include "threadinterrupt.h"
  24
  25 #include <atomic>
  26 #include <deque>
  27 #include <stdint.h>
  28 #include <thread>
  29 #include <memory>
  30 #include <condition_variable>
  31
  32 #ifndef WIN32
  33 #include <arpa/inet.h>
  34 #endif
  35
  36 #include <boost/signals2/signal.hpp>
  37
  38 class CScheduler;
  39 class CNode;
  40
  41 namespace boost {
  42     class thread_group;
  43 } // namespace boost
  44
  45 /** Time between pings automatically sent out for latency probing and keepalive (in seconds). */
  46 static const int PING_INTERVAL = 2 * 60;
  47 /** Time after which to disconnect, after waiting for a ping response (or inactivity). */
  48 static const int TIMEOUT_INTERVAL = 20 * 60;
  49 /** Run the feeler connection loop once every 2 minutes or 120 seconds. **/
  50 static const int FEELER_INTERVAL = 120;
  51 /** The maximum number of entries in an 'inv' protocol message */
  52 static const unsigned int MAX_INV_SZ = 50000;
  53 /** The maximum number of new addresses to accumulate before announcing. */
  54 static const unsigned int MAX_ADDR_TO_SEND = 1000;
  55 /** Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable). */
  56 static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1000 * 1000;
  57 /** Maximum length of strSubVer in `version` message */
  58 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
  59 /** Maximum number of automatic outgoing nodes */
  60 static const int MAX_OUTBOUND_CONNECTIONS = 8;
  61 /** Maximum number of addnode outgoing nodes */
  62 static const int MAX_ADDNODE_CONNECTIONS = 8;
  63 /** -listen default */
  64 static const bool DEFAULT_LISTEN = true;
  65 /** -upnp default */
  66 #ifdef USE_UPNP
  67 static const bool DEFAULT_UPNP = USE_UPNP;
  68 #else
  69 static const bool DEFAULT_UPNP = false;
  70 #endif
  71 /** The maximum number of entries in mapAskFor */
  72 static const size_t MAPASKFOR_MAX_SZ = MAX_INV_SZ;
  73 /** The maximum number of entries in setAskFor (larger due to getdata latency)*/
  74 static const size_t SETASKFOR_MAX_SZ = 2 * MAX_INV_SZ;
  75 /** The maximum number of peer connections to maintain. */
  76 static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 125;
  77 /** The default for -maxuploadtarget. 0 = Unlimited */
  78 static const uint64_t DEFAULT_MAX_UPLOAD_TARGET = 0;
  79 /** The default timeframe for -maxuploadtarget. 1 day. */
  80 static const uint64_t MAX_UPLOAD_TIMEFRAME = 60 * 60 * 24;
  81 /** Default for blocks only*/
  82 static const bool DEFAULT_BLOCKSONLY = false;
  83
  84 static const bool DEFAULT_FORCEDNSSEED = false;
  85 static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
  86 static const size_t DEFAULT_MAXSENDBUFFER    = 1 * 1000;
  87
  88 static const ServiceFlags REQUIRED_SERVICES = NODE_NETWORK;
  89
  90 // NOTE: When adjusting this, update rpcnet:setban's help ("24h")
  91 static const unsigned int DEFAULT_MISBEHAVING_BANTIME = 60 * 60 * 24;  // Default 24-hour ban
  92
  93 typedef int64_t NodeId;
  94
  95 struct AddedNodeInfo
  96 {
  97     std::string strAddedNode;
  98     CService resolvedAddress;
  99     bool fConnected;
 100     bool fInbound;
 101 };
 102
 103 class CNodeStats;
 104 class CClientUIInterface;
 105
 106 struct CSerializedNetMsg
 107 {
 108     CSerializedNetMsg() = default;
 109     CSerializedNetMsg(CSerializedNetMsg&&) = default;
 110     CSerializedNetMsg& operator=(CSerializedNetMsg&&) = default;
 111     // No copying, only moves.
 112     CSerializedNetMsg(const CSerializedNetMsg& msg) = delete;
 113     CSerializedNetMsg& operator=(const CSerializedNetMsg&) = delete;
 114
 115     std::vector<unsigned char> data;
 116     std::string command;
 117 };
 118
 119
 120 class CConnman
 121 {
 122 public:
 123
 124     enum NumConnections {
 125         CONNECTIONS_NONE = 0,
 126         CONNECTIONS_IN = (1U << 0),
 127         CONNECTIONS_OUT = (1U << 1),
 128         CONNECTIONS_ALL = (CONNECTIONS_IN | CONNECTIONS_OUT),
 129     };
 130
 131     struct Options
 132     {
 133         ServiceFlags nLocalServices = NODE_NONE;
 134         ServiceFlags nRelevantServices = NODE_NONE;
 135         int nMaxConnections = 0;
 136         int nMaxOutbound = 0;
 137         int nMaxAddnode = 0;
 138         int nMaxFeeler = 0;
 139         int nBestHeight = 0;
 140         CClientUIInterface* uiInterface = nullptr;
 141         unsigned int nSendBufferMaxSize = 0;
 142         unsigned int nReceiveFloodSize = 0;
 143         uint64_t nMaxOutboundTimeframe = 0;
 144         uint64_t nMaxOutboundLimit = 0;
 145         std::vector<std::string> vSeedNodes;
 146         std::vector<CSubNet> vWhitelistedRange;
 147         std::vector<CService> vBinds, vWhiteBinds;
 148         bool m_use_addrman_outgoing = true;
 149         std::vector<std::string> m_specified_outgoing;
 150     };
 151
 152     void Init(const Options& connOptions) {
 153         nLocalServices = connOptions.nLocalServices;
 154         nRelevantServices = connOptions.nRelevantServices;
 155         nMaxConnections = connOptions.nMaxConnections;
 156         nMaxOutbound = std::min(connOptions.nMaxOutbound, connOptions.nMaxConnections);
 157         nMaxAddnode = connOptions.nMaxAddnode;
 158         nMaxFeeler = connOptions.nMaxFeeler;
 159         nBestHeight = connOptions.nBestHeight;
 160         clientInterface = connOptions.uiInterface;
 161         nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
 162         nReceiveFloodSize = connOptions.nReceiveFloodSize;
 163         nMaxOutboundTimeframe = connOptions.nMaxOutboundTimeframe;
 164         nMaxOutboundLimit = connOptions.nMaxOutboundLimit;
 165         vWhitelistedRange = connOptions.vWhitelistedRange;
 166     }
 167
 168     CConnman(uint64_t seed0, uint64_t seed1);
 169     ~CConnman();
 170     bool Start(CScheduler& scheduler, const Options& options);
 171     void Stop();
 172     void Interrupt();
 173     bool GetNetworkActive() const { return fNetworkActive; };
 174     void SetNetworkActive(bool active);
 175     bool OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound = nullptr, const char *strDest = nullptr, bool fOneShot = false, bool fFeeler = false, bool fAddnode = false);
 176     bool CheckIncomingNonce(uint64_t nonce);
 177
 178     bool ForNode(NodeId id, std::function<bool(CNode* pnode)> func);
 179
 180     void PushMessage(CNode* pnode, CSerializedNetMsg&& msg);
 181
 182     template<typename Callable>
 183     void ForEachNode(Callable&& func)
 184     {
 185         LOCK(cs_vNodes);
 186         for (auto&& node : vNodes) {
 187             if (NodeFullyConnected(node))
 188                 func(node);
 189         }
 190     };
 191
 192     template<typename Callable>
 193     void ForEachNode(Callable&& func) const
 194     {
 195         LOCK(cs_vNodes);
 196         for (auto&& node : vNodes) {
 197             if (NodeFullyConnected(node))
 198                 func(node);
 199         }
 200     };
 201
 202     template<typename Callable, typename CallableAfter>
 203     void ForEachNodeThen(Callable&& pre, CallableAfter&& post)
 204     {
 205         LOCK(cs_vNodes);
 206         for (auto&& node : vNodes) {
 207             if (NodeFullyConnected(node))
 208                 pre(node);
 209         }
 210         post();
 211     };
 212
 213     template<typename Callable, typename CallableAfter>
 214     void ForEachNodeThen(Callable&& pre, CallableAfter&& post) const
 215     {
 216         LOCK(cs_vNodes);
 217         for (auto&& node : vNodes) {
 218             if (NodeFullyConnected(node))
 219                 pre(node);
 220         }
 221         post();
 222     };
 223
 224     // Addrman functions
 225     size_t GetAddressCount() const;
 226     void SetServices(const CService &addr, ServiceFlags nServices);
 227     void MarkAddressGood(const CAddress& addr);
 228     void AddNewAddresses(const std::vector<CAddress>& vAddr, const CAddress& addrFrom, int64_t nTimePenalty = 0);
 229     std::vector<CAddress> GetAddresses();
 230
 231     // Denial-of-service detection/prevention
 232     // The idea is to detect peers that are behaving
 233     // badly and disconnect/ban them, but do it in a
 234     // one-coding-mistake-won't-shatter-the-entire-network
 235     // way.
 236     // IMPORTANT:  There should be nothing I can give a
 237     // node that it will forward on that will make that
 238     // node's peers drop it. If there is, an attacker
 239     // can isolate a node and/or try to split the network.
 240     // Dropping a node for sending stuff that is invalid
 241     // now but might be valid in a later version is also
 242     // dangerous, because it can cause a network split
 243     // between nodes running old code and nodes running
 244     // new code.
 245     void Ban(const CNetAddr& netAddr, const BanReason& reason, int64_t bantimeoffset = 0, bool sinceUnixEpoch = false);
 246     void Ban(const CSubNet& subNet, const BanReason& reason, int64_t bantimeoffset = 0, bool sinceUnixEpoch = false);
 247     void ClearBanned(); // needed for unit testing
 248     bool IsBanned(CNetAddr ip);
 249     bool IsBanned(CSubNet subnet);
 250     bool Unban(const CNetAddr &ip);
 251     bool Unban(const CSubNet &ip);
 252     void GetBanned(banmap_t &banmap);
 253     void SetBanned(const banmap_t &banmap);
 254
 255     bool AddNode(const std::string& node);
 256     bool RemoveAddedNode(const std::string& node);
 257     std::vector<AddedNodeInfo> GetAddedNodeInfo();
 258
 259     size_t GetNodeCount(NumConnections num);
 260     void GetNodeStats(std::vector<CNodeStats>& vstats);
 261     bool DisconnectNode(const std::string& node);
 262     bool DisconnectNode(NodeId id);
 263
 264     ServiceFlags GetLocalServices() const;
 265
 266     //!set the max outbound target in bytes
 267     void SetMaxOutboundTarget(uint64_t limit);
 268     uint64_t GetMaxOutboundTarget();
 269
 270     //!set the timeframe for the max outbound target
 271     void SetMaxOutboundTimeframe(uint64_t timeframe);
 272     uint64_t GetMaxOutboundTimeframe();
 273
 274     //!check if the outbound target is reached
 275     // if param historicalBlockServingLimit is set true, the function will
 276     // response true if the limit for serving historical blocks has been reached
 277     bool OutboundTargetReached(bool historicalBlockServingLimit);
 278
 279     //!response the bytes left in the current max outbound cycle
 280     // in case of no limit, it will always response 0
 281     uint64_t GetOutboundTargetBytesLeft();
 282
 283     //!response the time in second left in the current max outbound cycle
 284     // in case of no limit, it will always response 0
 285     uint64_t GetMaxOutboundTimeLeftInCycle();
 286
 287     uint64_t GetTotalBytesRecv();
 288     uint64_t GetTotalBytesSent();
 289
 290     void SetBestHeight(int height);
 291     int GetBestHeight() const;
 292
 293     /** Get a unique deterministic randomizer. */
 294     CSipHasher GetDeterministicRandomizer(uint64_t id) const;
 295
 296     unsigned int GetReceiveFloodSize() const;
 297
 298     void WakeMessageHandler();
 299 private:
 300     struct ListenSocket {
 301         SOCKET socket;
 302         bool whitelisted;
 303
 304         ListenSocket(SOCKET socket_, bool whitelisted_) : socket(socket_), whitelisted(whitelisted_) {}
 305     };
 306
 307     bool BindListenPort(const CService &bindAddr, std::string& strError, bool fWhitelisted = false);
 308     bool Bind(const CService &addr, unsigned int flags);
 309     bool InitBinds(const std::vector<CService>& binds, const std::vector<CService>& whiteBinds);
 310     void ThreadOpenAddedConnections();
 311     void AddOneShot(const std::string& strDest);
 312     void ProcessOneShot();
 313     void ThreadOpenConnections(std::vector<std::string> connect);
 314     void ThreadMessageHandler();
 315     void AcceptConnection(const ListenSocket& hListenSocket);
 316     void ThreadSocketHandler();
 317     void ThreadDNSAddressSeed();
 318
 319     uint64_t CalculateKeyedNetGroup(const CAddress& ad) const;
 320
 321     CNode* FindNode(const CNetAddr& ip);
 322     CNode* FindNode(const CSubNet& subNet);
 323     CNode* FindNode(const std::string& addrName);
 324     CNode* FindNode(const CService& addr);
 325
 326     bool AttemptToEvictConnection();
 327     CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure);
 328     bool IsWhitelistedRange(const CNetAddr &addr);
 329
 330     void DeleteNode(CNode* pnode);
 331
 332     NodeId GetNewNodeId();
 333
 334     size_t SocketSendData(CNode *pnode) const;
 335     //!check is the banlist has unwritten changes
 336     bool BannedSetIsDirty();
 337     //!set the "dirty" flag for the banlist
 338     void SetBannedSetDirty(bool dirty=true);
 339     //!clean unused entries (if bantime has expired)
 340     void SweepBanned();
 341     void DumpAddresses();
 342     void DumpData();
 343     void DumpBanlist();
 344
 345     // Network stats
 346     void RecordBytesRecv(uint64_t bytes);
 347     void RecordBytesSent(uint64_t bytes);
 348
 349     // Whether the node should be passed out in ForEach* callbacks
 350     static bool NodeFullyConnected(const CNode* pnode);
 351
 352     // Network usage totals
 353     CCriticalSection cs_totalBytesRecv;
 354     CCriticalSection cs_totalBytesSent;
 355     uint64_t nTotalBytesRecv;
 356     uint64_t nTotalBytesSent;
 357
 358     // outbound limit & stats
 359     uint64_t nMaxOutboundTotalBytesSentInCycle;
 360     uint64_t nMaxOutboundCycleStartTime;
 361     uint64_t nMaxOutboundLimit;
 362     uint64_t nMaxOutboundTimeframe;
 363
 364     // Whitelisted ranges. Any node connecting from these is automatically
 365     // whitelisted (as well as those connecting to whitelisted binds).
 366     std::vector<CSubNet> vWhitelistedRange;
 367
 368     unsigned int nSendBufferMaxSize;
 369     unsigned int nReceiveFloodSize;
 370
 371     std::vector<ListenSocket> vhListenSocket;
 372     std::atomic<bool> fNetworkActive;
 373     banmap_t setBanned;
 374     CCriticalSection cs_setBanned;
 375     bool setBannedIsDirty;
 376     bool fAddressesInitialized;
 377     CAddrMan addrman;
 378     std::deque<std::string> vOneShots;
 379     CCriticalSection cs_vOneShots;
 380     std::vector<std::string> vAddedNodes;
 381     CCriticalSection cs_vAddedNodes;
 382     std::vector<CNode*> vNodes;
 383     std::list<CNode*> vNodesDisconnected;
 384     mutable CCriticalSection cs_vNodes;
 385     std::atomic<NodeId> nLastNodeId;
 386
 387     /** Services this instance offers */
 388     ServiceFlags nLocalServices;
 389
 390     /** Services this instance cares about */
 391     ServiceFlags nRelevantServices;
 392
 393     CSemaphore *semOutbound;
 394     CSemaphore *semAddnode;
 395     int nMaxConnections;
 396     int nMaxOutbound;
 397     int nMaxAddnode;
 398     int nMaxFeeler;
 399     std::atomic<int> nBestHeight;
 400     CClientUIInterface* clientInterface;
 401
 402     /** SipHasher seeds for deterministic randomness */
 403     const uint64_t nSeed0, nSeed1;
 404
 405     /** flag for waking the message processor. */
 406     bool fMsgProcWake;
 407
 408     std::condition_variable condMsgProc;
 409     std::mutex mutexMsgProc;
 410     std::atomic<bool> flagInterruptMsgProc;
 411
 412     CThreadInterrupt interruptNet;
 413
 414     std::thread threadDNSAddressSeed;
 415     std::thread threadSocketHandler;
 416     std::thread threadOpenAddedConnections;
 417     std::thread threadOpenConnections;
 418     std::thread threadMessageHandler;
 419 };
 420 extern std::unique_ptr<CConnman> g_connman;
 421 void Discover(boost::thread_group& threadGroup);
 422 void MapPort(bool fUseUPnP);
 423 unsigned short GetListenPort();
 424 bool BindListenPort(const CService &bindAddr, std::string& strError, bool fWhitelisted = false);
 425
 426 struct CombinerAll
 427 {
 428     typedef bool result_type;
 429
 430     template<typename I>
 431     bool operator()(I first, I last) const
 432     {
 433         while (first != last) {
 434             if (!(*first)) return false;
 435             ++first;
 436         }
 437         return true;
 438     }
 439 };
 440
 441 // Signals for message handling
 442 struct CNodeSignals
 443 {
 444     boost::signals2::signal<bool (CNode*, CConnman&, std::atomic<bool>&), CombinerAll> ProcessMessages;
 445     boost::signals2::signal<bool (CNode*, CConnman&, std::atomic<bool>&), CombinerAll> SendMessages;
 446     boost::signals2::signal<void (CNode*, CConnman&)> InitializeNode;
 447     boost::signals2::signal<void (NodeId, bool&)> FinalizeNode;
 448 };
 449
 450
 451 CNodeSignals& GetNodeSignals();
 452
 453
 454 enum
 455 {
 456     LOCAL_NONE,   // unknown
 457     LOCAL_IF,     // address a local interface listens on
 458     LOCAL_BIND,   // address explicit bound to
 459     LOCAL_UPNP,   // address reported by UPnP
 460     LOCAL_MANUAL, // address explicitly specified (-externalip=)
 461
 462     LOCAL_MAX
 463 };
 464
 465 bool IsPeerAddrLocalGood(CNode *pnode);
 466 void AdvertiseLocal(CNode *pnode);
 467 void SetLimited(enum Network net, bool fLimited = true);
 468 bool IsLimited(enum Network net);
 469 bool IsLimited(const CNetAddr& addr);
 470 bool AddLocal(const CService& addr, int nScore = LOCAL_NONE);
 471 bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
 472 bool RemoveLocal(const CService& addr);
 473 bool SeenLocal(const CService& addr);
 474 bool IsLocal(const CService& addr);
 475 bool GetLocal(CService &addr, const CNetAddr *paddrPeer = nullptr);
 476 bool IsReachable(enum Network net);
 477 bool IsReachable(const CNetAddr &addr);
 478 CAddress GetLocalAddress(const CNetAddr *paddrPeer, ServiceFlags nLocalServices);
 479
 480
 481 extern bool fDiscover;
 482 extern bool fListen;
 483 extern bool fRelayTxes;
 484
 485 extern limitedmap<uint256, int64_t> mapAlreadyAskedFor;
 486
 487 /** Subversion as sent to the P2P network in `version` messages */
 488 extern std::string strSubVersion;
 489
 490 struct LocalServiceInfo {
 491     int nScore;
 492     int nPort;
 493 };
 494
 495 extern CCriticalSection cs_mapLocalHost;
 496 extern std::map<CNetAddr, LocalServiceInfo> mapLocalHost;
 497 typedef std::map<std::string, uint64_t> mapMsgCmdSize; //command, total bytes
 498
 499 class CNodeStats
 500 {
 501 public:
 502     NodeId nodeid;
 503     ServiceFlags nServices;
 504     bool fRelayTxes;
 505     int64_t nLastSend;
 506     int64_t nLastRecv;
 507     int64_t nTimeConnected;
 508     int64_t nTimeOffset;
 509     std::string addrName;
 510     int nVersion;
 511     std::string cleanSubVer;
 512     bool fInbound;
 513     bool fAddnode;
 514     int nStartingHeight;
 515     uint64_t nSendBytes;
 516     mapMsgCmdSize mapSendBytesPerMsgCmd;
 517     uint64_t nRecvBytes;
 518     mapMsgCmdSize mapRecvBytesPerMsgCmd;
 519     bool fWhitelisted;
 520     double dPingTime;
 521     double dPingWait;
 522     double dMinPing;
 523     // Our address, as reported by the peer
 524     std::string addrLocal;
 525     // Address of this peer
 526     CAddress addr;
 527     // Bind address of our side of the connection
 528     CAddress addrBind;
 529 };
 530
 531
 532
 533
 534 class CNetMessage {
 535 private:
 536     mutable CHash256 hasher;
 537     mutable uint256 data_hash;
 538 public:
 539     bool in_data;                   // parsing header (false) or data (true)
 540
 541     CDataStream hdrbuf;             // partially received header
 542     CMessageHeader hdr;             // complete header
 543     unsigned int nHdrPos;
 544
 545     CDataStream vRecv;              // received message data
 546     unsigned int nDataPos;
 547
 548     int64_t nTime;                  // time (in microseconds) of message receipt.
 549
 550     CNetMessage(const CMessageHeader::MessageStartChars& pchMessageStartIn, int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), hdr(pchMessageStartIn), vRecv(nTypeIn, nVersionIn) {
 551         hdrbuf.resize(24);
 552         in_data = false;
 553         nHdrPos = 0;
 554         nDataPos = 0;
 555         nTime = 0;
 556     }
 557
 558     bool complete() const
 559     {
 560         if (!in_data)
 561             return false;
 562         return (hdr.nMessageSize == nDataPos);
 563     }
 564
 565     const uint256& GetMessageHash() const;
 566
 567     void SetVersion(int nVersionIn)
 568     {
 569         hdrbuf.SetVersion(nVersionIn);
 570         vRecv.SetVersion(nVersionIn);
 571     }
 572
 573     int readHeader(const char *pch, unsigned int nBytes);
 574     int readData(const char *pch, unsigned int nBytes);
 575 };
 576
 577
 578 /** Information about a peer */
 579 class CNode
 580 {
 581     friend class CConnman;
 582 public:
 583     // socket
 584     std::atomic<ServiceFlags> nServices;
 585     ServiceFlags nServicesExpected;
 586     SOCKET hSocket;
 587     size_t nSendSize; // total size of all vSendMsg entries
 588     size_t nSendOffset; // offset inside the first vSendMsg already sent
 589     uint64_t nSendBytes;
 590     std::deque<std::vector<unsigned char>> vSendMsg;
 591     CCriticalSection cs_vSend;
 592     CCriticalSection cs_hSocket;
 593     CCriticalSection cs_vRecv;
 594
 595     CCriticalSection cs_vProcessMsg;
 596     std::list<CNetMessage> vProcessMsg;
 597     size_t nProcessQueueSize;
 598
 599     CCriticalSection cs_sendProcessing;
 600
 601     std::deque<CInv> vRecvGetData;
 602     uint64_t nRecvBytes;
 603     std::atomic<int> nRecvVersion;
 604
 605     std::atomic<int64_t> nLastSend;
 606     std::atomic<int64_t> nLastRecv;
 607     const int64_t nTimeConnected;
 608     std::atomic<int64_t> nTimeOffset;
 609     // Address of this peer
 610     const CAddress addr;
 611     // Bind address of our side of the connection
 612     const CAddress addrBind;
 613     std::atomic<int> nVersion;
 614     // strSubVer is whatever byte array we read from the wire. However, this field is intended
 615     // to be printed out, displayed to humans in various forms and so on. So we sanitize it and
 616     // store the sanitized version in cleanSubVer. The original should be used when dealing with
 617     // the network or wire types and the cleaned string used when displayed or logged.
 618     std::string strSubVer, cleanSubVer;
 619     CCriticalSection cs_SubVer; // used for both cleanSubVer and strSubVer
 620     bool fWhitelisted; // This peer can bypass DoS banning.
 621     bool fFeeler; // If true this node is being used as a short lived feeler.
 622     bool fOneShot;
 623     bool fAddnode;
 624     bool fClient;
 625     const bool fInbound;
 626     std::atomic_bool fSuccessfullyConnected;
 627     std::atomic_bool fDisconnect;
 628     // We use fRelayTxes for two purposes -
 629     // a) it allows us to not relay tx invs before receiving the peer's version message
 630     // b) the peer may tell us in its version message that we should not relay tx invs
 631     //    unless it loads a bloom filter.
 632     bool fRelayTxes; //protected by cs_filter
 633     bool fSentAddr;
 634     CSemaphoreGrant grantOutbound;
 635     CCriticalSection cs_filter;
 636     CBloomFilter* pfilter;
 637     std::atomic<int> nRefCount;
 638
 639     const uint64_t nKeyedNetGroup;
 640     std::atomic_bool fPauseRecv;
 641     std::atomic_bool fPauseSend;
 642 protected:
 643
 644     mapMsgCmdSize mapSendBytesPerMsgCmd;
 645     mapMsgCmdSize mapRecvBytesPerMsgCmd;
 646
 647 public:
 648     uint256 hashContinue;
 649     std::atomic<int> nStartingHeight;
 650
 651     // flood relay
 652     std::vector<CAddress> vAddrToSend;
 653     CRollingBloomFilter addrKnown;
 654     bool fGetAddr;
 655     std::set<uint256> setKnown;
 656     int64_t nNextAddrSend;
 657     int64_t nNextLocalAddrSend;
 658
 659     // inventory based relay
 660     CRollingBloomFilter filterInventoryKnown;
 661     // Set of transaction ids we still have to announce.
 662     // They are sorted by the mempool before relay, so the order is not important.
 663     std::set<uint256> setInventoryTxToSend;
 664     // List of block ids we still have announce.
 665     // There is no final sorting before sending, as they are always sent immediately
 666     // and in the order requested.
 667     std::vector<uint256> vInventoryBlockToSend;
 668     CCriticalSection cs_inventory;
 669     std::set<uint256> setAskFor;
 670     std::multimap<int64_t, CInv> mapAskFor;
 671     int64_t nNextInvSend;
 672     // Used for headers announcements - unfiltered blocks to relay
 673     // Also protected by cs_inventory
 674     std::vector<uint256> vBlockHashesToAnnounce;
 675     // Used for BIP35 mempool sending, also protected by cs_inventory
 676     bool fSendMempool;
 677
 678     // Last time a "MEMPOOL" request was serviced.
 679     std::atomic<int64_t> timeLastMempoolReq;
 680
 681     // Block and TXN accept times
 682     std::atomic<int64_t> nLastBlockTime;
 683     std::atomic<int64_t> nLastTXTime;
 684
 685     // Ping time measurement:
 686     // The pong reply we're expecting, or 0 if no pong expected.
 687     std::atomic<uint64_t> nPingNonceSent;
 688     // Time (in usec) the last ping was sent, or 0 if no ping was ever sent.
 689     std::atomic<int64_t> nPingUsecStart;
 690     // Last measured round-trip time.
 691     std::atomic<int64_t> nPingUsecTime;
 692     // Best measured round-trip time.
 693     std::atomic<int64_t> nMinPingUsecTime;
 694     // Whether a ping is requested.
 695     std::atomic<bool> fPingQueued;
 696     // Minimum fee rate with which to filter inv's to this node
 697     CAmount minFeeFilter;
 698     CCriticalSection cs_feeFilter;
 699     CAmount lastSentFeeFilter;
 700     int64_t nextSendTimeFeeFilter;
 701
 702     CNode(NodeId id, ServiceFlags nLocalServicesIn, int nMyStartingHeightIn, SOCKET hSocketIn, const CAddress &addrIn, uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn, const CAddress &addrBindIn, const std::string &addrNameIn = "", bool fInboundIn = false);
 703     ~CNode();
 704
 705 private:
 706     CNode(const CNode&);
 707     void operator=(const CNode&);
 708     const NodeId id;
 709
 710
 711     const uint64_t nLocalHostNonce;
 712     // Services offered to this peer
 713     const ServiceFlags nLocalServices;
 714     const int nMyStartingHeight;
 715     int nSendVersion;
 716     std::list<CNetMessage> vRecvMsg;  // Used only by SocketHandler thread
 717
 718     mutable CCriticalSection cs_addrName;
 719     std::string addrName;
 720
 721     // Our address, as reported by the peer
 722     CService addrLocal;
 723     mutable CCriticalSection cs_addrLocal;
 724 public:
 725
 726     NodeId GetId() const {
 727         return id;
 728     }
 729
 730     uint64_t GetLocalNonce() const {
 731         return nLocalHostNonce;
 732     }
 733
 734     int GetMyStartingHeight() const {
 735         return nMyStartingHeight;
 736     }
 737
 738     int GetRefCount() const
 739     {
 740         assert(nRefCount >= 0);
 741         return nRefCount;
 742     }
 743
 744     bool ReceiveMsgBytes(const char *pch, unsigned int nBytes, bool& complete);
 745
 746     void SetRecvVersion(int nVersionIn)
 747     {
 748         nRecvVersion = nVersionIn;
 749     }
 750     int GetRecvVersion() const
 751     {
 752         return nRecvVersion;
 753     }
 754     void SetSendVersion(int nVersionIn);
 755     int GetSendVersion() const;
 756
 757     CService GetAddrLocal() const;
 758     //! May not be called more than once
 759     void SetAddrLocal(const CService& addrLocalIn);
 760
 761     CNode* AddRef()
 762     {
 763         nRefCount++;
 764         return this;
 765     }
 766
 767     void Release()
 768     {
 769         nRefCount--;
 770     }
 771
 772
 773
 774     void AddAddressKnown(const CAddress& _addr)
 775     {
 776         addrKnown.insert(_addr.GetKey());
 777     }
 778
 779     void PushAddress(const CAddress& _addr, FastRandomContext &insecure_rand)
 780     {
 781         // Known checking here is only to save space from duplicates.
 782         // SendMessages will filter it again for knowns that were added
 783         // after addresses were pushed.
 784         if (_addr.IsValid() && !addrKnown.contains(_addr.GetKey())) {
 785             if (vAddrToSend.size() >= MAX_ADDR_TO_SEND) {
 786                 vAddrToSend[insecure_rand.randrange(vAddrToSend.size())] = _addr;
 787             } else {
 788                 vAddrToSend.push_back(_addr);
 789             }
 790         }
 791     }
 792
 793
 794     void AddInventoryKnown(const CInv& inv)
 795     {
 796         {
 797             LOCK(cs_inventory);
 798             filterInventoryKnown.insert(inv.hash);
 799         }
 800     }
 801
 802     void PushInventory(const CInv& inv)
 803     {
 804         LOCK(cs_inventory);
 805         if (inv.type == MSG_TX) {
 806             if (!filterInventoryKnown.contains(inv.hash)) {
 807                 setInventoryTxToSend.insert(inv.hash);
 808             }
 809         } else if (inv.type == MSG_BLOCK) {
 810             vInventoryBlockToSend.push_back(inv.hash);
 811         }
 812     }
 813
 814     void PushBlockHash(const uint256 &hash)
 815     {
 816         LOCK(cs_inventory);
 817         vBlockHashesToAnnounce.push_back(hash);
 818     }
 819
 820     void AskFor(const CInv& inv);
 821
 822     void CloseSocketDisconnect();
 823
 824     void copyStats(CNodeStats &stats);
 825
 826     ServiceFlags GetLocalServices() const
 827     {
 828         return nLocalServices;
 829     }
 830
 831     std::string GetAddrName() const;
 832     //! Sets the addrName only if it was not previously set
 833     void MaybeSetAddrName(const std::string& addrNameIn);
 834 };
 835
 836
 837
 838
 839
 840 /** Return a timestamp in the future (in microseconds) for exponentially distributed events. */
 841 int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds);
 842
 843 #endif // BITCOIN_NET_H