src/net.cpp

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