src/net.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2011 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "headers.h"
   7 #include "irc.h"
   8 #include "db.h"
   9 #include "net.h"
  10 #include "init.h"
  11 #include "strlcpy.h"
  12
  13 #ifdef WIN32
  14 #include <string.h>
  15 #endif
  16
  17 #ifdef USE_UPNP
  18 #include <miniupnpc/miniwget.h>
  19 #include <miniupnpc/miniupnpc.h>
  20 #include <miniupnpc/upnpcommands.h>
  21 #include <miniupnpc/upnperrors.h>
  22 #endif
  23
  24 using namespace std;
  25 using namespace boost;
  26
  27 static const int MAX_OUTBOUND_CONNECTIONS = 8;
  28
  29 void ThreadMessageHandler2(void* parg);
  30 void ThreadSocketHandler2(void* parg);
  31 void ThreadOpenConnections2(void* parg);
  32 #ifdef USE_UPNP
  33 void ThreadMapPort2(void* parg);
  34 #endif
  35 void ThreadDNSAddressSeed2(void* parg);
  36 bool OpenNetworkConnection(const CAddress& addrConnect);
  37
  38
  39
  40
  41
  42 //
  43 // Global state variables
  44 //
  45 bool fClient = false;
  46 bool fAllowDNS = false;
  47 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
  48 CAddress addrLocalHost(CService("0.0.0.0", 0), nLocalServices);
  49 static CNode* pnodeLocalHost = NULL;
  50 uint64 nLocalHostNonce = 0;
  51 array<int, 10> vnThreadsRunning;
  52 static SOCKET hListenSocket = INVALID_SOCKET;
  53
  54 vector<CNode*> vNodes;
  55 CCriticalSection cs_vNodes;
  56 map<vector<unsigned char>, CAddress> mapAddresses;
  57 CCriticalSection cs_mapAddresses;
  58 map<CInv, CDataStream> mapRelay;
  59 deque<pair<int64, CInv> > vRelayExpiration;
  60 CCriticalSection cs_mapRelay;
  61 map<CInv, int64> mapAlreadyAskedFor;
  62
  63
  64
  65
  66
  67 unsigned short GetListenPort()
  68 {
  69     return (unsigned short)(GetArg("-port", GetDefaultPort()));
  70 }
  71
  72 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
  73 {
  74     // Filter out duplicate requests
  75     if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
  76         return;
  77     pindexLastGetBlocksBegin = pindexBegin;
  78     hashLastGetBlocksEnd = hashEnd;
  79
  80     PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
  81 }
  82
  83
  84
  85
  86
  87 bool GetMyExternalIP2(const CService& addrConnect, const char* pszGet, const char* pszKeyword, CNetAddr& ipRet)
  88 {
  89     SOCKET hSocket;
  90     if (!ConnectSocket(addrConnect, hSocket))
  91         return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
  92
  93     send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
  94
  95     string strLine;
  96     while (RecvLine(hSocket, strLine))
  97     {
  98         if (strLine.empty()) // HTTP response is separated from headers by blank line
  99         {
 100             loop
 101             {
 102                 if (!RecvLine(hSocket, strLine))
 103                 {
 104                     closesocket(hSocket);
 105                     return false;
 106                 }
 107                 if (pszKeyword == NULL)
 108                     break;
 109                 if (strLine.find(pszKeyword) != -1)
 110                 {
 111                     strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
 112                     break;
 113                 }
 114             }
 115             closesocket(hSocket);
 116             if (strLine.find("<") != -1)
 117                 strLine = strLine.substr(0, strLine.find("<"));
 118             strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
 119             while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
 120                 strLine.resize(strLine.size()-1);
 121             CService addr(strLine,0,true);
 122             printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
 123             if (!addr.IsValid() || !addr.IsRoutable())
 124                 return false;
 125             ipRet.SetIP(addr);
 126             return true;
 127         }
 128     }
 129     closesocket(hSocket);
 130     return error("GetMyExternalIP() : connection closed");
 131 }
 132
 133 // We now get our external IP from the IRC server first and only use this as a backup
 134 bool GetMyExternalIP(CNetAddr& ipRet)
 135 {
 136     CAddress addrConnect;
 137     const char* pszGet;
 138     const char* pszKeyword;
 139
 140     if (fUseProxy)
 141         return false;
 142
 143     for (int nLookup = 0; nLookup <= 1; nLookup++)
 144     for (int nHost = 1; nHost <= 2; nHost++)
 145     {
 146         // We should be phasing out our use of sites like these.  If we need
 147         // replacements, we should ask for volunteers to put this simple
 148         // php file on their webserver that prints the client IP:
 149         //  <?php echo $_SERVER["REMOTE_ADDR"]; ?>
 150         if (nHost == 1)
 151         {
 152             addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
 153
 154             if (nLookup == 1)
 155             {
 156                 CService addrIP("checkip.dyndns.org", 80, true);
 157                 if (addrIP.IsValid())
 158                     addrConnect = addrIP;
 159             }
 160
 161             pszGet = "GET / HTTP/1.1\r\n"
 162                      "Host: checkip.dyndns.org\r\n"
 163                      "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
 164                      "Connection: close\r\n"
 165                      "\r\n";
 166
 167             pszKeyword = "Address:";
 168         }
 169         else if (nHost == 2)
 170         {
 171             addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
 172
 173             if (nLookup == 1)
 174             {
 175                 CService addrIP("www.showmyip.com", 80, true);
 176                 if (addrIP.IsValid())
 177                     addrConnect = addrIP;
 178             }
 179
 180             pszGet = "GET /simple/ HTTP/1.1\r\n"
 181                      "Host: www.showmyip.com\r\n"
 182                      "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
 183                      "Connection: close\r\n"
 184                      "\r\n";
 185
 186             pszKeyword = NULL; // Returns just IP address
 187         }
 188
 189         if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
 190             return true;
 191     }
 192
 193     return false;
 194 }
 195
 196 void ThreadGetMyExternalIP(void* parg)
 197 {
 198     // Wait for IRC to get it first
 199     if (!GetBoolArg("-noirc"))
 200     {
 201         for (int i = 0; i < 2 * 60; i++)
 202         {
 203             Sleep(1000);
 204             if (fGotExternalIP || fShutdown)
 205                 return;
 206         }
 207     }
 208
 209     // Fallback in case IRC fails to get it
 210     if (GetMyExternalIP(addrLocalHost))
 211     {
 212         printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
 213         if (addrLocalHost.IsRoutable())
 214         {
 215             // If we already connected to a few before we had our IP, go back and addr them.
 216             // setAddrKnown automatically filters any duplicate sends.
 217             CAddress addr(addrLocalHost);
 218             addr.nTime = GetAdjustedTime();
 219             CRITICAL_BLOCK(cs_vNodes)
 220                 BOOST_FOREACH(CNode* pnode, vNodes)
 221                     pnode->PushAddress(addr);
 222         }
 223     }
 224 }
 225
 226
 227
 228
 229
 230 bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
 231 {
 232     if (!addr.IsRoutable())
 233         return false;
 234     if ((CService)addr == (CService)addrLocalHost)
 235         return false;
 236     addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
 237     bool fUpdated = false;
 238     bool fNew = false;
 239     CAddress addrFound = addr;
 240
 241     CRITICAL_BLOCK(cs_mapAddresses)
 242     {
 243         map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
 244         if (it == mapAddresses.end())
 245         {
 246             // New address
 247             printf("AddAddress(%s)\n", addr.ToString().c_str());
 248             mapAddresses.insert(make_pair(addr.GetKey(), addr));
 249             fUpdated = true;
 250             fNew = true;
 251         }
 252         else
 253         {
 254             addrFound = (*it).second;
 255             if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
 256             {
 257                 // Services have been added
 258                 addrFound.nServices |= addr.nServices;
 259                 fUpdated = true;
 260             }
 261             bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
 262             int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
 263             if (addrFound.nTime < addr.nTime - nUpdateInterval)
 264             {
 265                 // Periodically update most recently seen time
 266                 addrFound.nTime = addr.nTime;
 267                 fUpdated = true;
 268             }
 269         }
 270     }
 271     // There is a nasty deadlock bug if this is done inside the cs_mapAddresses
 272     // CRITICAL_BLOCK:
 273     // Thread 1:  begin db transaction (locks inside-db-mutex)
 274     //            then AddAddress (locks cs_mapAddresses)
 275     // Thread 2:  AddAddress (locks cs_mapAddresses)
 276     //             ... then db operation hangs waiting for inside-db-mutex
 277     if (fUpdated)
 278     {
 279         if (pAddrDB)
 280             pAddrDB->WriteAddress(addrFound);
 281         else
 282             CAddrDB().WriteAddress(addrFound);
 283     }
 284     return fNew;
 285 }
 286
 287 void AddressCurrentlyConnected(const CService& addr)
 288 {
 289     CAddress *paddrFound = NULL;
 290
 291     CRITICAL_BLOCK(cs_mapAddresses)
 292     {
 293         // Only if it's been published already
 294         map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
 295         if (it != mapAddresses.end())
 296             paddrFound = &(*it).second;
 297     }
 298
 299     if (paddrFound)
 300     {
 301         int64 nUpdateInterval = 20 * 60;
 302         if (paddrFound->nTime < GetAdjustedTime() - nUpdateInterval)
 303         {
 304             // Periodically update most recently seen time
 305             paddrFound->nTime = GetAdjustedTime();
 306             CAddrDB addrdb;
 307             addrdb.WriteAddress(*paddrFound);
 308         }
 309     }
 310 }
 311
 312
 313
 314
 315
 316 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
 317 {
 318     // If the dialog might get closed before the reply comes back,
 319     // call this in the destructor so it doesn't get called after it's deleted.
 320     CRITICAL_BLOCK(cs_vNodes)
 321     {
 322         BOOST_FOREACH(CNode* pnode, vNodes)
 323         {
 324             CRITICAL_BLOCK(pnode->cs_mapRequests)
 325             {
 326                 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
 327                 {
 328                     CRequestTracker& tracker = (*mi).second;
 329                     if (tracker.fn == fn && tracker.param1 == param1)
 330                         pnode->mapRequests.erase(mi++);
 331                     else
 332                         mi++;
 333                 }
 334             }
 335         }
 336     }
 337 }
 338
 339
 340
 341
 342
 343
 344
 345 //
 346 // Subscription methods for the broadcast and subscription system.
 347 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
 348 //
 349 // The subscription system uses a meet-in-the-middle strategy.
 350 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
 351 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
 352 //
 353
 354 bool AnySubscribed(unsigned int nChannel)
 355 {
 356     if (pnodeLocalHost->IsSubscribed(nChannel))
 357         return true;
 358     CRITICAL_BLOCK(cs_vNodes)
 359         BOOST_FOREACH(CNode* pnode, vNodes)
 360             if (pnode->IsSubscribed(nChannel))
 361                 return true;
 362     return false;
 363 }
 364
 365 bool CNode::IsSubscribed(unsigned int nChannel)
 366 {
 367     if (nChannel >= vfSubscribe.size())
 368         return false;
 369     return vfSubscribe[nChannel];
 370 }
 371
 372 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
 373 {
 374     if (nChannel >= vfSubscribe.size())
 375         return;
 376
 377     if (!AnySubscribed(nChannel))
 378     {
 379         // Relay subscribe
 380         CRITICAL_BLOCK(cs_vNodes)
 381             BOOST_FOREACH(CNode* pnode, vNodes)
 382                 if (pnode != this)
 383                     pnode->PushMessage("subscribe", nChannel, nHops);
 384     }
 385
 386     vfSubscribe[nChannel] = true;
 387 }
 388
 389 void CNode::CancelSubscribe(unsigned int nChannel)
 390 {
 391     if (nChannel >= vfSubscribe.size())
 392         return;
 393
 394     // Prevent from relaying cancel if wasn't subscribed
 395     if (!vfSubscribe[nChannel])
 396         return;
 397     vfSubscribe[nChannel] = false;
 398
 399     if (!AnySubscribed(nChannel))
 400     {
 401         // Relay subscription cancel
 402         CRITICAL_BLOCK(cs_vNodes)
 403             BOOST_FOREACH(CNode* pnode, vNodes)
 404                 if (pnode != this)
 405                     pnode->PushMessage("sub-cancel", nChannel);
 406     }
 407 }
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417 CNode* FindNode(const CNetAddr& ip)
 418 {
 419     CRITICAL_BLOCK(cs_vNodes)
 420     {
 421         BOOST_FOREACH(CNode* pnode, vNodes)
 422             if ((CNetAddr)pnode->addr == ip)
 423                 return (pnode);
 424     }
 425     return NULL;
 426 }
 427
 428 CNode* FindNode(const CService& addr)
 429 {
 430     CRITICAL_BLOCK(cs_vNodes)
 431     {
 432         BOOST_FOREACH(CNode* pnode, vNodes)
 433             if ((CService)pnode->addr == addr)
 434                 return (pnode);
 435     }
 436     return NULL;
 437 }
 438
 439 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
 440 {
 441     if ((CNetAddr)addrConnect == (CNetAddr)addrLocalHost)
 442         return NULL;
 443
 444     // Look for an existing connection
 445     CNode* pnode = FindNode((CService)addrConnect);
 446     if (pnode)
 447     {
 448         if (nTimeout != 0)
 449             pnode->AddRef(nTimeout);
 450         else
 451             pnode->AddRef();
 452         return pnode;
 453     }
 454
 455     /// debug print
 456     printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
 457         addrConnect.ToString().c_str(),
 458         (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
 459         (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
 460
 461     CRITICAL_BLOCK(cs_mapAddresses)
 462         mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
 463
 464     // Connect
 465     SOCKET hSocket;
 466     if (ConnectSocket(addrConnect, hSocket))
 467     {
 468         /// debug print
 469         printf("connected %s\n", addrConnect.ToString().c_str());
 470
 471         // Set to nonblocking
 472 #ifdef WIN32
 473         u_long nOne = 1;
 474         if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
 475             printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
 476 #else
 477         if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
 478             printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
 479 #endif
 480
 481         // Add node
 482         CNode* pnode = new CNode(hSocket, addrConnect, false);
 483         if (nTimeout != 0)
 484             pnode->AddRef(nTimeout);
 485         else
 486             pnode->AddRef();
 487         CRITICAL_BLOCK(cs_vNodes)
 488             vNodes.push_back(pnode);
 489
 490         pnode->nTimeConnected = GetTime();
 491         return pnode;
 492     }
 493     else
 494     {
 495         return NULL;
 496     }
 497 }
 498
 499 void CNode::CloseSocketDisconnect()
 500 {
 501     fDisconnect = true;
 502     if (hSocket != INVALID_SOCKET)
 503     {
 504         if (fDebug)
 505             printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
 506         printf("disconnecting node %s\n", addr.ToString().c_str());
 507         closesocket(hSocket);
 508         hSocket = INVALID_SOCKET;
 509     }
 510 }
 511
 512 void CNode::Cleanup()
 513 {
 514     // All of a nodes broadcasts and subscriptions are automatically torn down
 515     // when it goes down, so a node has to stay up to keep its broadcast going.
 516
 517     // Cancel subscriptions
 518     for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
 519         if (vfSubscribe[nChannel])
 520             CancelSubscribe(nChannel);
 521 }
 522
 523
 524 void CNode::PushVersion()
 525 {
 526     /// when NTP implemented, change to just nTime = GetAdjustedTime()
 527     int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
 528     CAddress addrYou = (fUseProxy ? CAddress("0.0.0.0") : addr);
 529     CAddress addrMe = (fUseProxy ? CAddress("0.0.0.0") : addrLocalHost);
 530     RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
 531     PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
 532                 nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight);
 533 }
 534
 535
 536
 537
 538
 539 std::map<CNetAddr, int64> CNode::setBanned;
 540 CCriticalSection CNode::cs_setBanned;
 541
 542 void CNode::ClearBanned()
 543 {
 544     setBanned.clear();
 545 }
 546
 547 bool CNode::IsBanned(CNetAddr ip)
 548 {
 549     bool fResult = false;
 550     CRITICAL_BLOCK(cs_setBanned)
 551     {
 552         std::map<CNetAddr, int64>::iterator i = setBanned.find(ip);
 553         if (i != setBanned.end())
 554         {
 555             int64 t = (*i).second;
 556             if (GetTime() < t)
 557                 fResult = true;
 558         }
 559     }
 560     return fResult;
 561 }
 562
 563 bool CNode::Misbehaving(int howmuch)
 564 {
 565     if (addr.IsLocal())
 566     {
 567         printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
 568         return false;
 569     }
 570
 571     nMisbehavior += howmuch;
 572     if (nMisbehavior >= GetArg("-banscore", 100))
 573     {
 574         int64 banTime = GetTime()+GetArg("-bantime", 60*60*24);  // Default 24-hour ban
 575         CRITICAL_BLOCK(cs_setBanned)
 576             if (setBanned[addr] < banTime)
 577                 setBanned[addr] = banTime;
 578         CloseSocketDisconnect();
 579         printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
 580         return true;
 581     }
 582     return false;
 583 }
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596 void ThreadSocketHandler(void* parg)
 597 {
 598     IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
 599     try
 600     {
 601         vnThreadsRunning[0]++;
 602         ThreadSocketHandler2(parg);
 603         vnThreadsRunning[0]--;
 604     }
 605     catch (std::exception& e) {
 606         vnThreadsRunning[0]--;
 607         PrintException(&e, "ThreadSocketHandler()");
 608     } catch (...) {
 609         vnThreadsRunning[0]--;
 610         throw; // support pthread_cancel()
 611     }
 612     printf("ThreadSocketHandler exiting\n");
 613 }
 614
 615 void ThreadSocketHandler2(void* parg)
 616 {
 617     printf("ThreadSocketHandler started\n");
 618     list<CNode*> vNodesDisconnected;
 619     int nPrevNodeCount = 0;
 620
 621     loop
 622     {
 623         //
 624         // Disconnect nodes
 625         //
 626         CRITICAL_BLOCK(cs_vNodes)
 627         {
 628             // Disconnect unused nodes
 629             vector<CNode*> vNodesCopy = vNodes;
 630             BOOST_FOREACH(CNode* pnode, vNodesCopy)
 631             {
 632                 if (pnode->fDisconnect ||
 633                     (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
 634                 {
 635                     // remove from vNodes
 636                     vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
 637
 638                     // close socket and cleanup
 639                     pnode->CloseSocketDisconnect();
 640                     pnode->Cleanup();
 641
 642                     // hold in disconnected pool until all refs are released
 643                     pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
 644                     if (pnode->fNetworkNode || pnode->fInbound)
 645                         pnode->Release();
 646                     vNodesDisconnected.push_back(pnode);
 647                 }
 648             }
 649
 650             // Delete disconnected nodes
 651             list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
 652             BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
 653             {
 654                 // wait until threads are done using it
 655                 if (pnode->GetRefCount() <= 0)
 656                 {
 657                     bool fDelete = false;
 658                     TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 659                      TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
 660                       TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
 661                        TRY_CRITICAL_BLOCK(pnode->cs_inventory)
 662                         fDelete = true;
 663                     if (fDelete)
 664                     {
 665                         vNodesDisconnected.remove(pnode);
 666                         delete pnode;
 667                     }
 668                 }
 669             }
 670         }
 671         if (vNodes.size() != nPrevNodeCount)
 672         {
 673             nPrevNodeCount = vNodes.size();
 674             MainFrameRepaint();
 675         }
 676
 677
 678         //
 679         // Find which sockets have data to receive
 680         //
 681         struct timeval timeout;
 682         timeout.tv_sec  = 0;
 683         timeout.tv_usec = 50000; // frequency to poll pnode->vSend
 684
 685         fd_set fdsetRecv;
 686         fd_set fdsetSend;
 687         fd_set fdsetError;
 688         FD_ZERO(&fdsetRecv);
 689         FD_ZERO(&fdsetSend);
 690         FD_ZERO(&fdsetError);
 691         SOCKET hSocketMax = 0;
 692
 693         if(hListenSocket != INVALID_SOCKET)
 694             FD_SET(hListenSocket, &fdsetRecv);
 695         hSocketMax = max(hSocketMax, hListenSocket);
 696         CRITICAL_BLOCK(cs_vNodes)
 697         {
 698             BOOST_FOREACH(CNode* pnode, vNodes)
 699             {
 700                 if (pnode->hSocket == INVALID_SOCKET)
 701                     continue;
 702                 FD_SET(pnode->hSocket, &fdsetRecv);
 703                 FD_SET(pnode->hSocket, &fdsetError);
 704                 hSocketMax = max(hSocketMax, pnode->hSocket);
 705                 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 706                     if (!pnode->vSend.empty())
 707                         FD_SET(pnode->hSocket, &fdsetSend);
 708             }
 709         }
 710
 711         vnThreadsRunning[0]--;
 712         int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
 713         vnThreadsRunning[0]++;
 714         if (fShutdown)
 715             return;
 716         if (nSelect == SOCKET_ERROR)
 717         {
 718             int nErr = WSAGetLastError();
 719             if (hSocketMax > -1)
 720             {
 721                 printf("socket select error %d\n", nErr);
 722                 for (int i = 0; i <= hSocketMax; i++)
 723                     FD_SET(i, &fdsetRecv);
 724             }
 725             FD_ZERO(&fdsetSend);
 726             FD_ZERO(&fdsetError);
 727             Sleep(timeout.tv_usec/1000);
 728         }
 729
 730
 731         //
 732         // Accept new connections
 733         //
 734         if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
 735         {
 736             struct sockaddr_in sockaddr;
 737             socklen_t len = sizeof(sockaddr);
 738             SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
 739             CAddress addr(sockaddr);
 740             int nInbound = 0;
 741
 742             CRITICAL_BLOCK(cs_vNodes)
 743                 BOOST_FOREACH(CNode* pnode, vNodes)
 744                 if (pnode->fInbound)
 745                     nInbound++;
 746             if (hSocket == INVALID_SOCKET)
 747             {
 748                 if (WSAGetLastError() != WSAEWOULDBLOCK)
 749                     printf("socket error accept failed: %d\n", WSAGetLastError());
 750             }
 751             else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
 752             {
 753                 closesocket(hSocket);
 754             }
 755             else if (CNode::IsBanned(addr))
 756             {
 757                 printf("connetion from %s dropped (banned)\n", addr.ToString().c_str());
 758                 closesocket(hSocket);
 759             }
 760             else
 761             {
 762                 printf("accepted connection %s\n", addr.ToString().c_str());
 763                 CNode* pnode = new CNode(hSocket, addr, true);
 764                 pnode->AddRef();
 765                 CRITICAL_BLOCK(cs_vNodes)
 766                     vNodes.push_back(pnode);
 767             }
 768         }
 769
 770
 771         //
 772         // Service each socket
 773         //
 774         vector<CNode*> vNodesCopy;
 775         CRITICAL_BLOCK(cs_vNodes)
 776         {
 777             vNodesCopy = vNodes;
 778             BOOST_FOREACH(CNode* pnode, vNodesCopy)
 779                 pnode->AddRef();
 780         }
 781         BOOST_FOREACH(CNode* pnode, vNodesCopy)
 782         {
 783             if (fShutdown)
 784                 return;
 785
 786             //
 787             // Receive
 788             //
 789             if (pnode->hSocket == INVALID_SOCKET)
 790                 continue;
 791             if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
 792             {
 793                 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
 794                 {
 795                     CDataStream& vRecv = pnode->vRecv;
 796                     unsigned int nPos = vRecv.size();
 797
 798                     if (nPos > ReceiveBufferSize()) {
 799                         if (!pnode->fDisconnect)
 800                             printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
 801                         pnode->CloseSocketDisconnect();
 802                     }
 803                     else {
 804                         // typical socket buffer is 8K-64K
 805                         char pchBuf[0x10000];
 806                         int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
 807                         if (nBytes > 0)
 808                         {
 809                             vRecv.resize(nPos + nBytes);
 810                             memcpy(&vRecv[nPos], pchBuf, nBytes);
 811                             pnode->nLastRecv = GetTime();
 812                         }
 813                         else if (nBytes == 0)
 814                         {
 815                             // socket closed gracefully
 816                             if (!pnode->fDisconnect)
 817                                 printf("socket closed\n");
 818                             pnode->CloseSocketDisconnect();
 819                         }
 820                         else if (nBytes < 0)
 821                         {
 822                             // error
 823                             int nErr = WSAGetLastError();
 824                             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
 825                             {
 826                                 if (!pnode->fDisconnect)
 827                                     printf("socket recv error %d\n", nErr);
 828                                 pnode->CloseSocketDisconnect();
 829                             }
 830                         }
 831                     }
 832                 }
 833             }
 834
 835             //
 836             // Send
 837             //
 838             if (pnode->hSocket == INVALID_SOCKET)
 839                 continue;
 840             if (FD_ISSET(pnode->hSocket, &fdsetSend))
 841             {
 842                 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 843                 {
 844                     CDataStream& vSend = pnode->vSend;
 845                     if (!vSend.empty())
 846                     {
 847                         int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
 848                         if (nBytes > 0)
 849                         {
 850                             vSend.erase(vSend.begin(), vSend.begin() + nBytes);
 851                             pnode->nLastSend = GetTime();
 852                         }
 853                         else if (nBytes < 0)
 854                         {
 855                             // error
 856                             int nErr = WSAGetLastError();
 857                             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
 858                             {
 859                                 printf("socket send error %d\n", nErr);
 860                                 pnode->CloseSocketDisconnect();
 861                             }
 862                         }
 863                         if (vSend.size() > SendBufferSize()) {
 864                             if (!pnode->fDisconnect)
 865                                 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
 866                             pnode->CloseSocketDisconnect();
 867                         }
 868                     }
 869                 }
 870             }
 871
 872             //
 873             // Inactivity checking
 874             //
 875             if (pnode->vSend.empty())
 876                 pnode->nLastSendEmpty = GetTime();
 877             if (GetTime() - pnode->nTimeConnected > 60)
 878             {
 879                 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
 880                 {
 881                     printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
 882                     pnode->fDisconnect = true;
 883                 }
 884                 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
 885                 {
 886                     printf("socket not sending\n");
 887                     pnode->fDisconnect = true;
 888                 }
 889                 else if (GetTime() - pnode->nLastRecv > 90*60)
 890                 {
 891                     printf("socket inactivity timeout\n");
 892                     pnode->fDisconnect = true;
 893                 }
 894             }
 895         }
 896         CRITICAL_BLOCK(cs_vNodes)
 897         {
 898             BOOST_FOREACH(CNode* pnode, vNodesCopy)
 899                 pnode->Release();
 900         }
 901
 902         Sleep(10);
 903     }
 904 }
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914 #ifdef USE_UPNP
 915 void ThreadMapPort(void* parg)
 916 {
 917     IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
 918     try
 919     {
 920         vnThreadsRunning[5]++;
 921         ThreadMapPort2(parg);
 922         vnThreadsRunning[5]--;
 923     }
 924     catch (std::exception& e) {
 925         vnThreadsRunning[5]--;
 926         PrintException(&e, "ThreadMapPort()");
 927     } catch (...) {
 928         vnThreadsRunning[5]--;
 929         PrintException(NULL, "ThreadMapPort()");
 930     }
 931     printf("ThreadMapPort exiting\n");
 932 }
 933
 934 void ThreadMapPort2(void* parg)
 935 {
 936     printf("ThreadMapPort started\n");
 937
 938     char port[6];
 939     sprintf(port, "%d", GetListenPort());
 940
 941     const char * multicastif = 0;
 942     const char * minissdpdpath = 0;
 943     struct UPNPDev * devlist = 0;
 944     char lanaddr[64];
 945
 946 #ifndef UPNPDISCOVER_SUCCESS
 947     /* miniupnpc 1.5 */
 948     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
 949 #else
 950     /* miniupnpc 1.6 */
 951     int error = 0;
 952     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
 953 #endif
 954
 955     struct UPNPUrls urls;
 956     struct IGDdatas data;
 957     int r;
 958
 959     r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
 960     if (r == 1)
 961     {
 962         string strDesc = "Bitcoin " + FormatFullVersion();
 963 #ifndef UPNPDISCOVER_SUCCESS
 964     /* miniupnpc 1.5 */
 965         r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
 966                             port, port, lanaddr, strDesc.c_str(), "TCP", 0);
 967 #else
 968     /* miniupnpc 1.6 */
 969         r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
 970                             port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
 971 #endif
 972
 973         if(r!=UPNPCOMMAND_SUCCESS)
 974             printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
 975                 port, port, lanaddr, r, strupnperror(r));
 976         else
 977             printf("UPnP Port Mapping successful.\n");
 978         loop {
 979             if (fShutdown || !fUseUPnP)
 980             {
 981                 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
 982                 printf("UPNP_DeletePortMapping() returned : %d\n", r);
 983                 freeUPNPDevlist(devlist); devlist = 0;
 984                 FreeUPNPUrls(&urls);
 985                 return;
 986             }
 987             Sleep(2000);
 988         }
 989     } else {
 990         printf("No valid UPnP IGDs found\n");
 991         freeUPNPDevlist(devlist); devlist = 0;
 992         if (r != 0)
 993             FreeUPNPUrls(&urls);
 994         loop {
 995             if (fShutdown || !fUseUPnP)
 996                 return;
 997             Sleep(2000);
 998         }
 999     }
1000 }
1001
1002 void MapPort(bool fMapPort)
1003 {
1004     if (fUseUPnP != fMapPort)
1005     {
1006         fUseUPnP = fMapPort;
1007         WriteSetting("fUseUPnP", fUseUPnP);
1008     }
1009     if (fUseUPnP && vnThreadsRunning[5] < 1)
1010     {
1011         if (!CreateThread(ThreadMapPort, NULL))
1012             printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1013     }
1014 }
1015 #else
1016 void MapPort(bool /* unused fMapPort */)
1017 {
1018     // Intentionally left blank.
1019 }
1020 #endif
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031 static const char *strDNSSeed[] = {
1032     "bitseed.xf2.org",
1033     "dnsseed.bluematt.me",
1034     "seed.bitcoin.sipa.be",
1035     "dnsseed.bitcoin.dashjr.org",
1036 };
1037
1038 void ThreadDNSAddressSeed(void* parg)
1039 {
1040     IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1041     try
1042     {
1043         vnThreadsRunning[6]++;
1044         ThreadDNSAddressSeed2(parg);
1045         vnThreadsRunning[6]--;
1046     }
1047     catch (std::exception& e) {
1048         vnThreadsRunning[6]--;
1049         PrintException(&e, "ThreadDNSAddressSeed()");
1050     } catch (...) {
1051         vnThreadsRunning[6]--;
1052         throw; // support pthread_cancel()
1053     }
1054     printf("ThreadDNSAddressSeed exiting\n");
1055 }
1056
1057 void ThreadDNSAddressSeed2(void* parg)
1058 {
1059     printf("ThreadDNSAddressSeed started\n");
1060     int found = 0;
1061
1062     if (!fTestNet)
1063     {
1064         printf("Loading addresses from DNS seeds (could take a while)\n");
1065
1066         for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1067             vector<CNetAddr> vaddr;
1068             if (LookupHost(strDNSSeed[seed_idx], vaddr))
1069             {
1070                 CAddrDB addrDB;
1071                 addrDB.TxnBegin();
1072                 BOOST_FOREACH (CNetAddr& ip, vaddr)
1073                 {
1074                     if (ip.IsRoutable())
1075                     {
1076                         CAddress addr(CService(ip, GetDefaultPort()), NODE_NETWORK);
1077                         addr.nTime = 0;
1078                         AddAddress(addr, 0, &addrDB);
1079                         found++;
1080                     }
1081                 }
1082                 addrDB.TxnCommit();  // Save addresses (it's ok if this fails)
1083             }
1084         }
1085     }
1086
1087     printf("%d addresses found from DNS seeds\n", found);
1088 }
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101 unsigned int pnSeed[] =
1102 {
1103     0x6884ac63, 0x3ffecead, 0x2919b953, 0x0942fe50, 0x7a1d922e, 0xcdd6734a, 0x953a5bb6, 0x2c46922e,
1104     0xe2a5f143, 0xaa39103a, 0xa06afa5c, 0x135ffd59, 0xe8e82863, 0xf61ef029, 0xf75f042e, 0x2b363532,
1105     0x29b2df42, 0x16b1f64e, 0xd46e281b, 0x5280bf58, 0x60372229, 0x1be58e4f, 0xa8496f45, 0x1fb1a057,
1106     0x756b3844, 0x3bb79445, 0x0b375518, 0xcccb0102, 0xb682bf2e, 0x46431c02, 0x3a81073a, 0xa3771f1f,
1107     0x213a121f, 0x85dc2c1b, 0x56b4323b, 0xb34e8945, 0x3c40b33d, 0xfa276418, 0x1f818d29, 0xebe1e344,
1108     0xf6160a18, 0xf4fa384a, 0x34b09558, 0xb882b543, 0xe3ce2253, 0x6abf56d8, 0xe91b1155, 0x688ee6ad,
1109     0x2efc6058, 0x4792cd47, 0x0c32f757, 0x4c813a46, 0x8c93644a, 0x37507444, 0x813ad218, 0xdac06d4a,
1110     0xe4c63e4b, 0x21a1ea3c, 0x8d88556f, 0x30e9173a, 0x041f681b, 0xdc77ba50, 0xc0072753, 0xceddd44f,
1111     0x052d1743, 0xe3c77a4a, 0x13981c3a, 0x5685d918, 0x3c0e4e70, 0x3e56fb54, 0xb676ae0c, 0xac93c859,
1112     0x22279f43, 0x975a4542, 0xe527f071, 0xea162f2e, 0x3c65a32e, 0x5be5713b, 0x961ec418, 0xb202922e,
1113     0x5ef7be50, 0xce49f53e, 0x05803b47, 0x8463b055, 0x78576153, 0x3ec2ae3a, 0x4bbd7118, 0xafcee043,
1114     0x56a3e8ba, 0x6174de4d, 0x8d01ba4b, 0xc9af564e, 0xdbc9c547, 0xa627474d, 0xdada9244, 0xd3b3083a,
1115     0x523e071f, 0xd6b96f18, 0xbd527c46, 0xdf2bbb4d, 0xd37b4a4b, 0x3a6a2158, 0xc064b055, 0x18a8e055,
1116     0xec4dae3b, 0x0540416c, 0x475b4fbe, 0x064803b2, 0x48e9f062, 0x2898524b, 0xd315ff43, 0xf786d247,
1117     0xc7ea2f3e, 0xc087f043, 0xc163354b, 0x8250284d, 0xed300029, 0xbf36e05c, 0x8eb3ae4c, 0xe7aa623e,
1118     0x7ced0274, 0xdd362c1b, 0x362b995a, 0xca26b629, 0x3fc41618, 0xb97b364e, 0xa05b8729, 0x0f5e3c43,
1119     0xdf942618, 0x6aeb9b5b, 0xbf04762e, 0xfaaeb118, 0x87579958, 0x76520044, 0xc2660c5b, 0x628b201b,
1120     0xf193932e, 0x1c0ad045, 0xff908346, 0x8da9d4da, 0xed201c1f, 0xa47a2b1b, 0x330007d4, 0x8ba1ed47,
1121     0xb2f02d44, 0x7db62c1b, 0x781c454b, 0xc0300029, 0xb7062a45, 0x88b52e3a, 0x78dd6b63, 0x1cb9b718,
1122     0x5d358e47, 0x59912c3b, 0x79607544, 0x5197f759, 0xc023be48, 0xd1013743, 0x0f354057, 0x8e3aac3b,
1123     0x4114693e, 0x22316318, 0xe27dda50, 0x878eac3b, 0x4948a21f, 0x5db7f24c, 0x8ccb6157, 0x26a5de18,
1124     0x0a11bd43, 0x27bb1e41, 0x60a7a951, 0x3e16b35e, 0x07888b53, 0x5648a853, 0x0149fe50, 0xd070a34f,
1125     0x6454c96d, 0xd6e54758, 0xa96dc152, 0x65447861, 0xf6bdf95e, 0x10400202, 0x2c29d483, 0x18174732,
1126     0x1d840618, 0x12e61818, 0x089d3f3c, 0x917e931f, 0xd1b0c90e, 0x25bd3c42, 0xeb05775b, 0x7d550c59,
1127     0x6cfacb01, 0xe4224444, 0xa41dd943, 0x0f5aa643, 0x5e33731b, 0x81036d50, 0x6f46a0d1, 0x7731be43,
1128     0x14840e18, 0xf1e8d059, 0x661d2b1f, 0x40a3201b, 0x9407b843, 0xedf0254d, 0x7bd1a5bc, 0x073dbe51,
1129     0xe864a97b, 0x2efd947b, 0xb9ca0e45, 0x4e2113ad, 0xcc305731, 0xd39ca63c, 0x733df918, 0xda172b1f,
1130     0xaa03b34d, 0x7230fd4d, 0xf1ce6e3a, 0x2e9fab43, 0xa4010750, 0xa928bd18, 0x6809be42, 0xb19de348,
1131     0xff956270, 0x0d795f51, 0xd2dec247, 0x6df5774b, 0xbac11f79, 0xdfb05c75, 0x887683d8, 0xa1e83632,
1132     0x2c0f7671, 0x28bcb65d, 0xac2a7545, 0x3eebfc60, 0x304ad7c4, 0xa215a462, 0xc86f0f58, 0xcfb92ebe,
1133     0x5e23ed82, 0xf506184b, 0xec0f19b7, 0x060c59ad, 0x86ee3174, 0x85380774, 0xa199a562, 0x02b507ae,
1134     0x33eb2163, 0xf2112b1f, 0xb702ba50, 0x131b9618, 0x90ccd04a, 0x08f3273b, 0xecb61718, 0x64b8b44d,
1135     0x182bf4dc, 0xc7b68286, 0x6e318d5f, 0xfdb03654, 0xb3272e54, 0xe014ad4b, 0x274e4a31, 0x7806375c,
1136     0xbc34a748, 0x1b5ad94a, 0x6b54d10e, 0x73e2ae6e, 0x5529d483, 0x8455a76d, 0x99c13f47, 0x1d811741,
1137     0xa9782a78, 0x0b00464d, 0x7266ea50, 0x532dab46, 0x33e1413e, 0x780d0c18, 0x0fb0854e, 0x03370155,
1138     0x2693042e, 0xfa3d824a, 0x2bb1681b, 0x37ea2a18, 0x7fb8414b, 0x32e0713b, 0xacf38d3f, 0xa282716f,
1139     0xb1a09d7b, 0xa04b764b, 0x83c94d18, 0x05ee4c6d, 0x0e795f51, 0x46984352, 0xf80fc247, 0x3fccb946,
1140     0xd7ae244b, 0x0a8e0a4c, 0x57b141bc, 0x3647bed1, 0x1431b052, 0x803a8bbb, 0xfc69056b, 0xf5991862,
1141     0x14963b2e, 0xd35d5dda, 0xc6c73574, 0xc8f1405b, 0x0ca4224d, 0xecd36071, 0xa9461754, 0xe7a0ed72,
1142     0x559e8346, 0x1c9beec1, 0xc786ea4a, 0x9561b44d, 0x9788074d, 0x1a69934f, 0x23c5614c, 0x07c79d4b,
1143     0xc7ee52db, 0xc72df351, 0xcb135e44, 0xa0988346, 0xc211fc4c, 0x87dec34b, 0x1381074d, 0x04a65cb7,
1144     0x4409083a, 0x4a407a4c, 0x92b8d37d, 0xacf50b4d, 0xa58aa5bc, 0x448f801f, 0x9c83762e, 0x6fd5734a,
1145     0xfe2d454b, 0x84144c55, 0x05190e4c, 0xb2151448, 0x63867a3e, 0x16099018, 0x9c010d3c, 0x962d8f3d,
1146     0xd51ee453, 0x9d86801f, 0x68e87b47, 0x6bf7bb73, 0x5fc7910e, 0x10d90118, 0x3db04442, 0x729d3e4b,
1147     0xc397d842, 0x57bb15ad, 0x72f31f4e, 0xc9380043, 0x2bb24e18, 0xd9b8ab50, 0xb786801f, 0xf4dc4847,
1148     0x85f4bb51, 0x4435995b, 0x5ba07e40, 0x2c57392e, 0x3628124b, 0x9839b64b, 0x6fe8b24d, 0xaddce847,
1149     0x75260e45, 0x0c572a43, 0xfea21902, 0xb9f9742e, 0x5a70d443, 0x8fc5910e, 0x868d4744, 0x56245e02,
1150     0xd7eb5f02, 0x35c12c1b, 0x4373034b, 0x8786554c, 0xa6facf18, 0x4b11a31f, 0x3570664e, 0x5a64bc42,
1151     0x0b03983f, 0x8f457e4c, 0x0fd874c3, 0xb6cf31b2, 0x2bbc2d4e, 0x146ca5b2, 0x9d00b150, 0x048a4153,
1152     0xca4dcd43, 0xc1607cca, 0x8234cf57, 0x9c7daead, 0x3dc07658, 0xea5c6e4c, 0xf1a0084e, 0x16d2ee53,
1153     0x1b849418, 0xfe913a47, 0x1e988f62, 0x208b644c, 0xc55ee980, 0xbdbce747, 0xf59a384e, 0x0f56091b,
1154     0x7417b745, 0x0c37344e, 0x2c62ab47, 0xf8533a4d, 0x8030084d, 0x76b93c4b, 0xda6ea0ad, 0x3c54f618,
1155     0x63b0de1f, 0x7370d858, 0x1a70bb4c, 0xdda63b2e, 0x60b2ba50, 0x1ba7d048, 0xbe1b2c1b, 0xabea5747,
1156     0x29ad2e4d, 0xe8cd7642, 0x66c80e18, 0x138bf34a, 0xc6145e44, 0x2586794c, 0x07bc5478, 0x0da0b14d,
1157     0x8f95354e, 0x9eb11c62, 0xa1545e46, 0x2e7a2602, 0x408c9c3d, 0x59065d55, 0xf51d1a4c, 0x3bbc6a4e,
1158     0xc71b2a2e, 0xcdaaa545, 0x17d659d0, 0x5202e7ad, 0xf1b68445, 0x93375961, 0xbd88a043, 0x066ad655,
1159     0x890f6318, 0x7b7dca47, 0x99bdd662, 0x3bb4fc53, 0x1231efdc, 0xc0a99444, 0x96bbea47, 0x61ed8748,
1160     0x27dfa73b, 0x8d4d1754, 0x3460042e, 0x551f0c4c, 0x8d0e0718, 0x162ddc53, 0x53231718, 0x1ecd65d0,
1161     0x944d28bc, 0x3b79d058, 0xaff97fbc, 0x4860006c, 0xc101c90e, 0xace41743, 0xa5975d4c, 0x5cc2703e,
1162     0xb55a4450, 0x02d18840, 0xee2765ae, 0xd6012fd5, 0x24c94d7d, 0x8c6eec47, 0x7520ba5d, 0x9e15e460,
1163     0x8510b04c, 0x75ec3847, 0x1dfa6661, 0xe172b3ad, 0x5744c90e, 0x52a0a152, 0x8d6fad18, 0x67b74b6d,
1164     0x93a089b2, 0x0f3ac5d5, 0xe5de1855, 0x43d25747, 0x4bad804a, 0x55b408d8, 0x60a36441, 0xf553e860,
1165     0xdb2fa2c8, 0x03152b32, 0xdd27a7d5, 0x3116a8b8, 0x0a1d708c, 0xeee2f13c, 0x6acf436f, 0xce6eb4ca,
1166     0x101cd3d9, 0x1c48a6b8, 0xe57d6f44, 0x93dcf562,
1167 };
1168
1169
1170
1171 void ThreadOpenConnections(void* parg)
1172 {
1173     IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1174     try
1175     {
1176         vnThreadsRunning[1]++;
1177         ThreadOpenConnections2(parg);
1178         vnThreadsRunning[1]--;
1179     }
1180     catch (std::exception& e) {
1181         vnThreadsRunning[1]--;
1182         PrintException(&e, "ThreadOpenConnections()");
1183     } catch (...) {
1184         vnThreadsRunning[1]--;
1185         PrintException(NULL, "ThreadOpenConnections()");
1186     }
1187     printf("ThreadOpenConnections exiting\n");
1188 }
1189
1190 void ThreadOpenConnections2(void* parg)
1191 {
1192     printf("ThreadOpenConnections started\n");
1193
1194     // Connect to specific addresses
1195     if (mapArgs.count("-connect"))
1196     {
1197         for (int64 nLoop = 0;; nLoop++)
1198         {
1199             BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1200             {
1201                 CAddress addr(strAddr, fAllowDNS);
1202                 if (addr.IsValid())
1203                     OpenNetworkConnection(addr);
1204                 for (int i = 0; i < 10 && i < nLoop; i++)
1205                 {
1206                     Sleep(500);
1207                     if (fShutdown)
1208                         return;
1209                 }
1210             }
1211         }
1212     }
1213
1214     // Connect to manually added nodes first
1215     if (mapArgs.count("-addnode"))
1216     {
1217         BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1218         {
1219             CAddress addr(strAddr, fAllowDNS);
1220             if (addr.IsValid())
1221             {
1222                 OpenNetworkConnection(addr);
1223                 Sleep(500);
1224                 if (fShutdown)
1225                     return;
1226             }
1227         }
1228     }
1229
1230     // Initiate network connections
1231     int64 nStart = GetTime();
1232     loop
1233     {
1234         // Limit outbound connections
1235         vnThreadsRunning[1]--;
1236         Sleep(500);
1237         loop
1238         {
1239             int nOutbound = 0;
1240             CRITICAL_BLOCK(cs_vNodes)
1241                 BOOST_FOREACH(CNode* pnode, vNodes)
1242                     if (!pnode->fInbound)
1243                         nOutbound++;
1244             int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1245             nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1246             if (nOutbound < nMaxOutboundConnections)
1247                 break;
1248             Sleep(2000);
1249             if (fShutdown)
1250                 return;
1251         }
1252         vnThreadsRunning[1]++;
1253         if (fShutdown)
1254             return;
1255
1256         bool fAddSeeds = false;
1257
1258         CRITICAL_BLOCK(cs_mapAddresses)
1259         {
1260             // Add seed nodes if IRC isn't working
1261             bool fTOR = (fUseProxy && addrProxy.GetPort() == 9050);
1262             if (mapAddresses.empty() && (GetTime() - nStart > 60 || fTOR) && !fTestNet)
1263                 fAddSeeds = true;
1264         }
1265
1266         if (fAddSeeds)
1267         {
1268             for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1269             {
1270                 // It'll only connect to one or two seed nodes because once it connects,
1271                 // it'll get a pile of addresses with newer timestamps.
1272                 // Seed nodes are given a random 'last seen time' of between one and two
1273                 // weeks ago.
1274                 const int64 nOneWeek = 7*24*60*60;
1275                 struct in_addr ip;
1276                 memcpy(&ip, &pnSeed[i], sizeof(ip));
1277                 CAddress addr(CService(ip, GetDefaultPort()));
1278                 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1279                 AddAddress(addr);
1280             }
1281         }
1282
1283         //
1284         // Choose an address to connect to based on most recently seen
1285         //
1286         CAddress addrConnect;
1287         int64 nBest = std::numeric_limits<int64>::min();
1288
1289         // Only connect to one address per a.b.?.? range.
1290         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1291         set<vector<unsigned char> > setConnected;
1292         CRITICAL_BLOCK(cs_vNodes)
1293             BOOST_FOREACH(CNode* pnode, vNodes)
1294                 setConnected.insert(pnode->addr.GetGroup());
1295
1296         int64 nANow = GetAdjustedTime();
1297
1298         CRITICAL_BLOCK(cs_mapAddresses)
1299         {
1300             BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1301             {
1302                 const CAddress& addr = item.second;
1303                 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.GetGroup()))
1304                     continue;
1305                 int64 nSinceLastSeen = nANow - addr.nTime;
1306                 int64 nSinceLastTry = nANow - addr.nLastTry;
1307
1308                 // Randomize the order in a deterministic way, putting the standard port first
1309                 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.GetHash()) % (2 * 60 * 60);
1310                 if (addr.GetPort() != GetDefaultPort())
1311                     nRandomizer += 2 * 60 * 60;
1312
1313                 // Last seen  Base retry frequency
1314                 //   <1 hour   10 min
1315                 //    1 hour    1 hour
1316                 //    4 hours   2 hours
1317                 //   24 hours   5 hours
1318                 //   48 hours   7 hours
1319                 //    7 days   13 hours
1320                 //   30 days   27 hours
1321                 //   90 days   46 hours
1322                 //  365 days   93 hours
1323                 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1324
1325                 // Fast reconnect for one hour after last seen
1326                 if (nSinceLastSeen < 60 * 60)
1327                     nDelay = 10 * 60;
1328
1329                 // Limit retry frequency
1330                 if (nSinceLastTry < nDelay)
1331                     continue;
1332
1333                 // If we have IRC, we'll be notified when they first come online,
1334                 // and again every 24 hours by the refresh broadcast.
1335                 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1336                     continue;
1337
1338                 // Only try the old stuff if we don't have enough connections
1339                 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1340                     continue;
1341
1342                 // If multiple addresses are ready, prioritize by time since
1343                 // last seen and time since last tried.
1344                 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1345                 if (nScore > nBest)
1346                 {
1347                     nBest = nScore;
1348                     addrConnect = addr;
1349                 }
1350             }
1351         }
1352
1353         if (addrConnect.IsValid())
1354             OpenNetworkConnection(addrConnect);
1355     }
1356 }
1357
1358 bool OpenNetworkConnection(const CAddress& addrConnect)
1359 {
1360     //
1361     // Initiate outbound network connection
1362     //
1363     if (fShutdown)
1364         return false;
1365     if ((CNetAddr)addrConnect == (CNetAddr)addrLocalHost || !addrConnect.IsIPv4() ||
1366         FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect))
1367         return false;
1368
1369     vnThreadsRunning[1]--;
1370     CNode* pnode = ConnectNode(addrConnect);
1371     vnThreadsRunning[1]++;
1372     if (fShutdown)
1373         return false;
1374     if (!pnode)
1375         return false;
1376     pnode->fNetworkNode = true;
1377
1378     return true;
1379 }
1380
1381
1382
1383
1384
1385
1386
1387
1388 void ThreadMessageHandler(void* parg)
1389 {
1390     IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1391     try
1392     {
1393         vnThreadsRunning[2]++;
1394         ThreadMessageHandler2(parg);
1395         vnThreadsRunning[2]--;
1396     }
1397     catch (std::exception& e) {
1398         vnThreadsRunning[2]--;
1399         PrintException(&e, "ThreadMessageHandler()");
1400     } catch (...) {
1401         vnThreadsRunning[2]--;
1402         PrintException(NULL, "ThreadMessageHandler()");
1403     }
1404     printf("ThreadMessageHandler exiting\n");
1405 }
1406
1407 void ThreadMessageHandler2(void* parg)
1408 {
1409     printf("ThreadMessageHandler started\n");
1410     SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1411     while (!fShutdown)
1412     {
1413         vector<CNode*> vNodesCopy;
1414         CRITICAL_BLOCK(cs_vNodes)
1415         {
1416             vNodesCopy = vNodes;
1417             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1418                 pnode->AddRef();
1419         }
1420
1421         // Poll the connected nodes for messages
1422         CNode* pnodeTrickle = NULL;
1423         if (!vNodesCopy.empty())
1424             pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1425         BOOST_FOREACH(CNode* pnode, vNodesCopy)
1426         {
1427             // Receive messages
1428             TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1429                 ProcessMessages(pnode);
1430             if (fShutdown)
1431                 return;
1432
1433             // Send messages
1434             TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1435                 SendMessages(pnode, pnode == pnodeTrickle);
1436             if (fShutdown)
1437                 return;
1438         }
1439
1440         CRITICAL_BLOCK(cs_vNodes)
1441         {
1442             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1443                 pnode->Release();
1444         }
1445
1446         // Wait and allow messages to bunch up.
1447         // Reduce vnThreadsRunning so StopNode has permission to exit while
1448         // we're sleeping, but we must always check fShutdown after doing this.
1449         vnThreadsRunning[2]--;
1450         Sleep(100);
1451         if (fRequestShutdown)
1452             Shutdown(NULL);
1453         vnThreadsRunning[2]++;
1454         if (fShutdown)
1455             return;
1456     }
1457 }
1458
1459
1460
1461
1462
1463
1464 bool BindListenPort(string& strError)
1465 {
1466     strError = "";
1467     int nOne = 1;
1468     addrLocalHost.SetPort(GetListenPort());
1469
1470 #ifdef WIN32
1471     // Initialize Windows Sockets
1472     WSADATA wsadata;
1473     int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1474     if (ret != NO_ERROR)
1475     {
1476         strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1477         printf("%s\n", strError.c_str());
1478         return false;
1479     }
1480 #endif
1481
1482     // Create socket for listening for incoming connections
1483     hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1484     if (hListenSocket == INVALID_SOCKET)
1485     {
1486         strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1487         printf("%s\n", strError.c_str());
1488         return false;
1489     }
1490
1491 #ifdef SO_NOSIGPIPE
1492     // Different way of disabling SIGPIPE on BSD
1493     setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1494 #endif
1495
1496 #ifndef WIN32
1497     // Allow binding if the port is still in TIME_WAIT state after
1498     // the program was closed and restarted.  Not an issue on windows.
1499     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1500 #endif
1501
1502 #ifdef WIN32
1503     // Set to nonblocking, incoming connections will also inherit this
1504     if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1505 #else
1506     if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1507 #endif
1508     {
1509         strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1510         printf("%s\n", strError.c_str());
1511         return false;
1512     }
1513
1514     // The sockaddr_in structure specifies the address family,
1515     // IP address, and port for the socket that is being bound
1516     struct sockaddr_in sockaddr;
1517     memset(&sockaddr, 0, sizeof(sockaddr));
1518     sockaddr.sin_family = AF_INET;
1519     sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1520     sockaddr.sin_port = htons(GetListenPort());
1521     if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1522     {
1523         int nErr = WSAGetLastError();
1524         if (nErr == WSAEADDRINUSE)
1525             strError = strprintf(_("Unable to bind to port %d on this computer.  Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1526         else
1527             strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1528         printf("%s\n", strError.c_str());
1529         return false;
1530     }
1531     printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1532
1533     // Listen for incoming connections
1534     if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1535     {
1536         strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1537         printf("%s\n", strError.c_str());
1538         return false;
1539     }
1540
1541     return true;
1542 }
1543
1544 void StartNode(void* parg)
1545 {
1546     if (pnodeLocalHost == NULL)
1547         pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress(CService("127.0.0.1", 0), nLocalServices));
1548
1549 #ifdef WIN32
1550     // Get local host ip
1551     char pszHostName[1000] = "";
1552     if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1553     {
1554         vector<CNetAddr> vaddr;
1555         if (LookupHost(pszHostName, vaddr))
1556             BOOST_FOREACH (const CNetAddr &addr, vaddr)
1557                 if (!addr.IsLocal())
1558                 {
1559                     addrLocalHost.SetIP(addr);
1560                     break;
1561                 }
1562     }
1563 #else
1564     // Get local host ip
1565     struct ifaddrs* myaddrs;
1566     if (getifaddrs(&myaddrs) == 0)
1567     {
1568         for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1569         {
1570             if (ifa->ifa_addr == NULL) continue;
1571             if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1572             if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1573             if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1574             char pszIP[100];
1575             if (ifa->ifa_addr->sa_family == AF_INET)
1576             {
1577                 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1578                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1579                     printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1580
1581                 // Take the first IP that isn't loopback 127.x.x.x
1582                 CAddress addr(CService(s4->sin_addr, GetListenPort()), nLocalServices);
1583                 if (addr.IsValid() && !addr.IsLocal())
1584                 {
1585                     addrLocalHost = addr;
1586                     break;
1587                 }
1588             }
1589             else if (ifa->ifa_addr->sa_family == AF_INET6)
1590             {
1591                 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1592                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1593                     printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1594             }
1595         }
1596         freeifaddrs(myaddrs);
1597     }
1598 #endif
1599     printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1600
1601     if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1602     {
1603         // Proxies can't take incoming connections
1604         addrLocalHost.SetIP(CNetAddr("0.0.0.0"));
1605         printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1606     }
1607     else
1608     {
1609         CreateThread(ThreadGetMyExternalIP, NULL);
1610     }
1611
1612     //
1613     // Start threads
1614     //
1615
1616     if (GetBoolArg("-nodnsseed"))
1617         printf("DNS seeding disabled\n");
1618     else
1619         if (!CreateThread(ThreadDNSAddressSeed, NULL))
1620             printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1621
1622     // Map ports with UPnP
1623     if (fHaveUPnP)
1624         MapPort(fUseUPnP);
1625
1626     // Get addresses from IRC and advertise ours
1627     if (!CreateThread(ThreadIRCSeed, NULL))
1628         printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1629
1630     // Send and receive from sockets, accept connections
1631     if (!CreateThread(ThreadSocketHandler, NULL))
1632         printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1633
1634     // Initiate outbound connections
1635     if (!CreateThread(ThreadOpenConnections, NULL))
1636         printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1637
1638     // Process messages
1639     if (!CreateThread(ThreadMessageHandler, NULL))
1640         printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1641
1642     // Generate coins in the background
1643     GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1644 }
1645
1646 bool StopNode()
1647 {
1648     printf("StopNode()\n");
1649     fShutdown = true;
1650     nTransactionsUpdated++;
1651     int64 nStart = GetTime();
1652     while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1653 #ifdef USE_UPNP
1654         || vnThreadsRunning[5] > 0
1655 #endif
1656     )
1657     {
1658         if (GetTime() - nStart > 20)
1659             break;
1660         Sleep(20);
1661     }
1662     if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1663     if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1664     if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1665     if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1666     if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1667     if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1668     if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1669     while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1670         Sleep(20);
1671     Sleep(50);
1672
1673     return true;
1674 }
1675
1676 class CNetCleanup
1677 {
1678 public:
1679     CNetCleanup()
1680     {
1681     }
1682     ~CNetCleanup()
1683     {
1684         // Close sockets
1685         BOOST_FOREACH(CNode* pnode, vNodes)
1686             if (pnode->hSocket != INVALID_SOCKET)
1687                 closesocket(pnode->hSocket);
1688         if (hListenSocket != INVALID_SOCKET)
1689             if (closesocket(hListenSocket) == SOCKET_ERROR)
1690                 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1691
1692 #ifdef WIN32
1693         // Shutdown Windows Sockets
1694         WSACleanup();
1695 #endif
1696     }
1697 }
1698 instance_of_cnetcleanup;