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