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