src/net.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 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 "bloom.h"
  10 #include "compat.h"
  11 #include "hash.h"
  12 #include "limitedmap.h"
  13 #include "mruset.h"
  14 #include "netbase.h"
  15 #include "protocol.h"
  16 #include "random.h"
  17 #include "streams.h"
  18 #include "sync.h"
  19 #include "uint256.h"
  20 #include "utilstrencodings.h"
  21
  22 #include <deque>
  23 #include <stdint.h>
  24
  25 #ifndef WIN32
  26 #include <arpa/inet.h>
  27 #endif
  28
  29 #include <boost/filesystem/path.hpp>
  30 #include <boost/foreach.hpp>
  31 #include <boost/signals2/signal.hpp>
  32
  33 class CAddrMan;
  34 class CBlockIndex;
  35 class CScheduler;
  36 class CNode;
  37
  38 namespace boost {
  39     class thread_group;
  40 } // namespace boost
  41
  42 /** Time between pings automatically sent out for latency probing and keepalive (in seconds). */
  43 static const int PING_INTERVAL = 2 * 60;
  44 /** Time after which to disconnect, after waiting for a ping response (or inactivity). */
  45 static const int TIMEOUT_INTERVAL = 20 * 60;
  46 /** The maximum number of entries in an 'inv' protocol message */
  47 static const unsigned int MAX_INV_SZ = 50000;
  48 /** The maximum number of new addresses to accumulate before announcing. */
  49 static const unsigned int MAX_ADDR_TO_SEND = 1000;
  50 /** Maximum length of incoming protocol messages (no message over 2 MiB is currently acceptable). */
  51 static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 2 * 1024 * 1024;
  52 /** -listen default */
  53 static const bool DEFAULT_LISTEN = true;
  54 /** The maximum number of entries in mapAskFor */
  55 static const size_t MAPASKFOR_MAX_SZ = MAX_INV_SZ;
  56 /** The maximum number of entries in setAskFor (larger due to getdata latency)*/
  57 static const size_t SETASKFOR_MAX_SZ = 2 * MAX_INV_SZ;
  58 /** The maximum number of peer connections to maintain. */
  59 static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 125;
  60 /** The period before a network upgrade activates, where connections to upgrading peers are preferred (in blocks). */
  61 static const int NETWORK_UPGRADE_PEER_PREFERENCE_BLOCK_PERIOD = 24 * 24 * 3;
  62
  63 unsigned int ReceiveFloodSize();
  64 unsigned int SendBufferSize();
  65
  66 void AddOneShot(const std::string& strDest);
  67 void AddressCurrentlyConnected(const CService& addr);
  68 CNode* FindNode(const CNetAddr& ip);
  69 CNode* FindNode(const CSubNet& subNet);
  70 CNode* FindNode(const std::string& addrName);
  71 CNode* FindNode(const CService& ip);
  72 CNode* ConnectNode(CAddress addrConnect, const char *pszDest = NULL);
  73 bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false);
  74 unsigned short GetListenPort();
  75 bool BindListenPort(const CService &bindAddr, std::string& strError, bool fWhitelisted = false);
  76 void StartNode(boost::thread_group& threadGroup, CScheduler& scheduler);
  77 bool StopNode();
  78 void SocketSendData(CNode *pnode);
  79
  80 typedef int NodeId;
  81
  82 struct CombinerAll
  83 {
  84     typedef bool result_type;
  85
  86     template<typename I>
  87     bool operator()(I first, I last) const
  88     {
  89         while (first != last) {
  90             if (!(*first)) return false;
  91             ++first;
  92         }
  93         return true;
  94     }
  95 };
  96
  97 // Signals for message handling
  98 struct CNodeSignals
  99 {
 100     boost::signals2::signal<int ()> GetHeight;
 101     boost::signals2::signal<bool (CNode*), CombinerAll> ProcessMessages;
 102     boost::signals2::signal<bool (CNode*, bool), CombinerAll> SendMessages;
 103     boost::signals2::signal<void (NodeId, const CNode*)> InitializeNode;
 104     boost::signals2::signal<void (NodeId)> FinalizeNode;
 105 };
 106
 107
 108 CNodeSignals& GetNodeSignals();
 109
 110
 111 enum
 112 {
 113     LOCAL_NONE,   // unknown
 114     LOCAL_IF,     // address a local interface listens on
 115     LOCAL_BIND,   // address explicit bound to
 116     LOCAL_UPNP,   // unused (was: address reported by UPnP)
 117     LOCAL_MANUAL, // address explicitly specified (-externalip=)
 118
 119     LOCAL_MAX
 120 };
 121
 122 bool IsPeerAddrLocalGood(CNode *pnode);
 123 void AdvertizeLocal(CNode *pnode);
 124 void SetLimited(enum Network net, bool fLimited = true);
 125 bool IsLimited(enum Network net);
 126 bool IsLimited(const CNetAddr& addr);
 127 bool AddLocal(const CService& addr, int nScore = LOCAL_NONE);
 128 bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
 129 bool RemoveLocal(const CService& addr);
 130 bool SeenLocal(const CService& addr);
 131 bool IsLocal(const CService& addr);
 132 bool GetLocal(CService &addr, const CNetAddr *paddrPeer = NULL);
 133 bool IsReachable(enum Network net);
 134 bool IsReachable(const CNetAddr &addr);
 135 CAddress GetLocalAddress(const CNetAddr *paddrPeer = NULL);
 136
 137
 138 extern bool fDiscover;
 139 extern bool fListen;
 140 extern uint64_t nLocalServices;
 141 extern uint64_t nLocalHostNonce;
 142 extern CAddrMan addrman;
 143 /** Maximum number of connections to simultaneously allow (aka connection slots) */
 144 extern int nMaxConnections;
 145
 146 extern std::vector<CNode*> vNodes;
 147 extern CCriticalSection cs_vNodes;
 148 extern std::map<CInv, CDataStream> mapRelay;
 149 extern std::deque<std::pair<int64_t, CInv> > vRelayExpiration;
 150 extern CCriticalSection cs_mapRelay;
 151 extern limitedmap<CInv, int64_t> mapAlreadyAskedFor;
 152
 153 extern std::vector<std::string> vAddedNodes;
 154 extern CCriticalSection cs_vAddedNodes;
 155
 156 extern NodeId nLastNodeId;
 157 extern CCriticalSection cs_nLastNodeId;
 158
 159 struct LocalServiceInfo {
 160     int nScore;
 161     int nPort;
 162 };
 163
 164 extern CCriticalSection cs_mapLocalHost;
 165 extern std::map<CNetAddr, LocalServiceInfo> mapLocalHost;
 166
 167 class CNodeStats
 168 {
 169 public:
 170     NodeId nodeid;
 171     uint64_t nServices;
 172     int64_t nLastSend;
 173     int64_t nLastRecv;
 174     int64_t nTimeConnected;
 175     int64_t nTimeOffset;
 176     std::string addrName;
 177     int nVersion;
 178     std::string cleanSubVer;
 179     bool fInbound;
 180     int nStartingHeight;
 181     uint64_t nSendBytes;
 182     uint64_t nRecvBytes;
 183     bool fWhitelisted;
 184     double dPingTime;
 185     double dPingWait;
 186     std::string addrLocal;
 187 };
 188
 189
 190
 191
 192 class CNetMessage {
 193 public:
 194     bool in_data;                   // parsing header (false) or data (true)
 195
 196     CDataStream hdrbuf;             // partially received header
 197     CMessageHeader hdr;             // complete header
 198     unsigned int nHdrPos;
 199
 200     CDataStream vRecv;              // received message data
 201     unsigned int nDataPos;
 202
 203     int64_t nTime;                  // time (in microseconds) of message receipt.
 204
 205     CNetMessage(const CMessageHeader::MessageStartChars& pchMessageStartIn, int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), hdr(pchMessageStartIn), vRecv(nTypeIn, nVersionIn) {
 206         hdrbuf.resize(24);
 207         in_data = false;
 208         nHdrPos = 0;
 209         nDataPos = 0;
 210         nTime = 0;
 211     }
 212
 213     bool complete() const
 214     {
 215         if (!in_data)
 216             return false;
 217         return (hdr.nMessageSize == nDataPos);
 218     }
 219
 220     void SetVersion(int nVersionIn)
 221     {
 222         hdrbuf.SetVersion(nVersionIn);
 223         vRecv.SetVersion(nVersionIn);
 224     }
 225
 226     int readHeader(const char *pch, unsigned int nBytes);
 227     int readData(const char *pch, unsigned int nBytes);
 228 };
 229
 230
 231
 232
 233
 234 /** Information about a peer */
 235 class CNode
 236 {
 237 public:
 238     // socket
 239     uint64_t nServices;
 240     SOCKET hSocket;
 241     CDataStream ssSend;
 242     size_t nSendSize; // total size of all vSendMsg entries
 243     size_t nSendOffset; // offset inside the first vSendMsg already sent
 244     uint64_t nSendBytes;
 245     std::deque<CSerializeData> vSendMsg;
 246     CCriticalSection cs_vSend;
 247
 248     std::deque<CInv> vRecvGetData;
 249     std::deque<CNetMessage> vRecvMsg;
 250     CCriticalSection cs_vRecvMsg;
 251     uint64_t nRecvBytes;
 252     int nRecvVersion;
 253
 254     int64_t nLastSend;
 255     int64_t nLastRecv;
 256     int64_t nTimeConnected;
 257     int64_t nTimeOffset;
 258     CAddress addr;
 259     std::string addrName;
 260     CService addrLocal;
 261     int nVersion;
 262     // strSubVer is whatever byte array we read from the wire. However, this field is intended
 263     // to be printed out, displayed to humans in various forms and so on. So we sanitize it and
 264     // store the sanitized version in cleanSubVer. The original should be used when dealing with
 265     // the network or wire types and the cleaned string used when displayed or logged.
 266     std::string strSubVer, cleanSubVer;
 267     bool fWhitelisted; // This peer can bypass DoS banning.
 268     bool fOneShot;
 269     bool fClient;
 270     bool fInbound;
 271     bool fNetworkNode;
 272     bool fSuccessfullyConnected;
 273     bool fDisconnect;
 274     // We use fRelayTxes for two purposes -
 275     // a) it allows us to not relay tx invs before receiving the peer's version message
 276     // b) the peer may tell us in its version message that we should not relay tx invs
 277     //    until it has initialized its bloom filter.
 278     bool fRelayTxes;
 279     bool fSentAddr;
 280     CSemaphoreGrant grantOutbound;
 281     CCriticalSection cs_filter;
 282     CBloomFilter* pfilter;
 283     int nRefCount;
 284     NodeId id;
 285 protected:
 286
 287     // Denial-of-service detection/prevention
 288     // Key is IP address, value is banned-until-time
 289     static std::map<CSubNet, int64_t> setBanned;
 290     static CCriticalSection cs_setBanned;
 291
 292     // Whitelisted ranges. Any node connecting from these is automatically
 293     // whitelisted (as well as those connecting to whitelisted binds).
 294     static std::vector<CSubNet> vWhitelistedRange;
 295     static CCriticalSection cs_vWhitelistedRange;
 296
 297     // Basic fuzz-testing
 298     void Fuzz(int nChance); // modifies ssSend
 299
 300 public:
 301     uint256 hashContinue;
 302     int nStartingHeight;
 303
 304     // flood relay
 305     std::vector<CAddress> vAddrToSend;
 306     CRollingBloomFilter addrKnown;
 307     bool fGetAddr;
 308     std::set<uint256> setKnown;
 309
 310     // inventory based relay
 311     mruset<CInv> setInventoryKnown;
 312     std::vector<CInv> vInventoryToSend;
 313     CCriticalSection cs_inventory;
 314     std::set<uint256> setAskFor;
 315     std::multimap<int64_t, CInv> mapAskFor;
 316
 317     // Ping time measurement:
 318     // The pong reply we're expecting, or 0 if no pong expected.
 319     uint64_t nPingNonceSent;
 320     // Time (in usec) the last ping was sent, or 0 if no ping was ever sent.
 321     int64_t nPingUsecStart;
 322     // Last measured round-trip time.
 323     int64_t nPingUsecTime;
 324     // Best measured round-trip time.
 325     int64_t nMinPingUsecTime;
 326     // Whether a ping is requested.
 327     bool fPingQueued;
 328
 329     CNode(SOCKET hSocketIn, const CAddress &addrIn, const std::string &addrNameIn = "", bool fInboundIn = false);
 330     ~CNode();
 331
 332 private:
 333     // Network usage totals
 334     static CCriticalSection cs_totalBytesRecv;
 335     static CCriticalSection cs_totalBytesSent;
 336     static uint64_t nTotalBytesRecv;
 337     static uint64_t nTotalBytesSent;
 338
 339     CNode(const CNode&);
 340     void operator=(const CNode&);
 341
 342 public:
 343
 344     NodeId GetId() const {
 345       return id;
 346     }
 347
 348     int GetRefCount()
 349     {
 350         assert(nRefCount >= 0);
 351         return nRefCount;
 352     }
 353
 354     // requires LOCK(cs_vRecvMsg)
 355     unsigned int GetTotalRecvSize()
 356     {
 357         unsigned int total = 0;
 358         BOOST_FOREACH(const CNetMessage &msg, vRecvMsg)
 359             total += msg.vRecv.size() + 24;
 360         return total;
 361     }
 362
 363     // requires LOCK(cs_vRecvMsg)
 364     bool ReceiveMsgBytes(const char *pch, unsigned int nBytes);
 365
 366     // requires LOCK(cs_vRecvMsg)
 367     void SetRecvVersion(int nVersionIn)
 368     {
 369         nRecvVersion = nVersionIn;
 370         BOOST_FOREACH(CNetMessage &msg, vRecvMsg)
 371             msg.SetVersion(nVersionIn);
 372     }
 373
 374     CNode* AddRef()
 375     {
 376         nRefCount++;
 377         return this;
 378     }
 379
 380     void Release()
 381     {
 382         nRefCount--;
 383     }
 384
 385
 386
 387     void AddAddressKnown(const CAddress& addr)
 388     {
 389         addrKnown.insert(addr.GetKey());
 390     }
 391
 392     void PushAddress(const CAddress& addr)
 393     {
 394         // Known checking here is only to save space from duplicates.
 395         // SendMessages will filter it again for knowns that were added
 396         // after addresses were pushed.
 397         if (addr.IsValid() && !addrKnown.contains(addr.GetKey())) {
 398             if (vAddrToSend.size() >= MAX_ADDR_TO_SEND) {
 399                 vAddrToSend[insecure_rand() % vAddrToSend.size()] = addr;
 400             } else {
 401                 vAddrToSend.push_back(addr);
 402             }
 403         }
 404     }
 405
 406
 407     void AddInventoryKnown(const CInv& inv)
 408     {
 409         {
 410             LOCK(cs_inventory);
 411             setInventoryKnown.insert(inv);
 412         }
 413     }
 414
 415     void PushInventory(const CInv& inv)
 416     {
 417         {
 418             LOCK(cs_inventory);
 419             if (!setInventoryKnown.count(inv))
 420                 vInventoryToSend.push_back(inv);
 421         }
 422     }
 423
 424     void AskFor(const CInv& inv);
 425
 426     // TODO: Document the postcondition of this function.  Is cs_vSend locked?
 427     void BeginMessage(const char* pszCommand) EXCLUSIVE_LOCK_FUNCTION(cs_vSend);
 428
 429     // TODO: Document the precondition of this function.  Is cs_vSend locked?
 430     void AbortMessage() UNLOCK_FUNCTION(cs_vSend);
 431
 432     // TODO: Document the precondition of this function.  Is cs_vSend locked?
 433     void EndMessage() UNLOCK_FUNCTION(cs_vSend);
 434
 435     void PushVersion();
 436
 437
 438     void PushMessage(const char* pszCommand)
 439     {
 440         try
 441         {
 442             BeginMessage(pszCommand);
 443             EndMessage();
 444         }
 445         catch (...)
 446         {
 447             AbortMessage();
 448             throw;
 449         }
 450     }
 451
 452     template<typename T1>
 453     void PushMessage(const char* pszCommand, const T1& a1)
 454     {
 455         try
 456         {
 457             BeginMessage(pszCommand);
 458             ssSend << a1;
 459             EndMessage();
 460         }
 461         catch (...)
 462         {
 463             AbortMessage();
 464             throw;
 465         }
 466     }
 467
 468     template<typename T1, typename T2>
 469     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2)
 470     {
 471         try
 472         {
 473             BeginMessage(pszCommand);
 474             ssSend << a1 << a2;
 475             EndMessage();
 476         }
 477         catch (...)
 478         {
 479             AbortMessage();
 480             throw;
 481         }
 482     }
 483
 484     template<typename T1, typename T2, typename T3>
 485     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3)
 486     {
 487         try
 488         {
 489             BeginMessage(pszCommand);
 490             ssSend << a1 << a2 << a3;
 491             EndMessage();
 492         }
 493         catch (...)
 494         {
 495             AbortMessage();
 496             throw;
 497         }
 498     }
 499
 500     template<typename T1, typename T2, typename T3, typename T4>
 501     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4)
 502     {
 503         try
 504         {
 505             BeginMessage(pszCommand);
 506             ssSend << a1 << a2 << a3 << a4;
 507             EndMessage();
 508         }
 509         catch (...)
 510         {
 511             AbortMessage();
 512             throw;
 513         }
 514     }
 515
 516     template<typename T1, typename T2, typename T3, typename T4, typename T5>
 517     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)
 518     {
 519         try
 520         {
 521             BeginMessage(pszCommand);
 522             ssSend << a1 << a2 << a3 << a4 << a5;
 523             EndMessage();
 524         }
 525         catch (...)
 526         {
 527             AbortMessage();
 528             throw;
 529         }
 530     }
 531
 532     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 533     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6)
 534     {
 535         try
 536         {
 537             BeginMessage(pszCommand);
 538             ssSend << a1 << a2 << a3 << a4 << a5 << a6;
 539             EndMessage();
 540         }
 541         catch (...)
 542         {
 543             AbortMessage();
 544             throw;
 545         }
 546     }
 547
 548     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 549     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7)
 550     {
 551         try
 552         {
 553             BeginMessage(pszCommand);
 554             ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7;
 555             EndMessage();
 556         }
 557         catch (...)
 558         {
 559             AbortMessage();
 560             throw;
 561         }
 562     }
 563
 564     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 565     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8)
 566     {
 567         try
 568         {
 569             BeginMessage(pszCommand);
 570             ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8;
 571             EndMessage();
 572         }
 573         catch (...)
 574         {
 575             AbortMessage();
 576             throw;
 577         }
 578     }
 579
 580     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 581     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8, const T9& a9)
 582     {
 583         try
 584         {
 585             BeginMessage(pszCommand);
 586             ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9;
 587             EndMessage();
 588         }
 589         catch (...)
 590         {
 591             AbortMessage();
 592             throw;
 593         }
 594     }
 595
 596     void CloseSocketDisconnect();
 597
 598     // Denial-of-service detection/prevention
 599     // The idea is to detect peers that are behaving
 600     // badly and disconnect/ban them, but do it in a
 601     // one-coding-mistake-won't-shatter-the-entire-network
 602     // way.
 603     // IMPORTANT:  There should be nothing I can give a
 604     // node that it will forward on that will make that
 605     // node's peers drop it. If there is, an attacker
 606     // can isolate a node and/or try to split the network.
 607     // Dropping a node for sending stuff that is invalid
 608     // now but might be valid in a later version is also
 609     // dangerous, because it can cause a network split
 610     // between nodes running old code and nodes running
 611     // new code.
 612     static void ClearBanned(); // needed for unit testing
 613     static bool IsBanned(CNetAddr ip);
 614     static bool IsBanned(CSubNet subnet);
 615     static void Ban(const CNetAddr &ip, int64_t bantimeoffset = 0, bool sinceUnixEpoch = false);
 616     static void Ban(const CSubNet &subNet, int64_t bantimeoffset = 0, bool sinceUnixEpoch = false);
 617     static bool Unban(const CNetAddr &ip);
 618     static bool Unban(const CSubNet &ip);
 619     static void GetBanned(std::map<CSubNet, int64_t> &banmap);
 620
 621     void copyStats(CNodeStats &stats);
 622
 623     static bool IsWhitelistedRange(const CNetAddr &ip);
 624     static void AddWhitelistedRange(const CSubNet &subnet);
 625
 626     // Network stats
 627     static void RecordBytesRecv(uint64_t bytes);
 628     static void RecordBytesSent(uint64_t bytes);
 629
 630     static uint64_t GetTotalBytesRecv();
 631     static uint64_t GetTotalBytesSent();
 632 };
 633
 634
 635
 636 class CTransaction;
 637 void RelayTransaction(const CTransaction& tx);
 638 void RelayTransaction(const CTransaction& tx, const CDataStream& ss);
 639
 640 /** Access to the (IP) address database (peers.dat) */
 641 class CAddrDB
 642 {
 643 private:
 644     boost::filesystem::path pathAddr;
 645 public:
 646     CAddrDB();
 647     bool Write(const CAddrMan& addr);
 648     bool Read(CAddrMan& addr);
 649 };
 650
 651 #endif // BITCOIN_NET_H