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     "bitseed.bitcoin.org.uk",
1163     "dnsseed.bluematt.me",
1164 };
1165
1166 void DNSAddressSeed()
1167 {
1168     int found = 0;
1169
1170     if (!fTestNet)
1171     {
1172         printf("Loading addresses from DNS seeds (could take a while)\n");
1173         CAddrDB addrDB;
1174         addrDB.TxnBegin();
1175
1176         for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1177             vector<CAddress> vaddr;
1178             if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1179             {
1180                 BOOST_FOREACH (CAddress& addr, vaddr)
1181                 {
1182                     if (addr.GetByte(3) != 127)
1183                     {
1184                         addr.nTime = 0;
1185                         AddAddress(addr, 0, &addrDB);
1186                         found++;
1187                     }
1188                 }
1189             }
1190         }
1191
1192         addrDB.TxnCommit();  // Save addresses (it's ok if this fails)
1193     }
1194
1195     printf("%d addresses found from DNS seeds\n", found);
1196 }
1197
1198
1199
1200 unsigned int pnSeed[] =
1201 {
1202     0x6884ac63, 0x3ffecead, 0x2919b953, 0x0942fe50, 0x7a1d922e, 0xcdd6734a, 0x953a5bb6, 0x2c46922e,
1203     0xe2a5f143, 0xaa39103a, 0xa06afa5c, 0x135ffd59, 0xe8e82863, 0xf61ef029, 0xf75f042e, 0x2b363532,
1204     0x29b2df42, 0x16b1f64e, 0xd46e281b, 0x5280bf58, 0x60372229, 0x1be58e4f, 0xa8496f45, 0x1fb1a057,
1205     0x756b3844, 0x3bb79445, 0x0b375518, 0xcccb0102, 0xb682bf2e, 0x46431c02, 0x3a81073a, 0xa3771f1f,
1206     0x213a121f, 0x85dc2c1b, 0x56b4323b, 0xb34e8945, 0x3c40b33d, 0xfa276418, 0x1f818d29, 0xebe1e344,
1207     0xf6160a18, 0xf4fa384a, 0x34b09558, 0xb882b543, 0xe3ce2253, 0x6abf56d8, 0xe91b1155, 0x688ee6ad,
1208     0x2efc6058, 0x4792cd47, 0x0c32f757, 0x4c813a46, 0x8c93644a, 0x37507444, 0x813ad218, 0xdac06d4a,
1209     0xe4c63e4b, 0x21a1ea3c, 0x8d88556f, 0x30e9173a, 0x041f681b, 0xdc77ba50, 0xc0072753, 0xceddd44f,
1210     0x052d1743, 0xe3c77a4a, 0x13981c3a, 0x5685d918, 0x3c0e4e70, 0x3e56fb54, 0xb676ae0c, 0xac93c859,
1211     0x22279f43, 0x975a4542, 0xe527f071, 0xea162f2e, 0x3c65a32e, 0x5be5713b, 0x961ec418, 0xb202922e,
1212     0x5ef7be50, 0xce49f53e, 0x05803b47, 0x8463b055, 0x78576153, 0x3ec2ae3a, 0x4bbd7118, 0xafcee043,
1213     0x56a3e8ba, 0x6174de4d, 0x8d01ba4b, 0xc9af564e, 0xdbc9c547, 0xa627474d, 0xdada9244, 0xd3b3083a,
1214     0x523e071f, 0xd6b96f18, 0xbd527c46, 0xdf2bbb4d, 0xd37b4a4b, 0x3a6a2158, 0xc064b055, 0x18a8e055,
1215     0xec4dae3b, 0x0540416c, 0x475b4fbe, 0x064803b2, 0x48e9f062, 0x2898524b, 0xd315ff43, 0xf786d247,
1216     0xc7ea2f3e, 0xc087f043, 0xc163354b, 0x8250284d, 0xed300029, 0xbf36e05c, 0x8eb3ae4c, 0xe7aa623e,
1217     0x7ced0274, 0xdd362c1b, 0x362b995a, 0xca26b629, 0x3fc41618, 0xb97b364e, 0xa05b8729, 0x0f5e3c43,
1218     0xdf942618, 0x6aeb9b5b, 0xbf04762e, 0xfaaeb118, 0x87579958, 0x76520044, 0xc2660c5b, 0x628b201b,
1219     0xf193932e, 0x1c0ad045, 0xff908346, 0x8da9d4da, 0xed201c1f, 0xa47a2b1b, 0x330007d4, 0x8ba1ed47,
1220     0xb2f02d44, 0x7db62c1b, 0x781c454b, 0xc0300029, 0xb7062a45, 0x88b52e3a, 0x78dd6b63, 0x1cb9b718,
1221     0x5d358e47, 0x59912c3b, 0x79607544, 0x5197f759, 0xc023be48, 0xd1013743, 0x0f354057, 0x8e3aac3b,
1222     0x4114693e, 0x22316318, 0xe27dda50, 0x878eac3b, 0x4948a21f, 0x5db7f24c, 0x8ccb6157, 0x26a5de18,
1223     0x0a11bd43, 0x27bb1e41, 0x60a7a951, 0x3e16b35e, 0x07888b53, 0x5648a853, 0x0149fe50, 0xd070a34f,
1224     0x6454c96d, 0xd6e54758, 0xa96dc152, 0x65447861, 0xf6bdf95e, 0x10400202, 0x2c29d483, 0x18174732,
1225     0x1d840618, 0x12e61818, 0x089d3f3c, 0x917e931f, 0xd1b0c90e, 0x25bd3c42, 0xeb05775b, 0x7d550c59,
1226     0x6cfacb01, 0xe4224444, 0xa41dd943, 0x0f5aa643, 0x5e33731b, 0x81036d50, 0x6f46a0d1, 0x7731be43,
1227     0x14840e18, 0xf1e8d059, 0x661d2b1f, 0x40a3201b, 0x9407b843, 0xedf0254d, 0x7bd1a5bc, 0x073dbe51,
1228     0xe864a97b, 0x2efd947b, 0xb9ca0e45, 0x4e2113ad, 0xcc305731, 0xd39ca63c, 0x733df918, 0xda172b1f,
1229     0xaa03b34d, 0x7230fd4d, 0xf1ce6e3a, 0x2e9fab43, 0xa4010750, 0xa928bd18, 0x6809be42, 0xb19de348,
1230     0xff956270, 0x0d795f51, 0xd2dec247, 0x6df5774b, 0xbac11f79, 0xdfb05c75, 0x887683d8, 0xa1e83632,
1231     0x2c0f7671, 0x28bcb65d, 0xac2a7545, 0x3eebfc60, 0x304ad7c4, 0xa215a462, 0xc86f0f58, 0xcfb92ebe,
1232     0x5e23ed82, 0xf506184b, 0xec0f19b7, 0x060c59ad, 0x86ee3174, 0x85380774, 0xa199a562, 0x02b507ae,
1233     0x33eb2163, 0xf2112b1f, 0xb702ba50, 0x131b9618, 0x90ccd04a, 0x08f3273b, 0xecb61718, 0x64b8b44d,
1234     0x182bf4dc, 0xc7b68286, 0x6e318d5f, 0xfdb03654, 0xb3272e54, 0xe014ad4b, 0x274e4a31, 0x7806375c,
1235     0xbc34a748, 0x1b5ad94a, 0x6b54d10e, 0x73e2ae6e, 0x5529d483, 0x8455a76d, 0x99c13f47, 0x1d811741,
1236     0xa9782a78, 0x0b00464d, 0x7266ea50, 0x532dab46, 0x33e1413e, 0x780d0c18, 0x0fb0854e, 0x03370155,
1237     0x2693042e, 0xfa3d824a, 0x2bb1681b, 0x37ea2a18, 0x7fb8414b, 0x32e0713b, 0xacf38d3f, 0xa282716f,
1238     0xb1a09d7b, 0xa04b764b, 0x83c94d18, 0x05ee4c6d, 0x0e795f51, 0x46984352, 0xf80fc247, 0x3fccb946,
1239     0xd7ae244b, 0x0a8e0a4c, 0x57b141bc, 0x3647bed1, 0x1431b052, 0x803a8bbb, 0xfc69056b, 0xf5991862,
1240     0x14963b2e, 0xd35d5dda, 0xc6c73574, 0xc8f1405b, 0x0ca4224d, 0xecd36071, 0xa9461754, 0xe7a0ed72,
1241     0x559e8346, 0x1c9beec1, 0xc786ea4a, 0x9561b44d, 0x9788074d, 0x1a69934f, 0x23c5614c, 0x07c79d4b,
1242     0xc7ee52db, 0xc72df351, 0xcb135e44, 0xa0988346, 0xc211fc4c, 0x87dec34b, 0x1381074d, 0x04a65cb7,
1243     0x4409083a, 0x4a407a4c, 0x92b8d37d, 0xacf50b4d, 0xa58aa5bc, 0x448f801f, 0x9c83762e, 0x6fd5734a,
1244     0xfe2d454b, 0x84144c55, 0x05190e4c, 0xb2151448, 0x63867a3e, 0x16099018, 0x9c010d3c, 0x962d8f3d,
1245     0xd51ee453, 0x9d86801f, 0x68e87b47, 0x6bf7bb73, 0x5fc7910e, 0x10d90118, 0x3db04442, 0x729d3e4b,
1246     0xc397d842, 0x57bb15ad, 0x72f31f4e, 0xc9380043, 0x2bb24e18, 0xd9b8ab50, 0xb786801f, 0xf4dc4847,
1247     0x85f4bb51, 0x4435995b, 0x5ba07e40, 0x2c57392e, 0x3628124b, 0x9839b64b, 0x6fe8b24d, 0xaddce847,
1248     0x75260e45, 0x0c572a43, 0xfea21902, 0xb9f9742e, 0x5a70d443, 0x8fc5910e, 0x868d4744, 0x56245e02,
1249     0xd7eb5f02, 0x35c12c1b, 0x4373034b, 0x8786554c, 0xa6facf18, 0x4b11a31f, 0x3570664e, 0x5a64bc42,
1250     0x0b03983f, 0x8f457e4c, 0x0fd874c3, 0xb6cf31b2, 0x2bbc2d4e, 0x146ca5b2, 0x9d00b150, 0x048a4153,
1251     0xca4dcd43, 0xc1607cca, 0x8234cf57, 0x9c7daead, 0x3dc07658, 0xea5c6e4c, 0xf1a0084e, 0x16d2ee53,
1252     0x1b849418, 0xfe913a47, 0x1e988f62, 0x208b644c, 0xc55ee980, 0xbdbce747, 0xf59a384e, 0x0f56091b,
1253     0x7417b745, 0x0c37344e, 0x2c62ab47, 0xf8533a4d, 0x8030084d, 0x76b93c4b, 0xda6ea0ad, 0x3c54f618,
1254     0x63b0de1f, 0x7370d858, 0x1a70bb4c, 0xdda63b2e, 0x60b2ba50, 0x1ba7d048, 0xbe1b2c1b, 0xabea5747,
1255     0x29ad2e4d, 0xe8cd7642, 0x66c80e18, 0x138bf34a, 0xc6145e44, 0x2586794c, 0x07bc5478, 0x0da0b14d,
1256     0x8f95354e, 0x9eb11c62, 0xa1545e46, 0x2e7a2602, 0x408c9c3d, 0x59065d55, 0xf51d1a4c, 0x3bbc6a4e,
1257     0xc71b2a2e, 0xcdaaa545, 0x17d659d0, 0x5202e7ad, 0xf1b68445, 0x93375961, 0xbd88a043, 0x066ad655,
1258     0x890f6318, 0x7b7dca47, 0x99bdd662, 0x3bb4fc53, 0x1231efdc, 0xc0a99444, 0x96bbea47, 0x61ed8748,
1259     0x27dfa73b, 0x8d4d1754, 0x3460042e, 0x551f0c4c, 0x8d0e0718, 0x162ddc53, 0x53231718, 0x1ecd65d0,
1260     0x944d28bc, 0x3b79d058, 0xaff97fbc, 0x4860006c, 0xc101c90e, 0xace41743, 0xa5975d4c, 0x5cc2703e,
1261     0xb55a4450, 0x02d18840, 0xee2765ae, 0xd6012fd5, 0x24c94d7d, 0x8c6eec47, 0x7520ba5d, 0x9e15e460,
1262     0x8510b04c, 0x75ec3847, 0x1dfa6661, 0xe172b3ad, 0x5744c90e, 0x52a0a152, 0x8d6fad18, 0x67b74b6d,
1263     0x93a089b2, 0x0f3ac5d5, 0xe5de1855, 0x43d25747, 0x4bad804a, 0x55b408d8, 0x60a36441, 0xf553e860,
1264     0xdb2fa2c8, 0x03152b32, 0xdd27a7d5, 0x3116a8b8, 0x0a1d708c, 0xeee2f13c, 0x6acf436f, 0xce6eb4ca,
1265     0x101cd3d9, 0x1c48a6b8, 0xe57d6f44, 0x93dcf562,
1266 };
1267
1268
1269
1270 void ThreadOpenConnections(void* parg)
1271 {
1272     IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1273     try
1274     {
1275         vnThreadsRunning[1]++;
1276         ThreadOpenConnections2(parg);
1277         vnThreadsRunning[1]--;
1278     }
1279     catch (std::exception& e) {
1280         vnThreadsRunning[1]--;
1281         PrintException(&e, "ThreadOpenConnections()");
1282     } catch (...) {
1283         vnThreadsRunning[1]--;
1284         PrintException(NULL, "ThreadOpenConnections()");
1285     }
1286     printf("ThreadOpenConnections exiting\n");
1287 }
1288
1289 void ThreadOpenConnections2(void* parg)
1290 {
1291     printf("ThreadOpenConnections started\n");
1292
1293     // Connect to specific addresses
1294     if (mapArgs.count("-connect"))
1295     {
1296         for (int64 nLoop = 0;; nLoop++)
1297         {
1298             BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1299             {
1300                 CAddress addr(strAddr, fAllowDNS);
1301                 if (addr.IsValid())
1302                     OpenNetworkConnection(addr);
1303                 for (int i = 0; i < 10 && i < nLoop; i++)
1304                 {
1305                     Sleep(500);
1306                     if (fShutdown)
1307                         return;
1308                 }
1309             }
1310         }
1311     }
1312
1313     // Connect to manually added nodes first
1314     if (mapArgs.count("-addnode"))
1315     {
1316         BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1317         {
1318             CAddress addr(strAddr, fAllowDNS);
1319             if (addr.IsValid())
1320             {
1321                 OpenNetworkConnection(addr);
1322                 Sleep(500);
1323                 if (fShutdown)
1324                     return;
1325             }
1326         }
1327     }
1328
1329     // Initiate network connections
1330     int64 nStart = GetTime();
1331     loop
1332     {
1333         // Limit outbound connections
1334         vnThreadsRunning[1]--;
1335         Sleep(500);
1336         loop
1337         {
1338             int nOutbound = 0;
1339             CRITICAL_BLOCK(cs_vNodes)
1340                 BOOST_FOREACH(CNode* pnode, vNodes)
1341                     if (!pnode->fInbound)
1342                         nOutbound++;
1343             int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1344             nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1345             if (nOutbound < nMaxOutboundConnections)
1346                 break;
1347             Sleep(2000);
1348             if (fShutdown)
1349                 return;
1350         }
1351         vnThreadsRunning[1]++;
1352         if (fShutdown)
1353             return;
1354
1355         CRITICAL_BLOCK(cs_mapAddresses)
1356         {
1357             // Add seed nodes if IRC isn't working
1358             bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1359             if (mapAddresses.empty() && (GetTime() - nStart > 60 || fTOR) && !fTestNet)
1360             {
1361                 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1362                 {
1363                     // It'll only connect to one or two seed nodes because once it connects,
1364                     // it'll get a pile of addresses with newer timestamps.
1365                     // Seed nodes are given a random 'last seen time' of between one and two
1366                     // weeks ago.
1367                     const int64 nOneWeek = 7*24*60*60;
1368                     CAddress addr;
1369                     addr.ip = pnSeed[i];
1370                     addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1371                     AddAddress(addr);
1372                 }
1373             }
1374         }
1375
1376
1377         //
1378         // Choose an address to connect to based on most recently seen
1379         //
1380         CAddress addrConnect;
1381         int64 nBest = INT64_MIN;
1382
1383         // Only connect to one address per a.b.?.? range.
1384         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1385         set<unsigned int> setConnected;
1386         CRITICAL_BLOCK(cs_vNodes)
1387             BOOST_FOREACH(CNode* pnode, vNodes)
1388                 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1389
1390         int64 nANow = GetAdjustedTime();
1391
1392         CRITICAL_BLOCK(cs_mapAddresses)
1393         {
1394             BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1395             {
1396                 const CAddress& addr = item.second;
1397                 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1398                     continue;
1399                 int64 nSinceLastSeen = nANow - addr.nTime;
1400                 int64 nSinceLastTry = nANow - addr.nLastTry;
1401
1402                 // Randomize the order in a deterministic way, putting the standard port first
1403                 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1404                 if (addr.port != htons(GetDefaultPort()))
1405                     nRandomizer += 2 * 60 * 60;
1406
1407                 // Last seen  Base retry frequency
1408                 //   <1 hour   10 min
1409                 //    1 hour    1 hour
1410                 //    4 hours   2 hours
1411                 //   24 hours   5 hours
1412                 //   48 hours   7 hours
1413                 //    7 days   13 hours
1414                 //   30 days   27 hours
1415                 //   90 days   46 hours
1416                 //  365 days   93 hours
1417                 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1418
1419                 // Fast reconnect for one hour after last seen
1420                 if (nSinceLastSeen < 60 * 60)
1421                     nDelay = 10 * 60;
1422
1423                 // Limit retry frequency
1424                 if (nSinceLastTry < nDelay)
1425                     continue;
1426
1427                 // If we have IRC, we'll be notified when they first come online,
1428                 // and again every 24 hours by the refresh broadcast.
1429                 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1430                     continue;
1431
1432                 // Only try the old stuff if we don't have enough connections
1433                 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1434                     continue;
1435
1436                 // If multiple addresses are ready, prioritize by time since
1437                 // last seen and time since last tried.
1438                 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1439                 if (nScore > nBest)
1440                 {
1441                     nBest = nScore;
1442                     addrConnect = addr;
1443                 }
1444             }
1445         }
1446
1447         if (addrConnect.IsValid())
1448             OpenNetworkConnection(addrConnect);
1449     }
1450 }
1451
1452 bool OpenNetworkConnection(const CAddress& addrConnect)
1453 {
1454     //
1455     // Initiate outbound network connection
1456     //
1457     if (fShutdown)
1458         return false;
1459     if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() || FindNode(addrConnect.ip))
1460         return false;
1461
1462     vnThreadsRunning[1]--;
1463     CNode* pnode = ConnectNode(addrConnect);
1464     vnThreadsRunning[1]++;
1465     if (fShutdown)
1466         return false;
1467     if (!pnode)
1468         return false;
1469     pnode->fNetworkNode = true;
1470
1471     return true;
1472 }
1473
1474
1475
1476
1477
1478
1479
1480
1481 void ThreadMessageHandler(void* parg)
1482 {
1483     IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1484     try
1485     {
1486         vnThreadsRunning[2]++;
1487         ThreadMessageHandler2(parg);
1488         vnThreadsRunning[2]--;
1489     }
1490     catch (std::exception& e) {
1491         vnThreadsRunning[2]--;
1492         PrintException(&e, "ThreadMessageHandler()");
1493     } catch (...) {
1494         vnThreadsRunning[2]--;
1495         PrintException(NULL, "ThreadMessageHandler()");
1496     }
1497     printf("ThreadMessageHandler exiting\n");
1498 }
1499
1500 void ThreadMessageHandler2(void* parg)
1501 {
1502     printf("ThreadMessageHandler started\n");
1503     SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1504     while (!fShutdown)
1505     {
1506         vector<CNode*> vNodesCopy;
1507         CRITICAL_BLOCK(cs_vNodes)
1508         {
1509             vNodesCopy = vNodes;
1510             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1511                 pnode->AddRef();
1512         }
1513
1514         // Poll the connected nodes for messages
1515         CNode* pnodeTrickle = NULL;
1516         if (!vNodesCopy.empty())
1517             pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1518         BOOST_FOREACH(CNode* pnode, vNodesCopy)
1519         {
1520             // Receive messages
1521             TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1522                 ProcessMessages(pnode);
1523             if (fShutdown)
1524                 return;
1525
1526             // Send messages
1527             TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1528                 SendMessages(pnode, pnode == pnodeTrickle);
1529             if (fShutdown)
1530                 return;
1531         }
1532
1533         CRITICAL_BLOCK(cs_vNodes)
1534         {
1535             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1536                 pnode->Release();
1537         }
1538
1539         // Wait and allow messages to bunch up.
1540         // Reduce vnThreadsRunning so StopNode has permission to exit while
1541         // we're sleeping, but we must always check fShutdown after doing this.
1542         vnThreadsRunning[2]--;
1543         Sleep(100);
1544         if (fRequestShutdown)
1545             Shutdown(NULL);
1546         vnThreadsRunning[2]++;
1547         if (fShutdown)
1548             return;
1549     }
1550 }
1551
1552
1553
1554
1555
1556
1557 bool BindListenPort(string& strError)
1558 {
1559     strError = "";
1560     int nOne = 1;
1561     addrLocalHost.port = htons(GetListenPort());
1562
1563 #ifdef __WXMSW__
1564     // Initialize Windows Sockets
1565     WSADATA wsadata;
1566     int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1567     if (ret != NO_ERROR)
1568     {
1569         strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1570         printf("%s\n", strError.c_str());
1571         return false;
1572     }
1573 #endif
1574
1575     // Create socket for listening for incoming connections
1576     hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1577     if (hListenSocket == INVALID_SOCKET)
1578     {
1579         strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1580         printf("%s\n", strError.c_str());
1581         return false;
1582     }
1583
1584 #ifdef SO_NOSIGPIPE
1585     // Different way of disabling SIGPIPE on BSD
1586     setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1587 #endif
1588
1589 #ifndef __WXMSW__
1590     // Allow binding if the port is still in TIME_WAIT state after
1591     // the program was closed and restarted.  Not an issue on windows.
1592     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1593 #endif
1594
1595 #ifdef __WXMSW__
1596     // Set to nonblocking, incoming connections will also inherit this
1597     if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1598 #else
1599     if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1600 #endif
1601     {
1602         strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1603         printf("%s\n", strError.c_str());
1604         return false;
1605     }
1606
1607     // The sockaddr_in structure specifies the address family,
1608     // IP address, and port for the socket that is being bound
1609     struct sockaddr_in sockaddr;
1610     memset(&sockaddr, 0, sizeof(sockaddr));
1611     sockaddr.sin_family = AF_INET;
1612     sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1613     sockaddr.sin_port = htons(GetListenPort());
1614     if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1615     {
1616         int nErr = WSAGetLastError();
1617         if (nErr == WSAEADDRINUSE)
1618             strError = strprintf(_("Unable to bind to port %d on this computer.  Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1619         else
1620             strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1621         printf("%s\n", strError.c_str());
1622         return false;
1623     }
1624     printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1625
1626     // Listen for incoming connections
1627     if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1628     {
1629         strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1630         printf("%s\n", strError.c_str());
1631         return false;
1632     }
1633
1634     return true;
1635 }
1636
1637 void StartNode(void* parg)
1638 {
1639     if (pnodeLocalHost == NULL)
1640         pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1641
1642 #ifdef __WXMSW__
1643     // Get local host ip
1644     char pszHostName[1000] = "";
1645     if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1646     {
1647         vector<CAddress> vaddr;
1648         if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1649             BOOST_FOREACH (const CAddress &addr, vaddr)
1650                 if (addr.GetByte(3) != 127)
1651                 {
1652                     addrLocalHost = addr;
1653                     break;
1654                 }
1655     }
1656 #else
1657     // Get local host ip
1658     struct ifaddrs* myaddrs;
1659     if (getifaddrs(&myaddrs) == 0)
1660     {
1661         for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1662         {
1663             if (ifa->ifa_addr == NULL) continue;
1664             if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1665             if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1666             if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1667             char pszIP[100];
1668             if (ifa->ifa_addr->sa_family == AF_INET)
1669             {
1670                 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1671                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1672                     printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1673
1674                 // Take the first IP that isn't loopback 127.x.x.x
1675                 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1676                 if (addr.IsValid() && addr.GetByte(3) != 127)
1677                 {
1678                     addrLocalHost = addr;
1679                     break;
1680                 }
1681             }
1682             else if (ifa->ifa_addr->sa_family == AF_INET6)
1683             {
1684                 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1685                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1686                     printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1687             }
1688         }
1689         freeifaddrs(myaddrs);
1690     }
1691 #endif
1692     printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1693
1694     if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1695     {
1696         // Proxies can't take incoming connections
1697         addrLocalHost.ip = CAddress("0.0.0.0").ip;
1698         printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1699     }
1700     else
1701     {
1702         CreateThread(ThreadGetMyExternalIP, NULL);
1703     }
1704
1705     //
1706     // Start threads
1707     //
1708
1709     // Map ports with UPnP
1710     if (fHaveUPnP)
1711         MapPort(fUseUPnP);
1712
1713     // Get addresses from IRC and advertise ours
1714     if (!CreateThread(ThreadIRCSeed, NULL))
1715         printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1716
1717     // Send and receive from sockets, accept connections
1718     CreateThread(ThreadSocketHandler, NULL);
1719
1720     // Initiate outbound connections
1721     if (!CreateThread(ThreadOpenConnections, NULL))
1722         printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1723
1724     // Process messages
1725     if (!CreateThread(ThreadMessageHandler, NULL))
1726         printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1727
1728     // Generate coins in the background
1729     GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1730 }
1731
1732 bool StopNode()
1733 {
1734     printf("StopNode()\n");
1735     fShutdown = true;
1736     nTransactionsUpdated++;
1737     int64 nStart = GetTime();
1738     while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1739 #ifdef USE_UPNP
1740         || vnThreadsRunning[5] > 0
1741 #endif
1742     )
1743     {
1744         if (GetTime() - nStart > 20)
1745             break;
1746         Sleep(20);
1747     }
1748     if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1749     if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1750     if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1751     if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1752     if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1753     if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1754     while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1755         Sleep(20);
1756     Sleep(50);
1757
1758     return true;
1759 }
1760
1761 class CNetCleanup
1762 {
1763 public:
1764     CNetCleanup()
1765     {
1766     }
1767     ~CNetCleanup()
1768     {
1769         // Close sockets
1770         BOOST_FOREACH(CNode* pnode, vNodes)
1771             if (pnode->hSocket != INVALID_SOCKET)
1772                 closesocket(pnode->hSocket);
1773         if (hListenSocket != INVALID_SOCKET)
1774             if (closesocket(hListenSocket) == SOCKET_ERROR)
1775                 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1776
1777 #ifdef __WXMSW__
1778         // Shutdown Windows Sockets
1779         WSACleanup();
1780 #endif
1781     }
1782 }
1783 instance_of_cnetcleanup;