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