src/net.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin developers
   3 // Distributed under the MIT/X11 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 "sync.h"
  18 #include "uint256.h"
  19 #include "util.h"
  20
  21 #include <deque>
  22 #include <stdint.h>
  23
  24 #ifndef WIN32
  25 #include <arpa/inet.h>
  26 #endif
  27
  28 #include <boost/foreach.hpp>
  29 #include <boost/signals2/signal.hpp>
  30
  31 class CAddrMan;
  32 class CBlockIndex;
  33 class CNode;
  34
  35 namespace boost {
  36     class thread_group;
  37 } // namespace boost
  38
  39 /** Time between pings automatically sent out for latency probing and keepalive (in seconds). */
  40 static const int PING_INTERVAL = 2 * 60;
  41 /** Time after which to disconnect, after waiting for a ping response (or inactivity). */
  42 static const int TIMEOUT_INTERVAL = 20 * 60;
  43 /** The maximum number of entries in an 'inv' protocol message */
  44 static const unsigned int MAX_INV_SZ = 50000;
  45 /** -listen default */
  46 static const bool DEFAULT_LISTEN = true;
  47 /** -upnp default */
  48 #ifdef USE_UPNP
  49 static const bool DEFAULT_UPNP = USE_UPNP;
  50 #else
  51 static const bool DEFAULT_UPNP = false;
  52 #endif
  53
  54 inline unsigned int ReceiveFloodSize() { return 1000*GetArg("-maxreceivebuffer", 5*1000); }
  55 inline unsigned int SendBufferSize() { return 1000*GetArg("-maxsendbuffer", 1*1000); }
  56
  57 void AddOneShot(std::string strDest);
  58 bool RecvLine(SOCKET hSocket, std::string& strLine);
  59 bool GetMyExternalIP(CNetAddr& ipRet);
  60 void AddressCurrentlyConnected(const CService& addr);
  61 CNode* FindNode(const CNetAddr& ip);
  62 CNode* FindNode(const CService& ip);
  63 CNode* ConnectNode(CAddress addrConnect, const char *pszDest = NULL);
  64 bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false);
  65 void MapPort(bool fUseUPnP);
  66 unsigned short GetListenPort();
  67 bool BindListenPort(const CService &bindAddr, std::string& strError, bool fWhitelisted = false);
  68 void StartNode(boost::thread_group& threadGroup);
  69 bool StopNode();
  70 void SocketSendData(CNode *pnode);
  71
  72 typedef int NodeId;
  73
  74 // Signals for message handling
  75 struct CNodeSignals
  76 {
  77     boost::signals2::signal<int ()> GetHeight;
  78     boost::signals2::signal<bool (CNode*)> ProcessMessages;
  79     boost::signals2::signal<bool (CNode*, bool)> SendMessages;
  80     boost::signals2::signal<void (NodeId, const CNode*)> InitializeNode;
  81     boost::signals2::signal<void (NodeId)> FinalizeNode;
  82 };
  83
  84
  85 CNodeSignals& GetNodeSignals();
  86
  87
  88 enum
  89 {
  90     LOCAL_NONE,   // unknown
  91     LOCAL_IF,     // address a local interface listens on
  92     LOCAL_BIND,   // address explicit bound to
  93     LOCAL_UPNP,   // address reported by UPnP
  94     LOCAL_HTTP,   // address reported by whatismyip.com and similar
  95     LOCAL_MANUAL, // address explicitly specified (-externalip=)
  96
  97     LOCAL_MAX
  98 };
  99
 100 void SetLimited(enum Network net, bool fLimited = true);
 101 bool IsLimited(enum Network net);
 102 bool IsLimited(const CNetAddr& addr);
 103 bool AddLocal(const CService& addr, int nScore = LOCAL_NONE);
 104 bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
 105 bool SeenLocal(const CService& addr);
 106 bool IsLocal(const CService& addr);
 107 bool GetLocal(CService &addr, const CNetAddr *paddrPeer = NULL);
 108 bool IsReachable(const CNetAddr &addr);
 109 void SetReachable(enum Network net, bool fFlag = true);
 110 CAddress GetLocalAddress(const CNetAddr *paddrPeer = NULL);
 111
 112
 113 extern bool fDiscover;
 114 extern bool fListen;
 115 extern uint64_t nLocalServices;
 116 extern uint64_t nLocalHostNonce;
 117 extern CAddrMan addrman;
 118 extern int nMaxConnections;
 119
 120 extern std::vector<CNode*> vNodes;
 121 extern CCriticalSection cs_vNodes;
 122 extern std::map<CInv, CDataStream> mapRelay;
 123 extern std::deque<std::pair<int64_t, CInv> > vRelayExpiration;
 124 extern CCriticalSection cs_mapRelay;
 125 extern limitedmap<CInv, int64_t> mapAlreadyAskedFor;
 126
 127 extern std::vector<std::string> vAddedNodes;
 128 extern CCriticalSection cs_vAddedNodes;
 129
 130 extern NodeId nLastNodeId;
 131 extern CCriticalSection cs_nLastNodeId;
 132
 133 struct LocalServiceInfo {
 134     int nScore;
 135     int nPort;
 136 };
 137
 138 extern CCriticalSection cs_mapLocalHost;
 139 extern std::map<CNetAddr, LocalServiceInfo> mapLocalHost;
 140
 141 class CNodeStats
 142 {
 143 public:
 144     NodeId nodeid;
 145     uint64_t nServices;
 146     int64_t nLastSend;
 147     int64_t nLastRecv;
 148     int64_t nTimeConnected;
 149     std::string addrName;
 150     int nVersion;
 151     std::string cleanSubVer;
 152     bool fInbound;
 153     int nStartingHeight;
 154     uint64_t nSendBytes;
 155     uint64_t nRecvBytes;
 156     bool fSyncNode;
 157     bool fWhitelisted;
 158     double dPingTime;
 159     double dPingWait;
 160     std::string addrLocal;
 161 };
 162
 163
 164
 165
 166 class CNetMessage {
 167 public:
 168     bool in_data;                   // parsing header (false) or data (true)
 169
 170     CDataStream hdrbuf;             // partially received header
 171     CMessageHeader hdr;             // complete header
 172     unsigned int nHdrPos;
 173
 174     CDataStream vRecv;              // received message data
 175     unsigned int nDataPos;
 176
 177     int64_t nTime;                  // time (in microseconds) of message receipt.
 178
 179     CNetMessage(int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), vRecv(nTypeIn, nVersionIn) {
 180         hdrbuf.resize(24);
 181         in_data = false;
 182         nHdrPos = 0;
 183         nDataPos = 0;
 184         nTime = 0;
 185     }
 186
 187     bool complete() const
 188     {
 189         if (!in_data)
 190             return false;
 191         return (hdr.nMessageSize == nDataPos);
 192     }
 193
 194     void SetVersion(int nVersionIn)
 195     {
 196         hdrbuf.SetVersion(nVersionIn);
 197         vRecv.SetVersion(nVersionIn);
 198     }
 199
 200     int readHeader(const char *pch, unsigned int nBytes);
 201     int readData(const char *pch, unsigned int nBytes);
 202 };
 203
 204
 205
 206
 207
 208 /** Information about a peer */
 209 class CNode
 210 {
 211 public:
 212     // socket
 213     uint64_t nServices;
 214     SOCKET hSocket;
 215     CDataStream ssSend;
 216     size_t nSendSize; // total size of all vSendMsg entries
 217     size_t nSendOffset; // offset inside the first vSendMsg already sent
 218     uint64_t nSendBytes;
 219     std::deque<CSerializeData> vSendMsg;
 220     CCriticalSection cs_vSend;
 221
 222     std::deque<CInv> vRecvGetData;
 223     std::deque<CNetMessage> vRecvMsg;
 224     CCriticalSection cs_vRecvMsg;
 225     uint64_t nRecvBytes;
 226     int nRecvVersion;
 227
 228     int64_t nLastSend;
 229     int64_t nLastRecv;
 230     int64_t nTimeConnected;
 231     CAddress addr;
 232     std::string addrName;
 233     CService addrLocal;
 234     int nVersion;
 235     // strSubVer is whatever byte array we read from the wire. However, this field is intended
 236     // to be printed out, displayed to humans in various forms and so on. So we sanitize it and
 237     // store the sanitized version in cleanSubVer. The original should be used when dealing with
 238     // the network or wire types and the cleaned string used when displayed or logged.
 239     std::string strSubVer, cleanSubVer;
 240     bool fWhitelisted; // This peer can bypass DoS banning.
 241     bool fOneShot;
 242     bool fClient;
 243     bool fInbound;
 244     bool fNetworkNode;
 245     bool fSuccessfullyConnected;
 246     bool fDisconnect;
 247     // We use fRelayTxes for two purposes -
 248     // a) it allows us to not relay tx invs before receiving the peer's version message
 249     // b) the peer may tell us in their version message that we should not relay tx invs
 250     //    until they have initialized their bloom filter.
 251     bool fRelayTxes;
 252     CSemaphoreGrant grantOutbound;
 253     CCriticalSection cs_filter;
 254     CBloomFilter* pfilter;
 255     int nRefCount;
 256     NodeId id;
 257 protected:
 258
 259     // Denial-of-service detection/prevention
 260     // Key is IP address, value is banned-until-time
 261     static std::map<CNetAddr, int64_t> setBanned;
 262     static CCriticalSection cs_setBanned;
 263
 264     // Whitelisted ranges. Any node connecting from these is automatically
 265     // whitelisted (as well as those connecting to whitelisted binds).
 266     static std::vector<CSubNet> vWhitelistedRange;
 267     static CCriticalSection cs_vWhitelistedRange;
 268
 269     // Basic fuzz-testing
 270     void Fuzz(int nChance); // modifies ssSend
 271
 272 public:
 273     uint256 hashContinue;
 274     CBlockIndex* pindexLastGetBlocksBegin;
 275     uint256 hashLastGetBlocksEnd;
 276     int nStartingHeight;
 277     bool fStartSync;
 278
 279     // flood relay
 280     std::vector<CAddress> vAddrToSend;
 281     mruset<CAddress> setAddrKnown;
 282     bool fGetAddr;
 283     std::set<uint256> setKnown;
 284
 285     // inventory based relay
 286     mruset<CInv> setInventoryKnown;
 287     std::vector<CInv> vInventoryToSend;
 288     CCriticalSection cs_inventory;
 289     std::multimap<int64_t, CInv> mapAskFor;
 290
 291     // Ping time measurement:
 292     // The pong reply we're expecting, or 0 if no pong expected.
 293     uint64_t nPingNonceSent;
 294     // Time (in usec) the last ping was sent, or 0 if no ping was ever sent.
 295     int64_t nPingUsecStart;
 296     // Last measured round-trip time.
 297     int64_t nPingUsecTime;
 298     // Whether a ping is requested.
 299     bool fPingQueued;
 300
 301     CNode(SOCKET hSocketIn, CAddress addrIn, std::string addrNameIn = "", bool fInboundIn=false) : ssSend(SER_NETWORK, INIT_PROTO_VERSION), setAddrKnown(5000)
 302     {
 303         nServices = 0;
 304         hSocket = hSocketIn;
 305         nRecvVersion = INIT_PROTO_VERSION;
 306         nLastSend = 0;
 307         nLastRecv = 0;
 308         nSendBytes = 0;
 309         nRecvBytes = 0;
 310         nTimeConnected = GetTime();
 311         addr = addrIn;
 312         addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
 313         nVersion = 0;
 314         strSubVer = "";
 315         fWhitelisted = false;
 316         fOneShot = false;
 317         fClient = false; // set by version message
 318         fInbound = fInboundIn;
 319         fNetworkNode = false;
 320         fSuccessfullyConnected = false;
 321         fDisconnect = false;
 322         nRefCount = 0;
 323         nSendSize = 0;
 324         nSendOffset = 0;
 325         hashContinue = 0;
 326         pindexLastGetBlocksBegin = 0;
 327         hashLastGetBlocksEnd = 0;
 328         nStartingHeight = -1;
 329         fStartSync = false;
 330         fGetAddr = false;
 331         fRelayTxes = false;
 332         setInventoryKnown.max_size(SendBufferSize() / 1000);
 333         pfilter = new CBloomFilter();
 334         nPingNonceSent = 0;
 335         nPingUsecStart = 0;
 336         nPingUsecTime = 0;
 337         fPingQueued = false;
 338
 339         {
 340             LOCK(cs_nLastNodeId);
 341             id = nLastNodeId++;
 342         }
 343
 344         if (fLogIPs)
 345             LogPrint("net", "Added connection to %s peer=%d\n", addrName, id);
 346         else
 347             LogPrint("net", "Added connection peer=%d\n", id);
 348
 349         // Be shy and don't send version until we hear
 350         if (hSocket != INVALID_SOCKET && !fInbound)
 351             PushVersion();
 352
 353         GetNodeSignals().InitializeNode(GetId(), this);
 354     }
 355
 356     ~CNode()
 357     {
 358         if (hSocket != INVALID_SOCKET)
 359         {
 360             closesocket(hSocket);
 361             hSocket = INVALID_SOCKET;
 362         }
 363         if (pfilter)
 364             delete pfilter;
 365         GetNodeSignals().FinalizeNode(GetId());
 366     }
 367
 368 private:
 369     // Network usage totals
 370     static CCriticalSection cs_totalBytesRecv;
 371     static CCriticalSection cs_totalBytesSent;
 372     static uint64_t nTotalBytesRecv;
 373     static uint64_t nTotalBytesSent;
 374
 375     CNode(const CNode&);
 376     void operator=(const CNode&);
 377
 378 public:
 379
 380     NodeId GetId() const {
 381       return id;
 382     }
 383
 384     int GetRefCount()
 385     {
 386         assert(nRefCount >= 0);
 387         return nRefCount;
 388     }
 389
 390     // requires LOCK(cs_vRecvMsg)
 391     unsigned int GetTotalRecvSize()
 392     {
 393         unsigned int total = 0;
 394         BOOST_FOREACH(const CNetMessage &msg, vRecvMsg)
 395             total += msg.vRecv.size() + 24;
 396         return total;
 397     }
 398
 399     // requires LOCK(cs_vRecvMsg)
 400     bool ReceiveMsgBytes(const char *pch, unsigned int nBytes);
 401
 402     // requires LOCK(cs_vRecvMsg)
 403     void SetRecvVersion(int nVersionIn)
 404     {
 405         nRecvVersion = nVersionIn;
 406         BOOST_FOREACH(CNetMessage &msg, vRecvMsg)
 407             msg.SetVersion(nVersionIn);
 408     }
 409
 410     CNode* AddRef()
 411     {
 412         nRefCount++;
 413         return this;
 414     }
 415
 416     void Release()
 417     {
 418         nRefCount--;
 419     }
 420
 421
 422
 423     void AddAddressKnown(const CAddress& addr)
 424     {
 425         setAddrKnown.insert(addr);
 426     }
 427
 428     void PushAddress(const CAddress& addr)
 429     {
 430         // Known checking here is only to save space from duplicates.
 431         // SendMessages will filter it again for knowns that were added
 432         // after addresses were pushed.
 433         if (addr.IsValid() && !setAddrKnown.count(addr))
 434             vAddrToSend.push_back(addr);
 435     }
 436
 437
 438     void AddInventoryKnown(const CInv& inv)
 439     {
 440         {
 441             LOCK(cs_inventory);
 442             setInventoryKnown.insert(inv);
 443         }
 444     }
 445
 446     void PushInventory(const CInv& inv)
 447     {
 448         {
 449             LOCK(cs_inventory);
 450             if (!setInventoryKnown.count(inv))
 451                 vInventoryToSend.push_back(inv);
 452         }
 453     }
 454
 455     void AskFor(const CInv& inv)
 456     {
 457         // We're using mapAskFor as a priority queue,
 458         // the key is the earliest time the request can be sent
 459         int64_t nRequestTime;
 460         limitedmap<CInv, int64_t>::const_iterator it = mapAlreadyAskedFor.find(inv);
 461         if (it != mapAlreadyAskedFor.end())
 462             nRequestTime = it->second;
 463         else
 464             nRequestTime = 0;
 465         LogPrint("net", "askfor %s  %d (%s) peer=%d\n", inv.ToString(), nRequestTime, DateTimeStrFormat("%H:%M:%S", nRequestTime/1000000).c_str(), id);
 466
 467         // Make sure not to reuse time indexes to keep things in the same order
 468         int64_t nNow = GetTimeMicros() - 1000000;
 469         static int64_t nLastTime;
 470         ++nLastTime;
 471         nNow = std::max(nNow, nLastTime);
 472         nLastTime = nNow;
 473
 474         // Each retry is 2 minutes after the last
 475         nRequestTime = std::max(nRequestTime + 2 * 60 * 1000000, nNow);
 476         if (it != mapAlreadyAskedFor.end())
 477             mapAlreadyAskedFor.update(it, nRequestTime);
 478         else
 479             mapAlreadyAskedFor.insert(std::make_pair(inv, nRequestTime));
 480         mapAskFor.insert(std::make_pair(nRequestTime, inv));
 481     }
 482
 483
 484
 485     // TODO: Document the postcondition of this function.  Is cs_vSend locked?
 486     void BeginMessage(const char* pszCommand) EXCLUSIVE_LOCK_FUNCTION(cs_vSend)
 487     {
 488         ENTER_CRITICAL_SECTION(cs_vSend);
 489         assert(ssSend.size() == 0);
 490         ssSend << CMessageHeader(pszCommand, 0);
 491         LogPrint("net", "sending: %s ", pszCommand);
 492     }
 493
 494     // TODO: Document the precondition of this function.  Is cs_vSend locked?
 495     void AbortMessage() UNLOCK_FUNCTION(cs_vSend)
 496     {
 497         ssSend.clear();
 498
 499         LEAVE_CRITICAL_SECTION(cs_vSend);
 500
 501         LogPrint("net", "(aborted)\n");
 502     }
 503
 504     // TODO: Document the precondition of this function.  Is cs_vSend locked?
 505     void EndMessage() UNLOCK_FUNCTION(cs_vSend)
 506     {
 507         // The -*messagestest options are intentionally not documented in the help message,
 508         // since they are only used during development to debug the networking code and are
 509         // not intended for end-users.
 510         if (mapArgs.count("-dropmessagestest") && GetRand(GetArg("-dropmessagestest", 2)) == 0)
 511         {
 512             LogPrint("net", "dropmessages DROPPING SEND MESSAGE\n");
 513             AbortMessage();
 514             return;
 515         }
 516         if (mapArgs.count("-fuzzmessagestest"))
 517             Fuzz(GetArg("-fuzzmessagestest", 10));
 518
 519         if (ssSend.size() == 0)
 520             return;
 521
 522         // Set the size
 523         unsigned int nSize = ssSend.size() - CMessageHeader::HEADER_SIZE;
 524         memcpy((char*)&ssSend[CMessageHeader::MESSAGE_SIZE_OFFSET], &nSize, sizeof(nSize));
 525
 526         // Set the checksum
 527         uint256 hash = Hash(ssSend.begin() + CMessageHeader::HEADER_SIZE, ssSend.end());
 528         unsigned int nChecksum = 0;
 529         memcpy(&nChecksum, &hash, sizeof(nChecksum));
 530         assert(ssSend.size () >= CMessageHeader::CHECKSUM_OFFSET + sizeof(nChecksum));
 531         memcpy((char*)&ssSend[CMessageHeader::CHECKSUM_OFFSET], &nChecksum, sizeof(nChecksum));
 532
 533         LogPrint("net", "(%d bytes) peer=%d\n", nSize, id);
 534
 535         std::deque<CSerializeData>::iterator it = vSendMsg.insert(vSendMsg.end(), CSerializeData());
 536         ssSend.GetAndClear(*it);
 537         nSendSize += (*it).size();
 538
 539         // If write queue empty, attempt "optimistic write"
 540         if (it == vSendMsg.begin())
 541             SocketSendData(this);
 542
 543         LEAVE_CRITICAL_SECTION(cs_vSend);
 544     }
 545
 546     void PushVersion();
 547
 548
 549     void PushMessage(const char* pszCommand)
 550     {
 551         try
 552         {
 553             BeginMessage(pszCommand);
 554             EndMessage();
 555         }
 556         catch (...)
 557         {
 558             AbortMessage();
 559             throw;
 560         }
 561     }
 562
 563     template<typename T1>
 564     void PushMessage(const char* pszCommand, const T1& a1)
 565     {
 566         try
 567         {
 568             BeginMessage(pszCommand);
 569             ssSend << a1;
 570             EndMessage();
 571         }
 572         catch (...)
 573         {
 574             AbortMessage();
 575             throw;
 576         }
 577     }
 578
 579     template<typename T1, typename T2>
 580     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2)
 581     {
 582         try
 583         {
 584             BeginMessage(pszCommand);
 585             ssSend << a1 << a2;
 586             EndMessage();
 587         }
 588         catch (...)
 589         {
 590             AbortMessage();
 591             throw;
 592         }
 593     }
 594
 595     template<typename T1, typename T2, typename T3>
 596     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3)
 597     {
 598         try
 599         {
 600             BeginMessage(pszCommand);
 601             ssSend << a1 << a2 << a3;
 602             EndMessage();
 603         }
 604         catch (...)
 605         {
 606             AbortMessage();
 607             throw;
 608         }
 609     }
 610
 611     template<typename T1, typename T2, typename T3, typename T4>
 612     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4)
 613     {
 614         try
 615         {
 616             BeginMessage(pszCommand);
 617             ssSend << a1 << a2 << a3 << a4;
 618             EndMessage();
 619         }
 620         catch (...)
 621         {
 622             AbortMessage();
 623             throw;
 624         }
 625     }
 626
 627     template<typename T1, typename T2, typename T3, typename T4, typename T5>
 628     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)
 629     {
 630         try
 631         {
 632             BeginMessage(pszCommand);
 633             ssSend << a1 << a2 << a3 << a4 << a5;
 634             EndMessage();
 635         }
 636         catch (...)
 637         {
 638             AbortMessage();
 639             throw;
 640         }
 641     }
 642
 643     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 644     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6)
 645     {
 646         try
 647         {
 648             BeginMessage(pszCommand);
 649             ssSend << a1 << a2 << a3 << a4 << a5 << a6;
 650             EndMessage();
 651         }
 652         catch (...)
 653         {
 654             AbortMessage();
 655             throw;
 656         }
 657     }
 658
 659     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 660     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)
 661     {
 662         try
 663         {
 664             BeginMessage(pszCommand);
 665             ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7;
 666             EndMessage();
 667         }
 668         catch (...)
 669         {
 670             AbortMessage();
 671             throw;
 672         }
 673     }
 674
 675     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 676     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)
 677     {
 678         try
 679         {
 680             BeginMessage(pszCommand);
 681             ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8;
 682             EndMessage();
 683         }
 684         catch (...)
 685         {
 686             AbortMessage();
 687             throw;
 688         }
 689     }
 690
 691     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 692     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)
 693     {
 694         try
 695         {
 696             BeginMessage(pszCommand);
 697             ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9;
 698             EndMessage();
 699         }
 700         catch (...)
 701         {
 702             AbortMessage();
 703             throw;
 704         }
 705     }
 706
 707     bool IsSubscribed(unsigned int nChannel);
 708     void Subscribe(unsigned int nChannel, unsigned int nHops=0);
 709     void CancelSubscribe(unsigned int nChannel);
 710     void CloseSocketDisconnect();
 711
 712     // Denial-of-service detection/prevention
 713     // The idea is to detect peers that are behaving
 714     // badly and disconnect/ban them, but do it in a
 715     // one-coding-mistake-won't-shatter-the-entire-network
 716     // way.
 717     // IMPORTANT:  There should be nothing I can give a
 718     // node that it will forward on that will make that
 719     // node's peers drop it. If there is, an attacker
 720     // can isolate a node and/or try to split the network.
 721     // Dropping a node for sending stuff that is invalid
 722     // now but might be valid in a later version is also
 723     // dangerous, because it can cause a network split
 724     // between nodes running old code and nodes running
 725     // new code.
 726     static void ClearBanned(); // needed for unit testing
 727     static bool IsBanned(CNetAddr ip);
 728     static bool Ban(const CNetAddr &ip);
 729     void copyStats(CNodeStats &stats);
 730
 731     static bool IsWhitelistedRange(const CNetAddr &ip);
 732     static void AddWhitelistedRange(const CSubNet &subnet);
 733
 734     // Network stats
 735     static void RecordBytesRecv(uint64_t bytes);
 736     static void RecordBytesSent(uint64_t bytes);
 737
 738     static uint64_t GetTotalBytesRecv();
 739     static uint64_t GetTotalBytesSent();
 740 };
 741
 742
 743
 744 class CTransaction;
 745 void RelayTransaction(const CTransaction& tx);
 746 void RelayTransaction(const CTransaction& tx, const CDataStream& ss);
 747
 748 /** Access to the (IP) address database (peers.dat) */
 749 class CAddrDB
 750 {
 751 private:
 752     boost::filesystem::path pathAddr;
 753 public:
 754     CAddrDB();
 755     bool Write(const CAddrMan& addr);
 756     bool Read(CAddrMan& addr);
 757 };
 758
 759 #endif