src/net.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 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 #ifndef BITCOIN_NET_H
   6 #define BITCOIN_NET_H
   7
   8 #include <deque>
   9 #ifndef Q_MOC_RUN
  10 #include <boost/array.hpp>
  11 #include <boost/foreach.hpp>
  12 #endif
  13 #include <openssl/rand.h>
  14
  15 #ifndef WIN32
  16 #include <arpa/inet.h>
  17 #endif
  18
  19 #include "mruset.h"
  20 #include "netbase.h"
  21 #include "protocol.h"
  22 #include "addrman.h"
  23 #include "hash.h"
  24
  25 class CRequestTracker;
  26 class CNode;
  27 class CBlockIndex;
  28 extern int nBestHeight;
  29
  30
  31
  32 inline uint64_t ReceiveBufferSize() { return 1000*GetArg("-maxreceivebuffer", 5*1000); }
  33 inline uint64_t SendBufferSize() { return 1000*GetArg("-maxsendbuffer", 1*1000); }
  34
  35 void AddOneShot(std::string strDest);
  36 bool RecvLine(SOCKET hSocket, std::string& strLine);
  37 bool GetMyExternalIP(CNetAddr& ipRet);
  38 void AddressCurrentlyConnected(const CService& addr);
  39 CNode* FindNode(const CNetAddr& ip);
  40 CNode* FindNode(const CService& ip);
  41 CNode* ConnectNode(CAddress addrConnect, const char *strDest = NULL, int64_t nTimeout=0);
  42 bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false);
  43 void MapPort();
  44 unsigned short GetListenPort();
  45 bool BindListenPort(const CService &bindAddr, std::string& strError=REF(std::string()));
  46 void StartNode(void* parg);
  47 bool StopNode();
  48
  49 enum
  50 {
  51     LOCAL_NONE,   // unknown
  52     LOCAL_IF,     // address a local interface listens on
  53     LOCAL_BIND,   // address explicit bound to
  54     LOCAL_UPNP,   // address reported by UPnP
  55     LOCAL_IRC,    // address reported by IRC (deprecated)
  56     LOCAL_HTTP,   // address reported by whatismyip.com and similar
  57     LOCAL_MANUAL, // address explicitly specified (-externalip=)
  58
  59     LOCAL_MAX
  60 };
  61
  62 void SetLimited(enum Network net, bool fLimited = true);
  63 bool IsLimited(enum Network net);
  64 bool IsLimited(const CNetAddr& addr);
  65 bool AddLocal(const CService& addr, int nScore = LOCAL_NONE);
  66 bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
  67 bool SeenLocal(const CService& addr);
  68 bool IsLocal(const CService& addr);
  69 bool GetLocal(CService &addr, const CNetAddr *paddrPeer = NULL);
  70 bool IsReachable(const CNetAddr &addr);
  71 void SetReachable(enum Network net, bool fFlag = true);
  72 CAddress GetLocalAddress(const CNetAddr *paddrPeer = NULL);
  73
  74
  75 enum
  76 {
  77     MSG_TX = 1,
  78     MSG_BLOCK,
  79 };
  80
  81 class CRequestTracker
  82 {
  83 public:
  84     void (*fn)(void*, CDataStream&);
  85     void* param1;
  86
  87     explicit CRequestTracker(void (*fnIn)(void*, CDataStream&)=NULL, void* param1In=NULL)
  88     {
  89         fn = fnIn;
  90         param1 = param1In;
  91     }
  92
  93     bool IsNull()
  94     {
  95         return fn == NULL;
  96     }
  97 };
  98
  99
 100 /** Thread types */
 101 enum threadId
 102 {
 103     THREAD_SOCKETHANDLER,
 104     THREAD_OPENCONNECTIONS,
 105     THREAD_MESSAGEHANDLER,
 106     THREAD_RPCLISTENER,
 107     THREAD_UPNP,
 108     THREAD_DNSSEED,
 109     THREAD_ADDEDCONNECTIONS,
 110     THREAD_DUMPADDRESS,
 111     THREAD_RPCHANDLER,
 112     THREAD_MINTER,
 113     THREAD_SCRIPTCHECK,
 114
 115     THREAD_MAX
 116 };
 117
 118 extern bool fClient;
 119 extern bool fDiscover;
 120 extern bool fUseUPnP;
 121 extern uint64_t nLocalServices;
 122 extern uint64_t nLocalHostNonce;
 123 extern CAddress addrSeenByPeer;
 124 extern boost::array<int, THREAD_MAX> vnThreadsRunning;
 125 extern CAddrMan addrman;
 126
 127 extern std::vector<CNode*> vNodes;
 128 extern CCriticalSection cs_vNodes;
 129 extern std::vector<std::string> vAddedNodes;
 130 extern CCriticalSection cs_vAddedNodes;
 131 extern std::map<CInv, CDataStream> mapRelay;
 132 extern std::deque<std::pair<int64_t, CInv> > vRelayExpiration;
 133 extern CCriticalSection cs_mapRelay;
 134 extern std::map<CInv, int64_t> mapAlreadyAskedFor;
 135
 136
 137
 138
 139 class CNodeStats
 140 {
 141 public:
 142     uint64_t nServices;
 143     int64_t nLastSend;
 144     int64_t nLastRecv;
 145     int64_t nTimeConnected;
 146     std::string addrName;
 147     int32_t nVersion;
 148     std::string strSubVer;
 149     bool fInbound;
 150     int64_t nReleaseTime;
 151     int32_t nStartingHeight;
 152     int32_t nMisbehavior;
 153     uint64_t nSendBytes;
 154     uint64_t nRecvBytes;
 155     bool fSyncNode;
 156 };
 157
 158
 159
 160
 161
 162 /** Information about a peer */
 163 class CNode
 164 {
 165 public:
 166     // socket
 167     uint64_t nServices;
 168     SOCKET hSocket;
 169     CDataStream vSend;
 170     CDataStream vRecv;
 171     uint64_t nSendBytes;
 172     uint64_t nRecvBytes;
 173     CCriticalSection cs_vSend;
 174     CCriticalSection cs_vRecv;
 175     int64_t nLastSend;
 176     int64_t nLastRecv;
 177     int64_t nLastSendEmpty;
 178     int64_t nTimeConnected;
 179     int32_t nHeaderStart;
 180     uint32_t nMessageStart;
 181     CAddress addr;
 182     std::string addrName;
 183     CService addrLocal;
 184     int32_t nVersion;
 185     std::string strSubVer;
 186     bool fOneShot;
 187     bool fClient;
 188     bool fInbound;
 189     bool fNetworkNode;
 190     bool fSuccessfullyConnected;
 191     bool fDisconnect;
 192     CSemaphoreGrant grantOutbound;
 193 protected:
 194     int nRefCount;
 195
 196     // Denial-of-service detection/prevention
 197     // Key is IP address, value is banned-until-time
 198     static std::map<CNetAddr, int64_t> setBanned;
 199     static CCriticalSection cs_setBanned;
 200     int nMisbehavior;
 201
 202 public:
 203     int64_t nReleaseTime;
 204     std::map<uint256, CRequestTracker> mapRequests;
 205     CCriticalSection cs_mapRequests;
 206     uint256 hashContinue;
 207     CBlockIndex* pindexLastGetBlocksBegin;
 208     uint256 hashLastGetBlocksEnd;
 209     int32_t nStartingHeight;
 210     bool fStartSync;
 211
 212     // flood relay
 213     std::vector<CAddress> vAddrToSend;
 214     std::set<CAddress> setAddrKnown;
 215     bool fGetAddr;
 216     std::set<uint256> setKnown;
 217     uint256 hashCheckpointKnown; // ppcoin: known sent sync-checkpoint
 218
 219     // inventory based relay
 220     mruset<CInv> setInventoryKnown;
 221     std::vector<CInv> vInventoryToSend;
 222     CCriticalSection cs_inventory;
 223     std::multimap<int64_t, CInv> mapAskFor;
 224
 225     CNode(SOCKET hSocketIn, CAddress addrIn, std::string addrNameIn = "", bool fInboundIn=false) : vSend(SER_NETWORK, MIN_PROTO_VERSION), vRecv(SER_NETWORK, MIN_PROTO_VERSION)
 226     {
 227         nServices = 0;
 228         hSocket = hSocketIn;
 229         nLastSend = 0;
 230         nLastRecv = 0;
 231         nSendBytes = 0;
 232         nRecvBytes = 0;
 233         nLastSendEmpty = GetTime();
 234         nTimeConnected = GetTime();
 235         nHeaderStart = -1;
 236         nMessageStart = -1;
 237         addr = addrIn;
 238         addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
 239         nVersion = 0;
 240         strSubVer = "";
 241         fOneShot = false;
 242         fClient = false; // set by version message
 243         fInbound = fInboundIn;
 244         fNetworkNode = false;
 245         fSuccessfullyConnected = false;
 246         fDisconnect = false;
 247         nRefCount = 0;
 248         nReleaseTime = 0;
 249         hashContinue = 0;
 250         pindexLastGetBlocksBegin = 0;
 251         hashLastGetBlocksEnd = 0;
 252         nStartingHeight = -1;
 253         fStartSync = false;
 254         fGetAddr = false;
 255         nMisbehavior = 0;
 256         hashCheckpointKnown = 0;
 257         setInventoryKnown.max_size((size_t)SendBufferSize() / 1000);
 258
 259         // Be shy and don't send version until we hear
 260         if (hSocket != INVALID_SOCKET && !fInbound)
 261             PushVersion();
 262     }
 263
 264     ~CNode()
 265     {
 266         if (hSocket != INVALID_SOCKET)
 267         {
 268             closesocket(hSocket);
 269             hSocket = INVALID_SOCKET;
 270         }
 271     }
 272
 273
 274 private:
 275     // Network usage totals
 276     static CCriticalSection cs_totalBytesRecv;
 277     static CCriticalSection cs_totalBytesSent;
 278     static uint64_t nTotalBytesRecv;
 279     static uint64_t nTotalBytesSent;
 280     CNode(const CNode&);
 281     void operator=(const CNode&);
 282 public:
 283
 284
 285     int GetRefCount()
 286     {
 287         return std::max(nRefCount, 0) + (GetTime() < nReleaseTime ? 1 : 0);
 288     }
 289
 290     CNode* AddRef(int64_t nTimeout=0)
 291     {
 292         if (nTimeout != 0)
 293             nReleaseTime = std::max(nReleaseTime, GetTime() + nTimeout);
 294         else
 295             nRefCount++;
 296         return this;
 297     }
 298
 299     void Release()
 300     {
 301         nRefCount--;
 302     }
 303
 304
 305
 306     void AddAddressKnown(const CAddress& addr)
 307     {
 308         setAddrKnown.insert(addr);
 309     }
 310
 311     void PushAddress(const CAddress& addr)
 312     {
 313         // Known checking here is only to save space from duplicates.
 314         // SendMessages will filter it again for knowns that were added
 315         // after addresses were pushed.
 316         if (addr.IsValid() && !setAddrKnown.count(addr))
 317             vAddrToSend.push_back(addr);
 318     }
 319
 320
 321     void AddInventoryKnown(const CInv& inv)
 322     {
 323         {
 324             LOCK(cs_inventory);
 325             setInventoryKnown.insert(inv);
 326         }
 327     }
 328
 329     void PushInventory(const CInv& inv)
 330     {
 331         {
 332             LOCK(cs_inventory);
 333             if (!setInventoryKnown.count(inv))
 334                 vInventoryToSend.push_back(inv);
 335         }
 336     }
 337
 338     void AskFor(const CInv& inv)
 339     {
 340         // We're using mapAskFor as a priority queue,
 341         // the key is the earliest time the request can be sent
 342         int64_t& nRequestTime = mapAlreadyAskedFor[inv];
 343         if (fDebugNet)
 344             printf("askfor %s   %" PRId64 " (%s)\n", inv.ToString().c_str(), nRequestTime, DateTimeStrFormat("%H:%M:%S", nRequestTime/1000000).c_str());
 345
 346         // Make sure not to reuse time indexes to keep things in the same order
 347         int64_t nNow = (GetTime() - 1) * 1000000;
 348         static int64_t nLastTime;
 349         ++nLastTime;
 350         nNow = std::max(nNow, nLastTime);
 351         nLastTime = nNow;
 352
 353         // Each retry is 2 minutes after the last
 354         nRequestTime = std::max(nRequestTime + 2 * 60 * 1000000, nNow);
 355         mapAskFor.insert(std::make_pair(nRequestTime, inv));
 356     }
 357
 358
 359
 360     void BeginMessage(const char* pszCommand)
 361     {
 362         ENTER_CRITICAL_SECTION(cs_vSend);
 363         if (nHeaderStart != -1)
 364             AbortMessage();
 365         nHeaderStart = (int32_t)vSend.size();
 366         vSend << CMessageHeader(pszCommand, 0);
 367         nMessageStart = (uint32_t)vSend.size();
 368         if (fDebug)
 369             printf("sending: %s ", pszCommand);
 370     }
 371
 372     void AbortMessage()
 373     {
 374         if (nHeaderStart < 0)
 375             return;
 376         vSend.resize(nHeaderStart);
 377         nHeaderStart = -1;
 378         nMessageStart = -1;
 379         LEAVE_CRITICAL_SECTION(cs_vSend);
 380
 381         if (fDebug)
 382             printf("(aborted)\n");
 383     }
 384
 385     void EndMessage()
 386     {
 387         if (mapArgs.count("-dropmessagestest") && GetRand(atoi(mapArgs["-dropmessagestest"])) == 0)
 388         {
 389             printf("dropmessages DROPPING SEND MESSAGE\n");
 390             AbortMessage();
 391             return;
 392         }
 393
 394         if (nHeaderStart < 0)
 395             return;
 396
 397         // Set the size
 398         uint32_t nSize = (uint32_t) vSend.size() - nMessageStart;
 399         memcpy((char*)&vSend[nHeaderStart] + CMessageHeader::MESSAGE_SIZE_OFFSET, &nSize, sizeof(nSize));
 400
 401         // Set the checksum
 402         uint256 hash = Hash(vSend.begin() + nMessageStart, vSend.end());
 403         uint32_t nChecksum = 0;
 404         memcpy(&nChecksum, &hash, sizeof(nChecksum));
 405         assert(nMessageStart - nHeaderStart >= CMessageHeader::CHECKSUM_OFFSET + sizeof(nChecksum));
 406         memcpy((char*)&vSend[nHeaderStart] + CMessageHeader::CHECKSUM_OFFSET, &nChecksum, sizeof(nChecksum));
 407
 408         if (fDebug) {
 409             printf("(%d bytes)\n", nSize);
 410         }
 411
 412         nHeaderStart = -1;
 413         nMessageStart = -1;
 414         LEAVE_CRITICAL_SECTION(cs_vSend);
 415     }
 416
 417     void EndMessageAbortIfEmpty()
 418     {
 419         if (nHeaderStart < 0)
 420             return;
 421         int nSize = (int) vSend.size() - nMessageStart;
 422         if (nSize > 0)
 423             EndMessage();
 424         else
 425             AbortMessage();
 426     }
 427
 428
 429
 430     void PushVersion();
 431
 432
 433     void PushMessage(const char* pszCommand)
 434     {
 435         try
 436         {
 437             BeginMessage(pszCommand);
 438             EndMessage();
 439         }
 440         catch (...)
 441         {
 442             AbortMessage();
 443             throw;
 444         }
 445     }
 446
 447     template<typename T1>
 448     void PushMessage(const char* pszCommand, const T1& a1)
 449     {
 450         try
 451         {
 452             BeginMessage(pszCommand);
 453             vSend << a1;
 454             EndMessage();
 455         }
 456         catch (...)
 457         {
 458             AbortMessage();
 459             throw;
 460         }
 461     }
 462
 463     template<typename T1, typename T2>
 464     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2)
 465     {
 466         try
 467         {
 468             BeginMessage(pszCommand);
 469             vSend << a1 << a2;
 470             EndMessage();
 471         }
 472         catch (...)
 473         {
 474             AbortMessage();
 475             throw;
 476         }
 477     }
 478
 479     template<typename T1, typename T2, typename T3>
 480     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3)
 481     {
 482         try
 483         {
 484             BeginMessage(pszCommand);
 485             vSend << a1 << a2 << a3;
 486             EndMessage();
 487         }
 488         catch (...)
 489         {
 490             AbortMessage();
 491             throw;
 492         }
 493     }
 494
 495     template<typename T1, typename T2, typename T3, typename T4>
 496     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4)
 497     {
 498         try
 499         {
 500             BeginMessage(pszCommand);
 501             vSend << a1 << a2 << a3 << a4;
 502             EndMessage();
 503         }
 504         catch (...)
 505         {
 506             AbortMessage();
 507             throw;
 508         }
 509     }
 510
 511     template<typename T1, typename T2, typename T3, typename T4, typename T5>
 512     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)
 513     {
 514         try
 515         {
 516             BeginMessage(pszCommand);
 517             vSend << a1 << a2 << a3 << a4 << a5;
 518             EndMessage();
 519         }
 520         catch (...)
 521         {
 522             AbortMessage();
 523             throw;
 524         }
 525     }
 526
 527     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 528     void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6)
 529     {
 530         try
 531         {
 532             BeginMessage(pszCommand);
 533             vSend << a1 << a2 << a3 << a4 << a5 << a6;
 534             EndMessage();
 535         }
 536         catch (...)
 537         {
 538             AbortMessage();
 539             throw;
 540         }
 541     }
 542
 543     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 544     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)
 545     {
 546         try
 547         {
 548             BeginMessage(pszCommand);
 549             vSend << a1 << a2 << a3 << a4 << a5 << a6 << a7;
 550             EndMessage();
 551         }
 552         catch (...)
 553         {
 554             AbortMessage();
 555             throw;
 556         }
 557     }
 558
 559     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 560     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)
 561     {
 562         try
 563         {
 564             BeginMessage(pszCommand);
 565             vSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8;
 566             EndMessage();
 567         }
 568         catch (...)
 569         {
 570             AbortMessage();
 571             throw;
 572         }
 573     }
 574
 575     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 576     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)
 577     {
 578         try
 579         {
 580             BeginMessage(pszCommand);
 581             vSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9;
 582             EndMessage();
 583         }
 584         catch (...)
 585         {
 586             AbortMessage();
 587             throw;
 588         }
 589     }
 590
 591
 592     void PushRequest(const char* pszCommand,
 593                      void (*fn)(void*, CDataStream&), void* param1)
 594     {
 595         uint256 hashReply;
 596         RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
 597
 598         {
 599             LOCK(cs_mapRequests);
 600             mapRequests[hashReply] = CRequestTracker(fn, param1);
 601         }
 602
 603         PushMessage(pszCommand, hashReply);
 604     }
 605
 606     template<typename T1>
 607     void PushRequest(const char* pszCommand, const T1& a1,
 608                      void (*fn)(void*, CDataStream&), void* param1)
 609     {
 610         uint256 hashReply;
 611         RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
 612
 613         {
 614             LOCK(cs_mapRequests);
 615             mapRequests[hashReply] = CRequestTracker(fn, param1);
 616         }
 617
 618         PushMessage(pszCommand, hashReply, a1);
 619     }
 620
 621     template<typename T1, typename T2>
 622     void PushRequest(const char* pszCommand, const T1& a1, const T2& a2,
 623                      void (*fn)(void*, CDataStream&), void* param1)
 624     {
 625         uint256 hashReply;
 626         RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
 627
 628         {
 629             LOCK(cs_mapRequests);
 630             mapRequests[hashReply] = CRequestTracker(fn, param1);
 631         }
 632
 633         PushMessage(pszCommand, hashReply, a1, a2);
 634     }
 635
 636
 637
 638     void PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd);
 639     bool IsSubscribed(unsigned int nChannel);
 640     void Subscribe(unsigned int nChannel, unsigned int nHops=0);
 641     void CancelSubscribe(unsigned int nChannel);
 642     void CloseSocketDisconnect();
 643     void Cleanup();
 644
 645
 646     // Denial-of-service detection/prevention
 647     // The idea is to detect peers that are behaving
 648     // badly and disconnect/ban them, but do it in a
 649     // one-coding-mistake-won't-shatter-the-entire-network
 650     // way.
 651     // IMPORTANT:  There should be nothing I can give a
 652     // node that it will forward on that will make that
 653     // node's peers drop it. If there is, an attacker
 654     // can isolate a node and/or try to split the network.
 655     // Dropping a node for sending stuff that is invalid
 656     // now but might be valid in a later version is also
 657     // dangerous, because it can cause a network split
 658     // between nodes running old code and nodes running
 659     // new code.
 660     static void ClearBanned(); // needed for unit testing
 661     static bool IsBanned(CNetAddr ip);
 662     bool Misbehaving(int howmuch); // 1 == a little, 100 == a lot
 663     void copyStats(CNodeStats &stats);
 664     // Network stats
 665     static void RecordBytesRecv(uint64_t bytes);
 666     static void RecordBytesSent(uint64_t bytes);
 667
 668     static uint64_t GetTotalBytesRecv();
 669     static uint64_t GetTotalBytesSent();
 670 };
 671
 672 inline void RelayInventory(const CInv& inv)
 673 {
 674     // Put on lists to offer to the other nodes
 675     {
 676         LOCK(cs_vNodes);
 677         BOOST_FOREACH(CNode* pnode, vNodes)
 678             pnode->PushInventory(inv);
 679     }
 680 }
 681
 682 class CTransaction;
 683 void RelayTransaction(const CTransaction& tx, const uint256& hash);
 684 void RelayTransaction(const CTransaction& tx, const uint256& hash, const CDataStream& ss);
 685
 686
 687 #endif