src/net.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING 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 #else
  16 #include <netinet/in.h>
  17 #endif
  18
  19 #ifdef USE_UPNP
  20 #include <miniupnpc/miniwget.h>
  21 #include <miniupnpc/miniupnpc.h>
  22 #include <miniupnpc/upnpcommands.h>
  23 #include <miniupnpc/upnperrors.h>
  24 #endif
  25
  26 using namespace std;
  27 using namespace boost;
  28
  29 static const int MAX_OUTBOUND_CONNECTIONS = 8;
  30
  31 void ThreadMessageHandler2(void* parg);
  32 void ThreadSocketHandler2(void* parg);
  33 void ThreadOpenConnections2(void* parg);
  34 #ifdef USE_UPNP
  35 void ThreadMapPort2(void* parg);
  36 #endif
  37 void ThreadDNSAddressSeed2(void* parg);
  38 bool OpenNetworkConnection(const CAddress& addrConnect);
  39
  40
  41
  42
  43
  44 //
  45 // Global state variables
  46 //
  47 bool fClient = false;
  48 bool fAllowDNS = false;
  49 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
  50 CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
  51 static CNode* pnodeLocalHost = NULL;
  52 uint64 nLocalHostNonce = 0;
  53 array<int, 10> vnThreadsRunning;
  54 static SOCKET hListenSocket = INVALID_SOCKET;
  55
  56 vector<CNode*> vNodes;
  57 CCriticalSection cs_vNodes;
  58 map<vector<unsigned char>, CAddress> mapAddresses;
  59 CCriticalSection cs_mapAddresses;
  60 map<CInv, CDataStream> mapRelay;
  61 deque<pair<int64, CInv> > vRelayExpiration;
  62 CCriticalSection cs_mapRelay;
  63 map<CInv, int64> mapAlreadyAskedFor;
  64
  65 // Settings
  66 int fUseProxy = false;
  67 int nConnectTimeout = 5000;
  68 CAddress addrProxy("127.0.0.1",9050);
  69
  70
  71
  72
  73 unsigned short GetListenPort()
  74 {
  75     return (unsigned short)(GetArg("-port", GetDefaultPort()));
  76 }
  77
  78 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
  79 {
  80     // Filter out duplicate requests
  81     if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
  82         return;
  83     pindexLastGetBlocksBegin = pindexBegin;
  84     hashLastGetBlocksEnd = hashEnd;
  85
  86     PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
  87 }
  88
  89
  90
  91
  92
  93 bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
  94 {
  95     hSocketRet = INVALID_SOCKET;
  96
  97     SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  98     if (hSocket == INVALID_SOCKET)
  99         return false;
 100 #ifdef SO_NOSIGPIPE
 101     int set = 1;
 102     setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
 103 #endif
 104
 105     bool fProxy = (fUseProxy && addrConnect.IsRoutable());
 106     struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
 107
 108 #ifdef WIN32
 109     u_long fNonblock = 1;
 110     if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
 111 #else
 112     int fFlags = fcntl(hSocket, F_GETFL, 0);
 113     if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
 114 #endif
 115     {
 116         closesocket(hSocket);
 117         return false;
 118     }
 119
 120
 121     if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
 122     {
 123         // WSAEINVAL is here because some legacy version of winsock uses it
 124         if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
 125         {
 126             struct timeval timeout;
 127             timeout.tv_sec  = nTimeout / 1000;
 128             timeout.tv_usec = (nTimeout % 1000) * 1000;
 129
 130             fd_set fdset;
 131             FD_ZERO(&fdset);
 132             FD_SET(hSocket, &fdset);
 133             int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
 134             if (nRet == 0)
 135             {
 136                 printf("connection timeout\n");
 137                 closesocket(hSocket);
 138                 return false;
 139             }
 140             if (nRet == SOCKET_ERROR)
 141             {
 142                 printf("select() for connection failed: %i\n",WSAGetLastError());
 143                 closesocket(hSocket);
 144                 return false;
 145             }
 146             socklen_t nRetSize = sizeof(nRet);
 147 #ifdef WIN32
 148             if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
 149 #else
 150             if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
 151 #endif
 152             {
 153                 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
 154                 closesocket(hSocket);
 155                 return false;
 156             }
 157             if (nRet != 0)
 158             {
 159                 printf("connect() failed after select(): %s\n",strerror(nRet));
 160                 closesocket(hSocket);
 161                 return false;
 162             }
 163         }
 164 #ifdef WIN32
 165         else if (WSAGetLastError() != WSAEISCONN)
 166 #else
 167         else
 168 #endif
 169         {
 170             printf("connect() failed: %i\n",WSAGetLastError());
 171             closesocket(hSocket);
 172             return false;
 173         }
 174     }
 175
 176     /*
 177     this isn't even strictly necessary
 178     CNode::ConnectNode immediately turns the socket back to non-blocking
 179     but we'll turn it back to blocking just in case
 180     */
 181 #ifdef WIN32
 182     fNonblock = 0;
 183     if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
 184 #else
 185     fFlags = fcntl(hSocket, F_GETFL, 0);
 186     if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
 187 #endif
 188     {
 189         closesocket(hSocket);
 190         return false;
 191     }
 192
 193     if (fProxy)
 194     {
 195         printf("proxy connecting %s\n", addrConnect.ToString().c_str());
 196         char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
 197         memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
 198         memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
 199         char* pszSocks4 = pszSocks4IP;
 200         int nSize = sizeof(pszSocks4IP);
 201
 202         int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
 203         if (ret != nSize)
 204         {
 205             closesocket(hSocket);
 206             return error("Error sending to proxy");
 207         }
 208         char pchRet[8];
 209         if (recv(hSocket, pchRet, 8, 0) != 8)
 210         {
 211             closesocket(hSocket);
 212             return error("Error reading proxy response");
 213         }
 214         if (pchRet[1] != 0x5a)
 215         {
 216             closesocket(hSocket);
 217             if (pchRet[1] != 0x5b)
 218                 printf("ERROR: Proxy returned error %d\n", pchRet[1]);
 219             return false;
 220         }
 221         printf("proxy connected %s\n", addrConnect.ToString().c_str());
 222     }
 223
 224     hSocketRet = hSocket;
 225     return true;
 226 }
 227
 228 // portDefault is in host order
 229 bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
 230 {
 231     vaddr.clear();
 232     if (pszName[0] == 0)
 233         return false;
 234     int port = portDefault;
 235     char psz[256];
 236     char *pszHost = psz;
 237     strlcpy(psz, pszName, sizeof(psz));
 238     if (fAllowPort)
 239     {
 240         char* pszColon = strrchr(psz+1,':');
 241         char *pszPortEnd = NULL;
 242         int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
 243         if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
 244         {
 245             if (psz[0] == '[' && pszColon[-1] == ']')
 246             {
 247                 // Future: enable IPv6 colon-notation inside []
 248                 pszHost = psz+1;
 249                 pszColon[-1] = 0;
 250             }
 251             else
 252                 pszColon[0] = 0;
 253             port = portParsed;
 254             if (port < 0 || port > USHRT_MAX)
 255                 port = USHRT_MAX;
 256         }
 257     }
 258
 259     unsigned int addrIP = inet_addr(pszHost);
 260     if (addrIP != INADDR_NONE)
 261     {
 262         // valid IP address passed
 263         vaddr.push_back(CAddress(addrIP, port, nServices));
 264         return true;
 265     }
 266
 267     if (!fAllowLookup)
 268         return false;
 269
 270     struct hostent* phostent = gethostbyname(pszHost);
 271     if (!phostent)
 272         return false;
 273
 274     if (phostent->h_addrtype != AF_INET)
 275         return false;
 276
 277     char** ppAddr = phostent->h_addr_list;
 278     while (*ppAddr != NULL && vaddr.size() != nMaxSolutions)
 279     {
 280         CAddress addr(((struct in_addr*)ppAddr[0])->s_addr, port, nServices);
 281         if (addr.IsValid())
 282             vaddr.push_back(addr);
 283         ppAddr++;
 284     }
 285
 286     return (vaddr.size() > 0);
 287 }
 288
 289 // portDefault is in host order
 290 bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup, int portDefault, bool fAllowPort)
 291 {
 292     vector<CAddress> vaddr;
 293     bool fRet = Lookup(pszName, vaddr, nServices, 1, fAllowLookup, portDefault, fAllowPort);
 294     if (fRet)
 295         addr = vaddr[0];
 296     return fRet;
 297 }
 298
 299 bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet)
 300 {
 301     SOCKET hSocket;
 302     if (!ConnectSocket(addrConnect, hSocket))
 303         return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
 304
 305     send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
 306
 307     string strLine;
 308     while (RecvLine(hSocket, strLine))
 309     {
 310         if (strLine.empty()) // HTTP response is separated from headers by blank line
 311         {
 312             loop
 313             {
 314                 if (!RecvLine(hSocket, strLine))
 315                 {
 316                     closesocket(hSocket);
 317                     return false;
 318                 }
 319                 if (pszKeyword == NULL)
 320                     break;
 321                 if (strLine.find(pszKeyword) != string::npos)
 322                 {
 323                     strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
 324                     break;
 325                 }
 326             }
 327             closesocket(hSocket);
 328             if (strLine.find("<") != string::npos)
 329                 strLine = strLine.substr(0, strLine.find("<"));
 330             strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
 331             while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
 332                 strLine.resize(strLine.size()-1);
 333             CAddress addr(strLine,0,true);
 334             printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
 335             if (addr.ip == 0 || addr.ip == INADDR_NONE || !addr.IsRoutable())
 336                 return false;
 337             ipRet = addr.ip;
 338             return true;
 339         }
 340     }
 341     closesocket(hSocket);
 342     return error("GetMyExternalIP() : connection closed");
 343 }
 344
 345 // We now get our external IP from the IRC server first and only use this as a backup
 346 bool GetMyExternalIP(unsigned int& ipRet)
 347 {
 348     CAddress addrConnect;
 349     const char* pszGet;
 350     const char* pszKeyword;
 351
 352     if (fUseProxy)
 353         return false;
 354
 355     for (int nLookup = 0; nLookup <= 1; nLookup++)
 356     for (int nHost = 1; nHost <= 2; nHost++)
 357     {
 358         // We should be phasing out our use of sites like these.  If we need
 359         // replacements, we should ask for volunteers to put this simple
 360         // php file on their webserver that prints the client IP:
 361         //  <?php echo $_SERVER["REMOTE_ADDR"]; ?>
 362         if (nHost == 1)
 363         {
 364             addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
 365
 366             if (nLookup == 1)
 367             {
 368                 CAddress addrIP("checkip.dyndns.org", 80, true);
 369                 if (addrIP.IsValid())
 370                     addrConnect = addrIP;
 371             }
 372
 373             pszGet = "GET / HTTP/1.1\r\n"
 374                      "Host: checkip.dyndns.org\r\n"
 375                      "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
 376                      "Connection: close\r\n"
 377                      "\r\n";
 378
 379             pszKeyword = "Address:";
 380         }
 381         else if (nHost == 2)
 382         {
 383             addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
 384
 385             if (nLookup == 1)
 386             {
 387                 CAddress addrIP("www.showmyip.com", 80, true);
 388                 if (addrIP.IsValid())
 389                     addrConnect = addrIP;
 390             }
 391
 392             pszGet = "GET /simple/ HTTP/1.1\r\n"
 393                      "Host: www.showmyip.com\r\n"
 394                      "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
 395                      "Connection: close\r\n"
 396                      "\r\n";
 397
 398             pszKeyword = NULL; // Returns just IP address
 399         }
 400
 401         if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
 402             return true;
 403     }
 404
 405     return false;
 406 }
 407
 408 void ThreadGetMyExternalIP(void* parg)
 409 {
 410     // Wait for IRC to get it first
 411     if (!GetBoolArg("-noirc"))
 412     {
 413         for (int i = 0; i < 2 * 60; i++)
 414         {
 415             Sleep(1000);
 416             if (fGotExternalIP || fShutdown)
 417                 return;
 418         }
 419     }
 420
 421     // Fallback in case IRC fails to get it
 422     if (GetMyExternalIP(addrLocalHost.ip))
 423     {
 424         printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
 425         if (addrLocalHost.IsRoutable())
 426         {
 427             // If we already connected to a few before we had our IP, go back and addr them.
 428             // setAddrKnown automatically filters any duplicate sends.
 429             CAddress addr(addrLocalHost);
 430             addr.nTime = GetAdjustedTime();
 431             CRITICAL_BLOCK(cs_vNodes)
 432                 BOOST_FOREACH(CNode* pnode, vNodes)
 433                     pnode->PushAddress(addr);
 434         }
 435     }
 436 }
 437
 438
 439
 440
 441
 442 bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
 443 {
 444     if (!addr.IsRoutable())
 445         return false;
 446     if (addr.ip == addrLocalHost.ip)
 447         return false;
 448     addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
 449     bool fUpdated = false;
 450     bool fNew = false;
 451     CAddress addrFound = addr;
 452
 453     CRITICAL_BLOCK(cs_mapAddresses)
 454     {
 455         map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
 456         if (it == mapAddresses.end())
 457         {
 458             // New address
 459             printf("AddAddress(%s)\n", addr.ToString().c_str());
 460             mapAddresses.insert(make_pair(addr.GetKey(), addr));
 461             fUpdated = true;
 462             fNew = true;
 463         }
 464         else
 465         {
 466             addrFound = (*it).second;
 467             if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
 468             {
 469                 // Services have been added
 470                 addrFound.nServices |= addr.nServices;
 471                 fUpdated = true;
 472             }
 473             bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
 474             int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
 475             if (addrFound.nTime < addr.nTime - nUpdateInterval)
 476             {
 477                 // Periodically update most recently seen time
 478                 addrFound.nTime = addr.nTime;
 479                 fUpdated = true;
 480             }
 481         }
 482     }
 483     // There is a nasty deadlock bug if this is done inside the cs_mapAddresses
 484     // CRITICAL_BLOCK:
 485     // Thread 1:  begin db transaction (locks inside-db-mutex)
 486     //            then AddAddress (locks cs_mapAddresses)
 487     // Thread 2:  AddAddress (locks cs_mapAddresses)
 488     //             ... then db operation hangs waiting for inside-db-mutex
 489     if (fUpdated)
 490     {
 491         if (pAddrDB)
 492             pAddrDB->WriteAddress(addrFound);
 493         else
 494             CAddrDB().WriteAddress(addrFound);
 495     }
 496     return fNew;
 497 }
 498
 499 void AddressCurrentlyConnected(const CAddress& addr)
 500 {
 501     CAddress *paddrFound = NULL;
 502
 503     CRITICAL_BLOCK(cs_mapAddresses)
 504     {
 505         // Only if it's been published already
 506         map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
 507         if (it != mapAddresses.end())
 508             paddrFound = &(*it).second;
 509     }
 510
 511     if (paddrFound)
 512     {
 513         int64 nUpdateInterval = 20 * 60;
 514         if (paddrFound->nTime < GetAdjustedTime() - nUpdateInterval)
 515         {
 516             // Periodically update most recently seen time
 517             paddrFound->nTime = GetAdjustedTime();
 518             CAddrDB addrdb;
 519             addrdb.WriteAddress(*paddrFound);
 520         }
 521     }
 522 }
 523
 524
 525
 526
 527
 528 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
 529 {
 530     // If the dialog might get closed before the reply comes back,
 531     // call this in the destructor so it doesn't get called after it's deleted.
 532     CRITICAL_BLOCK(cs_vNodes)
 533     {
 534         BOOST_FOREACH(CNode* pnode, vNodes)
 535         {
 536             CRITICAL_BLOCK(pnode->cs_mapRequests)
 537             {
 538                 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
 539                 {
 540                     CRequestTracker& tracker = (*mi).second;
 541                     if (tracker.fn == fn && tracker.param1 == param1)
 542                         pnode->mapRequests.erase(mi++);
 543                     else
 544                         mi++;
 545                 }
 546             }
 547         }
 548     }
 549 }
 550
 551
 552
 553
 554
 555
 556
 557 //
 558 // Subscription methods for the broadcast and subscription system.
 559 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
 560 //
 561 // The subscription system uses a meet-in-the-middle strategy.
 562 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
 563 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
 564 //
 565
 566 bool AnySubscribed(unsigned int nChannel)
 567 {
 568     if (pnodeLocalHost->IsSubscribed(nChannel))
 569         return true;
 570     CRITICAL_BLOCK(cs_vNodes)
 571         BOOST_FOREACH(CNode* pnode, vNodes)
 572             if (pnode->IsSubscribed(nChannel))
 573                 return true;
 574     return false;
 575 }
 576
 577 bool CNode::IsSubscribed(unsigned int nChannel)
 578 {
 579     if (nChannel >= vfSubscribe.size())
 580         return false;
 581     return vfSubscribe[nChannel];
 582 }
 583
 584 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
 585 {
 586     if (nChannel >= vfSubscribe.size())
 587         return;
 588
 589     if (!AnySubscribed(nChannel))
 590     {
 591         // Relay subscribe
 592         CRITICAL_BLOCK(cs_vNodes)
 593             BOOST_FOREACH(CNode* pnode, vNodes)
 594                 if (pnode != this)
 595                     pnode->PushMessage("subscribe", nChannel, nHops);
 596     }
 597
 598     vfSubscribe[nChannel] = true;
 599 }
 600
 601 void CNode::CancelSubscribe(unsigned int nChannel)
 602 {
 603     if (nChannel >= vfSubscribe.size())
 604         return;
 605
 606     // Prevent from relaying cancel if wasn't subscribed
 607     if (!vfSubscribe[nChannel])
 608         return;
 609     vfSubscribe[nChannel] = false;
 610
 611     if (!AnySubscribed(nChannel))
 612     {
 613         // Relay subscription cancel
 614         CRITICAL_BLOCK(cs_vNodes)
 615             BOOST_FOREACH(CNode* pnode, vNodes)
 616                 if (pnode != this)
 617                     pnode->PushMessage("sub-cancel", nChannel);
 618     }
 619 }
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629 CNode* FindNode(unsigned int ip)
 630 {
 631     CRITICAL_BLOCK(cs_vNodes)
 632     {
 633         BOOST_FOREACH(CNode* pnode, vNodes)
 634             if (pnode->addr.ip == ip)
 635                 return (pnode);
 636     }
 637     return NULL;
 638 }
 639
 640 CNode* FindNode(CAddress addr)
 641 {
 642     CRITICAL_BLOCK(cs_vNodes)
 643     {
 644         BOOST_FOREACH(CNode* pnode, vNodes)
 645             if (pnode->addr == addr)
 646                 return (pnode);
 647     }
 648     return NULL;
 649 }
 650
 651 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
 652 {
 653     if (addrConnect.ip == addrLocalHost.ip)
 654         return NULL;
 655
 656     // Look for an existing connection
 657     CNode* pnode = FindNode(addrConnect.ip);
 658     if (pnode)
 659     {
 660         if (nTimeout != 0)
 661             pnode->AddRef(nTimeout);
 662         else
 663             pnode->AddRef();
 664         return pnode;
 665     }
 666
 667     /// debug print
 668     printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
 669         addrConnect.ToString().c_str(),
 670         (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
 671         (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
 672
 673     CRITICAL_BLOCK(cs_mapAddresses)
 674         mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
 675
 676     // Connect
 677     SOCKET hSocket;
 678     if (ConnectSocket(addrConnect, hSocket))
 679     {
 680         /// debug print
 681         printf("connected %s\n", addrConnect.ToString().c_str());
 682
 683         // Set to nonblocking
 684 #ifdef WIN32
 685         u_long nOne = 1;
 686         if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
 687             printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
 688 #else
 689         if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
 690             printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
 691 #endif
 692
 693         // Add node
 694         CNode* pnode = new CNode(hSocket, addrConnect, false);
 695         if (nTimeout != 0)
 696             pnode->AddRef(nTimeout);
 697         else
 698             pnode->AddRef();
 699         CRITICAL_BLOCK(cs_vNodes)
 700             vNodes.push_back(pnode);
 701
 702         pnode->nTimeConnected = GetTime();
 703         return pnode;
 704     }
 705     else
 706     {
 707         return NULL;
 708     }
 709 }
 710
 711 void CNode::CloseSocketDisconnect()
 712 {
 713     fDisconnect = true;
 714     if (hSocket != INVALID_SOCKET)
 715     {
 716         if (fDebug)
 717             printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
 718         printf("disconnecting node %s\n", addr.ToString().c_str());
 719         closesocket(hSocket);
 720         hSocket = INVALID_SOCKET;
 721         vRecv.clear();
 722     }
 723 }
 724
 725 void CNode::Cleanup()
 726 {
 727     // All of a nodes broadcasts and subscriptions are automatically torn down
 728     // when it goes down, so a node has to stay up to keep its broadcast going.
 729
 730     // Cancel subscriptions
 731     for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
 732         if (vfSubscribe[nChannel])
 733             CancelSubscribe(nChannel);
 734 }
 735
 736
 737 std::map<unsigned int, int64> CNode::setBanned;
 738 CCriticalSection CNode::cs_setBanned;
 739
 740 void CNode::ClearBanned()
 741 {
 742     setBanned.clear();
 743 }
 744
 745 bool CNode::IsBanned(unsigned int ip)
 746 {
 747     bool fResult = false;
 748     CRITICAL_BLOCK(cs_setBanned)
 749     {
 750         std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
 751         if (i != setBanned.end())
 752         {
 753             int64 t = (*i).second;
 754             if (GetTime() < t)
 755                 fResult = true;
 756         }
 757     }
 758     return fResult;
 759 }
 760
 761 bool CNode::Misbehaving(int howmuch)
 762 {
 763     if (addr.IsLocal())
 764     {
 765         printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
 766         return false;
 767     }
 768
 769     nMisbehavior += howmuch;
 770     if (nMisbehavior >= GetArg("-banscore", 100))
 771     {
 772         int64 banTime = GetTime()+GetArg("-bantime", 60*60*24);  // Default 24-hour ban
 773         CRITICAL_BLOCK(cs_setBanned)
 774             if (setBanned[addr.ip] < banTime)
 775                 setBanned[addr.ip] = banTime;
 776         CloseSocketDisconnect();
 777         printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
 778         return true;
 779     }
 780     return false;
 781 }
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794 void ThreadSocketHandler(void* parg)
 795 {
 796     IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
 797     try
 798     {
 799         vnThreadsRunning[0]++;
 800         ThreadSocketHandler2(parg);
 801         vnThreadsRunning[0]--;
 802     }
 803     catch (std::exception& e) {
 804         vnThreadsRunning[0]--;
 805         PrintException(&e, "ThreadSocketHandler()");
 806     } catch (...) {
 807         vnThreadsRunning[0]--;
 808         throw; // support pthread_cancel()
 809     }
 810     printf("ThreadSocketHandler exiting\n");
 811 }
 812
 813 void ThreadSocketHandler2(void* parg)
 814 {
 815     printf("ThreadSocketHandler started\n");
 816     list<CNode*> vNodesDisconnected;
 817     int nPrevNodeCount = 0;
 818
 819     loop
 820     {
 821         //
 822         // Disconnect nodes
 823         //
 824         CRITICAL_BLOCK(cs_vNodes)
 825         {
 826             // Disconnect unused nodes
 827             vector<CNode*> vNodesCopy = vNodes;
 828             BOOST_FOREACH(CNode* pnode, vNodesCopy)
 829             {
 830                 if (pnode->fDisconnect ||
 831                     (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
 832                 {
 833                     // remove from vNodes
 834                     vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
 835
 836                     // close socket and cleanup
 837                     pnode->CloseSocketDisconnect();
 838                     pnode->Cleanup();
 839
 840                     // hold in disconnected pool until all refs are released
 841                     pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
 842                     if (pnode->fNetworkNode || pnode->fInbound)
 843                         pnode->Release();
 844                     vNodesDisconnected.push_back(pnode);
 845                 }
 846             }
 847
 848             // Delete disconnected nodes
 849             list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
 850             BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
 851             {
 852                 // wait until threads are done using it
 853                 if (pnode->GetRefCount() <= 0)
 854                 {
 855                     bool fDelete = false;
 856                     TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 857                      TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
 858                       TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
 859                        TRY_CRITICAL_BLOCK(pnode->cs_inventory)
 860                         fDelete = true;
 861                     if (fDelete)
 862                     {
 863                         vNodesDisconnected.remove(pnode);
 864                         delete pnode;
 865                     }
 866                 }
 867             }
 868         }
 869         if (vNodes.size() != nPrevNodeCount)
 870         {
 871             nPrevNodeCount = vNodes.size();
 872             MainFrameRepaint();
 873         }
 874
 875
 876         //
 877         // Find which sockets have data to receive
 878         //
 879         struct timeval timeout;
 880         timeout.tv_sec  = 0;
 881         timeout.tv_usec = 50000; // frequency to poll pnode->vSend
 882
 883         fd_set fdsetRecv;
 884         fd_set fdsetSend;
 885         fd_set fdsetError;
 886         FD_ZERO(&fdsetRecv);
 887         FD_ZERO(&fdsetSend);
 888         FD_ZERO(&fdsetError);
 889         SOCKET hSocketMax = 0;
 890
 891         if(hListenSocket != INVALID_SOCKET)
 892             FD_SET(hListenSocket, &fdsetRecv);
 893         hSocketMax = max(hSocketMax, hListenSocket);
 894         CRITICAL_BLOCK(cs_vNodes)
 895         {
 896             BOOST_FOREACH(CNode* pnode, vNodes)
 897             {
 898                 if (pnode->hSocket == INVALID_SOCKET)
 899                     continue;
 900                 FD_SET(pnode->hSocket, &fdsetRecv);
 901                 FD_SET(pnode->hSocket, &fdsetError);
 902                 hSocketMax = max(hSocketMax, pnode->hSocket);
 903                 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 904                     if (!pnode->vSend.empty())
 905                         FD_SET(pnode->hSocket, &fdsetSend);
 906             }
 907         }
 908
 909         vnThreadsRunning[0]--;
 910         int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
 911         vnThreadsRunning[0]++;
 912         if (fShutdown)
 913             return;
 914         if (nSelect == SOCKET_ERROR)
 915         {
 916             int nErr = WSAGetLastError();
 917             if (hSocketMax > -1)
 918             {
 919                 printf("socket select error %d\n", nErr);
 920                 for (unsigned int i = 0; i <= hSocketMax; i++)
 921                     FD_SET(i, &fdsetRecv);
 922             }
 923             FD_ZERO(&fdsetSend);
 924             FD_ZERO(&fdsetError);
 925             Sleep(timeout.tv_usec/1000);
 926         }
 927
 928
 929         //
 930         // Accept new connections
 931         //
 932         if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
 933         {
 934             struct sockaddr_in sockaddr;
 935             socklen_t len = sizeof(sockaddr);
 936             SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
 937             CAddress addr;
 938             int nInbound = 0;
 939
 940             if (hSocket != INVALID_SOCKET)
 941                 addr = CAddress(sockaddr);
 942
 943             CRITICAL_BLOCK(cs_vNodes)
 944                 BOOST_FOREACH(CNode* pnode, vNodes)
 945                 if (pnode->fInbound)
 946                     nInbound++;
 947
 948             if (hSocket == INVALID_SOCKET)
 949             {
 950                 if (WSAGetLastError() != WSAEWOULDBLOCK)
 951                     printf("socket error accept failed: %d\n", WSAGetLastError());
 952             }
 953             else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
 954             {
 955                 closesocket(hSocket);
 956             }
 957             else if (CNode::IsBanned(addr.ip))
 958             {
 959                 printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
 960                 closesocket(hSocket);
 961             }
 962             else
 963             {
 964                 printf("accepted connection %s\n", addr.ToString().c_str());
 965                 CNode* pnode = new CNode(hSocket, addr, true);
 966                 pnode->AddRef();
 967                 CRITICAL_BLOCK(cs_vNodes)
 968                     vNodes.push_back(pnode);
 969             }
 970         }
 971
 972
 973         //
 974         // Service each socket
 975         //
 976         vector<CNode*> vNodesCopy;
 977         CRITICAL_BLOCK(cs_vNodes)
 978         {
 979             vNodesCopy = vNodes;
 980             BOOST_FOREACH(CNode* pnode, vNodesCopy)
 981                 pnode->AddRef();
 982         }
 983         BOOST_FOREACH(CNode* pnode, vNodesCopy)
 984         {
 985             if (fShutdown)
 986                 return;
 987
 988             //
 989             // Receive
 990             //
 991             if (pnode->hSocket == INVALID_SOCKET)
 992                 continue;
 993             if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
 994             {
 995                 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
 996                 {
 997                     CDataStream& vRecv = pnode->vRecv;
 998                     unsigned int nPos = vRecv.size();
 999
1000                     if (nPos > ReceiveBufferSize()) {
1001                         if (!pnode->fDisconnect)
1002                             printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
1003                         pnode->CloseSocketDisconnect();
1004                     }
1005                     else {
1006                         // typical socket buffer is 8K-64K
1007                         char pchBuf[0x10000];
1008                         int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1009                         if (nBytes > 0)
1010                         {
1011                             vRecv.resize(nPos + nBytes);
1012                             memcpy(&vRecv[nPos], pchBuf, nBytes);
1013                             pnode->nLastRecv = GetTime();
1014                         }
1015                         else if (nBytes == 0)
1016                         {
1017                             // socket closed gracefully
1018                             if (!pnode->fDisconnect)
1019                                 printf("socket closed\n");
1020                             pnode->CloseSocketDisconnect();
1021                         }
1022                         else if (nBytes < 0)
1023                         {
1024                             // error
1025                             int nErr = WSAGetLastError();
1026                             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1027                             {
1028                                 if (!pnode->fDisconnect)
1029                                     printf("socket recv error %d\n", nErr);
1030                                 pnode->CloseSocketDisconnect();
1031                             }
1032                         }
1033                     }
1034                 }
1035             }
1036
1037             //
1038             // Send
1039             //
1040             if (pnode->hSocket == INVALID_SOCKET)
1041                 continue;
1042             if (FD_ISSET(pnode->hSocket, &fdsetSend))
1043             {
1044                 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1045                 {
1046                     CDataStream& vSend = pnode->vSend;
1047                     if (!vSend.empty())
1048                     {
1049                         int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
1050                         if (nBytes > 0)
1051                         {
1052                             vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1053                             pnode->nLastSend = GetTime();
1054                         }
1055                         else if (nBytes < 0)
1056                         {
1057                             // error
1058                             int nErr = WSAGetLastError();
1059                             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1060                             {
1061                                 printf("socket send error %d\n", nErr);
1062                                 pnode->CloseSocketDisconnect();
1063                             }
1064                         }
1065                         if (vSend.size() > SendBufferSize()) {
1066                             if (!pnode->fDisconnect)
1067                                 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1068                             pnode->CloseSocketDisconnect();
1069                         }
1070                     }
1071                 }
1072             }
1073
1074             //
1075             // Inactivity checking
1076             //
1077             if (pnode->vSend.empty())
1078                 pnode->nLastSendEmpty = GetTime();
1079             if (GetTime() - pnode->nTimeConnected > 60)
1080             {
1081                 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1082                 {
1083                     printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1084                     pnode->fDisconnect = true;
1085                 }
1086                 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1087                 {
1088                     printf("socket not sending\n");
1089                     pnode->fDisconnect = true;
1090                 }
1091                 else if (GetTime() - pnode->nLastRecv > 90*60)
1092                 {
1093                     printf("socket inactivity timeout\n");
1094                     pnode->fDisconnect = true;
1095                 }
1096             }
1097         }
1098         CRITICAL_BLOCK(cs_vNodes)
1099         {
1100             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1101                 pnode->Release();
1102         }
1103
1104         Sleep(10);
1105     }
1106 }
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116 #ifdef USE_UPNP
1117 void ThreadMapPort(void* parg)
1118 {
1119     IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1120     try
1121     {
1122         vnThreadsRunning[5]++;
1123         ThreadMapPort2(parg);
1124         vnThreadsRunning[5]--;
1125     }
1126     catch (std::exception& e) {
1127         vnThreadsRunning[5]--;
1128         PrintException(&e, "ThreadMapPort()");
1129     } catch (...) {
1130         vnThreadsRunning[5]--;
1131         PrintException(NULL, "ThreadMapPort()");
1132     }
1133     printf("ThreadMapPort exiting\n");
1134 }
1135
1136 void ThreadMapPort2(void* parg)
1137 {
1138     printf("ThreadMapPort started\n");
1139
1140     char port[6];
1141     sprintf(port, "%d", GetListenPort());
1142
1143     const char * multicastif = 0;
1144     const char * minissdpdpath = 0;
1145     struct UPNPDev * devlist = 0;
1146     char lanaddr[64];
1147
1148 #ifndef UPNPDISCOVER_SUCCESS
1149     /* miniupnpc 1.5 */
1150     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1151 #else
1152     /* miniupnpc 1.6 */
1153     int error = 0;
1154     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1155 #endif
1156
1157     struct UPNPUrls urls;
1158     struct IGDdatas data;
1159     int r;
1160
1161     r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1162     if (r == 1)
1163     {
1164         if (!addrLocalHost.IsRoutable())
1165         {
1166             char externalIPAddress[40];
1167             r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1168             if(r != UPNPCOMMAND_SUCCESS)
1169                 printf("UPnP: GetExternalIPAddress() returned %d\n", r);
1170             else
1171             {
1172                 if(externalIPAddress[0])
1173                 {
1174                     printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1175                     CAddress addrExternalFromUPnP(externalIPAddress, 0, false, nLocalServices);
1176                     if (addrExternalFromUPnP.IsRoutable())
1177                         addrLocalHost = addrExternalFromUPnP;
1178                 }
1179                 else
1180                     printf("UPnP: GetExternalIPAddress failed.\n");
1181             }
1182         }
1183
1184         string strDesc = "Bitcoin " + FormatFullVersion();
1185 #ifndef UPNPDISCOVER_SUCCESS
1186         /* miniupnpc 1.5 */
1187         r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1188                             port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1189 #else
1190         /* miniupnpc 1.6 */
1191         r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1192                             port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1193 #endif
1194
1195         if(r!=UPNPCOMMAND_SUCCESS)
1196             printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1197                 port, port, lanaddr, r, strupnperror(r));
1198         else
1199             printf("UPnP Port Mapping successful.\n");
1200         int i = 1;
1201         loop {
1202             if (fShutdown || !fUseUPnP)
1203             {
1204                 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1205                 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1206                 freeUPNPDevlist(devlist); devlist = 0;
1207                 FreeUPNPUrls(&urls);
1208                 return;
1209             }
1210             if (i % 600 == 0) // Refresh every 20 minutes
1211             {
1212 #ifndef UPNPDISCOVER_SUCCESS
1213                 /* miniupnpc 1.5 */
1214                 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1215                                     port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1216 #else
1217                 /* miniupnpc 1.6 */
1218                 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1219                                     port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1220 #endif
1221
1222                 if(r!=UPNPCOMMAND_SUCCESS)
1223                     printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1224                         port, port, lanaddr, r, strupnperror(r));
1225                 else
1226                     printf("UPnP Port Mapping successful.\n");;
1227             }
1228             Sleep(2000);
1229             i++;
1230         }
1231     } else {
1232         printf("No valid UPnP IGDs found\n");
1233         freeUPNPDevlist(devlist); devlist = 0;
1234         if (r != 0)
1235             FreeUPNPUrls(&urls);
1236         loop {
1237             if (fShutdown || !fUseUPnP)
1238                 return;
1239             Sleep(2000);
1240         }
1241     }
1242 }
1243
1244 void MapPort(bool fMapPort)
1245 {
1246     if (fUseUPnP != fMapPort)
1247     {
1248         fUseUPnP = fMapPort;
1249         WriteSetting("fUseUPnP", fUseUPnP);
1250     }
1251     if (fUseUPnP && vnThreadsRunning[5] < 1)
1252     {
1253         if (!CreateThread(ThreadMapPort, NULL))
1254             printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1255     }
1256 }
1257 #else
1258 void MapPort(bool /* unused fMapPort */)
1259 {
1260     // Intentionally left blank.
1261 }
1262 #endif
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273 static const char *strDNSSeed[] = {
1274     "bitseed.xf2.org",
1275     "dnsseed.bluematt.me",
1276     "seed.bitcoin.sipa.be",
1277     "dnsseed.bitcoin.dashjr.org",
1278 };
1279
1280 void ThreadDNSAddressSeed(void* parg)
1281 {
1282     IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1283     try
1284     {
1285         vnThreadsRunning[6]++;
1286         ThreadDNSAddressSeed2(parg);
1287         vnThreadsRunning[6]--;
1288     }
1289     catch (std::exception& e) {
1290         vnThreadsRunning[6]--;
1291         PrintException(&e, "ThreadDNSAddressSeed()");
1292     } catch (...) {
1293         vnThreadsRunning[6]--;
1294         throw; // support pthread_cancel()
1295     }
1296     printf("ThreadDNSAddressSeed exiting\n");
1297 }
1298
1299 void ThreadDNSAddressSeed2(void* parg)
1300 {
1301     printf("ThreadDNSAddressSeed started\n");
1302     int found = 0;
1303
1304     if (!fTestNet)
1305     {
1306         printf("Loading addresses from DNS seeds (could take a while)\n");
1307
1308         for (unsigned int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1309             vector<CAddress> vaddr;
1310             if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1311             {
1312                 CAddrDB addrDB;
1313                 addrDB.TxnBegin();
1314                 BOOST_FOREACH (CAddress& addr, vaddr)
1315                 {
1316                     if (addr.GetByte(3) != 127)
1317                     {
1318                         addr.nTime = 0;
1319                         AddAddress(addr, 0, &addrDB);
1320                         found++;
1321                     }
1322                 }
1323                 addrDB.TxnCommit();  // Save addresses (it's ok if this fails)
1324             }
1325         }
1326     }
1327
1328     printf("%d addresses found from DNS seeds\n", found);
1329 }
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342 unsigned int pnSeed[] =
1343 {
1344     0x959bd347, 0xf8de42b2, 0x73bc0518, 0xea6edc50, 0x21b00a4d, 0xc725b43d, 0xd665464d, 0x1a2a770e,
1345     0x27c93946, 0x65b2fa46, 0xb80ae255, 0x66b3b446, 0xb1877a3e, 0x6ee89e3e, 0xc3175b40, 0x2a01a83c,
1346     0x95b1363a, 0xa079ad3d, 0xe6ca801f, 0x027f4f4a, 0x34f7f03a, 0xf790f04a, 0x16ca801f, 0x2f4d5e40,
1347     0x3a4d5e40, 0xc43a322e, 0xc8159753, 0x14d4724c, 0x7919a118, 0xe0bdb34e, 0x68a16b2e, 0xff64b44d,
1348     0x6099115b, 0x9b57b05b, 0x7bd1b4ad, 0xdf95944f, 0x29d2b73d, 0xafa8db79, 0xe247ba41, 0x24078348,
1349     0xf722f03c, 0x33567ebc, 0xace64ed4, 0x984d3932, 0xb5f34e55, 0x27b7024d, 0x94579247, 0x8894042e,
1350     0x9357d34c, 0x1063c24b, 0xcaa228b1, 0xa3c5a8b2, 0x5dc64857, 0xa2c23643, 0xa8369a54, 0x31203077,
1351     0x00707c5c, 0x09fc0b3a, 0x272e9e2e, 0xf80f043e, 0x9449ca3e, 0x5512c33e, 0xd106b555, 0xe8024157,
1352     0xe288ec29, 0xc79c5461, 0xafb63932, 0xdb02ab4b, 0x0e512777, 0x8a145a4c, 0xb201ff4f, 0x5e09314b,
1353     0xcd9bfbcd, 0x1c023765, 0x4394e75c, 0xa728bd4d, 0x65331552, 0xa98420b1, 0x89ecf559, 0x6e80801f,
1354     0xf404f118, 0xefd62b51, 0x05918346, 0x9b186d5f, 0xacabab46, 0xf912e255, 0xc188ea62, 0xcc55734e,
1355     0xc668064d, 0xd77a4558, 0x46201c55, 0xf17dfc80, 0xf7142f2e, 0x87bfb718, 0x8aa54fb2, 0xc451d518,
1356     0xc4ae8831, 0x8dd44d55, 0x5bbd206c, 0x64536b5d, 0x5c667e60, 0x3b064242, 0xfe963a42, 0xa28e6dc8,
1357     0xe8a9604a, 0xc989464e, 0xd124a659, 0x50065140, 0xa44dfe5e, 0x1079e655, 0x3fb986d5, 0x47895b18,
1358     0x7d3ce4ad, 0x4561ba50, 0x296eec62, 0x255b41ad, 0xaed35ec9, 0x55556f12, 0xc7d3154d, 0x3297b65d,
1359     0x8930121f, 0xabf42e4e, 0x4a29e044, 0x1212685d, 0x676c1e40, 0xce009744, 0x383a8948, 0xa2dbd0ad,
1360     0xecc2564d, 0x07dbc252, 0x887ee24b, 0x5171644c, 0x6bb798c1, 0x847f495d, 0x4cbb7145, 0x3bb81c32,
1361     0x45eb262e, 0xc8015a4e, 0x250a361b, 0xf694f946, 0xd64a183e, 0xd4f1dd59, 0x8f20ffd4, 0x51d9e55c,
1362     0x09521763, 0x5e02002e, 0x32c8074d, 0xe685762e, 0x8290b0bc, 0x762a922e, 0xfc5ee754, 0x83a24829,
1363     0x775b224d, 0x6295bb4d, 0x38ec0555, 0xbffbba50, 0xe5560260, 0x86b16a7c, 0xd372234e, 0x49a3c24b,
1364     0x2f6a171f, 0x4d75ed60, 0xae94115b, 0xcb543744, 0x63080c59, 0x3f9c724c, 0xc977ce18, 0x532efb18,
1365     0x69dc3b2e, 0x5f94d929, 0x1732bb4d, 0x9c814b4d, 0xe6b3762e, 0xc024f662, 0x8face35b, 0x6b5b044d,
1366     0x798c7b57, 0x79a6b44c, 0x067d3057, 0xf9e94e5f, 0x91cbe15b, 0x71405eb2, 0x2662234e, 0xcbcc4a6d,
1367     0xbf69d54b, 0xa79b4e55, 0xec6d3e51, 0x7c0b3c02, 0x60f83653, 0x24c1e15c, 0x1110b62e, 0x10350f59,
1368     0xa56f1d55, 0x3509e7a9, 0xeb128354, 0x14268e2e, 0x934e28bc, 0x8e32692e, 0x8331a21f, 0x3e633932,
1369     0xc812b12e, 0xc684bf2e, 0x80112d2e, 0xe0ddc96c, 0xc630ca4a, 0x5c09b3b2, 0x0b580518, 0xc8e9d54b,
1370     0xd169aa43, 0x17d0d655, 0x1d029963, 0x7ff87559, 0xcb701f1f, 0x6fa3e85d, 0xe45e9a54, 0xf05d1802,
1371     0x44d03b2e, 0x837b692e, 0xccd4354e, 0x3d6da13c, 0x3423084d, 0xf707c34a, 0x55f6db3a, 0xad26e442,
1372     0x6233a21f, 0x09e80e59, 0x8caeb54d, 0xbe870941, 0xb407d20e, 0x20b51018, 0x56fb152e, 0x460d2a4e,
1373     0xbb9a2946, 0x560eb12e, 0xed83dd29, 0xd6724f53, 0xa50aafb8, 0x451346d9, 0x88348e2e, 0x7312fead,
1374     0x8ecaf96f, 0x1bda4e5f, 0xf1671e40, 0x3c8c3e3b, 0x4716324d, 0xdde24ede, 0xf98cd17d, 0xa91d4644,
1375     0x28124eb2, 0x147d5129, 0xd022042e, 0x61733d3b, 0xad0d5e02, 0x8ce2932e, 0xe5c18502, 0x549c1e32,
1376     0x9685801f, 0x86e217ad, 0xd948214b, 0x4110f462, 0x3a2e894e, 0xbd35492e, 0x87e0d558, 0x64b8ef7d,
1377     0x7c3eb962, 0x72a84b3e, 0x7cd667c9, 0x28370a2e, 0x4bc60e7b, 0x6fc1ec60, 0x14a6983f, 0x86739a4b,
1378     0x46954e5f, 0x32e2e15c, 0x2e9326cf, 0xe5801c5e, 0x379607b2, 0x32151145, 0xf0e39744, 0xacb54c55,
1379     0xa37dfb60, 0x83b55cc9, 0x388f7ca5, 0x15034f5f, 0x3e94965b, 0x68e0ffad, 0x35280f59, 0x8fe190cf,
1380     0x7c6ba5b2, 0xa5e9db43, 0x4ee1fc60, 0xd9d94e5f, 0x04040677, 0x0ea9b35e, 0x5961f14f, 0x67fda063,
1381     0xa48a5a31, 0xc6524e55, 0x283d325e, 0x3f37515f, 0x96b94b3e, 0xacce620e, 0x6481cc5b, 0xa4a06d4b,
1382     0x9e95d2d9, 0xe40c03d5, 0xc2f4514b, 0xb79aad44, 0xf64be843, 0xb2064070, 0xfca00455, 0x429dfa4e,
1383     0x2323f173, 0xeda4185e, 0xabd5227d, 0x9efd4d58, 0xb1104758, 0x4811e955, 0xbd9ab355, 0xe921f44b,
1384     0x9f166dce, 0x09e279b2, 0xe0c9ac7b, 0x7901a5ad, 0xa145d4b0, 0x79104671, 0xec31e35a, 0x4fe0b555,
1385     0xc7d9cbad, 0xad057f55, 0xe94cc759, 0x7fe0b043, 0xe4529f2e, 0x0d4dd4b2, 0x9f11a54d, 0x031e2e4e,
1386     0xe6014f5f, 0x11d1ca6c, 0x26bd7f61, 0xeb86854f, 0x4d347b57, 0x116bbe2e, 0xdba7234e, 0x7bcbfd2e,
1387     0x174dd4b2, 0x6686762e, 0xb089ba50, 0xc6258246, 0x087e767b, 0xc4a8cb4a, 0x595dba50, 0x7f0ae502,
1388     0x7b1dbd5a, 0xa0603492, 0x57d1af4b, 0x9e21ffd4, 0x6393064d, 0x7407376e, 0xe484762e, 0x122a4e53,
1389     0x4a37aa43, 0x3888a6be, 0xee77864e, 0x039c8dd5, 0x688d89af, 0x0e988f62, 0x08218246, 0xfc2f8246,
1390     0xd1d97040, 0xd64cd4b2, 0x5ae4a6b8, 0x7d0de9bc, 0x8d304d61, 0x06c5c672, 0xa4c8bd4d, 0xe0fd373b,
1391     0x575ebe4d, 0x72d26277, 0x55570f55, 0x77b154d9, 0xe214293a, 0xfc740f4b, 0xfe3f6a57, 0xa9c55f02,
1392     0xae4054db, 0x2394d918, 0xb511b24a, 0xb8741ab2, 0x0758e65e, 0xc7b5795b, 0xb0a30a4c, 0xaf7f170c,
1393     0xf3b4762e, 0x8179576d, 0x738a1581, 0x4b95b64c, 0x9829b618, 0x1bea932e, 0x7bdeaa4b, 0xcb5e0281,
1394     0x65618f54, 0x0658474b, 0x27066acf, 0x40556d65, 0x7d204d53, 0xf28bc244, 0xdce23455, 0xadc0ff54,
1395     0x3863c948, 0xcee34e5f, 0xdeb85e02, 0x2ed17a61, 0x6a7b094d, 0x7f0cfc40, 0x59603f54, 0x3220afbc,
1396     0xb5dfd962, 0x125d21c0, 0x13f8d243, 0xacfefb4e, 0x86c2c147, 0x3d8bbd59, 0xbd02a21f, 0x2593042e,
1397     0xc6a17a7c, 0x28925861, 0xb487ed44, 0xb5f4fd6d, 0x90c28a45, 0x5a14f74d, 0x43d71b4c, 0x728ebb5d,
1398     0x885bf950, 0x08134dd0, 0x38ec046e, 0xc575684b, 0x50082d2e, 0xa2f47757, 0x270f86ae, 0xf3ff6462,
1399     0x10ed3f4e, 0x4b58d462, 0xe01ce23e, 0x8c5b092e, 0x63e52f4e, 0x22c1e85d, 0xa908f54e, 0x8591624f,
1400     0x2c0fb94e, 0xa280ba3c, 0xb6f41b4c, 0x24f9aa47, 0x27201647, 0x3a3ea6dc, 0xa14fc3be, 0x3c34bdd5,
1401     0x5b8d4f5b, 0xaadeaf4b, 0xc71cab50, 0x15697a4c, 0x9a1a734c, 0x2a037d81, 0x2590bd59, 0x48ec2741,
1402     0x53489c5b, 0x7f00314b, 0x2170d362, 0xf2e92542, 0x42c10b44, 0x98f0f118, 0x883a3456, 0x099a932e,
1403     0xea38f7bc, 0x644e9247, 0xbb61b62e, 0x30e0863d, 0x5f51be54, 0x207215c7, 0x5f306c45, 0xaa7f3932,
1404     0x98da7d45, 0x4e339b59, 0x2e411581, 0xa808f618, 0xad2c0c59, 0x54476741, 0x09e99fd1, 0x5db8f752,
1405     0xc16df8bd, 0x1dd4b44f, 0x106edf2e, 0x9e15c180, 0x2ad6b56f, 0x633a5332, 0xff33787c, 0x077cb545,
1406     0x6610be6d, 0x75aad2c4, 0x72fb4d5b, 0xe81e0f59, 0x576f6332, 0x47333373, 0x351ed783, 0x2d90fb50,
1407     0x8d5e0f6c, 0x5b27a552, 0xdb293ebb, 0xe55ef950, 0x4b133ad8, 0x75df975a, 0x7b6a8740, 0xa899464b,
1408     0xfab15161, 0x10f8b64d, 0xd055ea4d, 0xee8e146b, 0x4b14afb8, 0x4bc1c44a, 0x9b961dcc, 0xd111ff43,
1409     0xfca0b745, 0xc800e412, 0x0afad9d1, 0xf751c350, 0xf9f0cccf, 0xa290a545, 0x8ef13763, 0x7ec70d59,
1410     0x2b066acf, 0x65496c45, 0xade02c1b, 0xae6eb077, 0x92c1e65b, 0xc064e6a9, 0xc649e56d, 0x5287a243,
1411     0x36de4f5b, 0x5b1df6ad, 0x65c39a59, 0xdba805b2, 0x20067aa8, 0x6457e56d, 0x3cee26cf, 0xfd3ff26d,
1412     0x04f86d4a, 0x06b8e048, 0xa93bcd5c, 0x91135852, 0xbe90a643, 0x8fa0094d, 0x06d8215f, 0x2677094d,
1413     0xd735685c, 0x164a00c9, 0x5209ac5f, 0xa9564c5c, 0x3b504f5f, 0xcc826bd0, 0x4615042e, 0x5fe13b4a,
1414     0x8c81b86d, 0x879ab68c, 0x1de564b8, 0x434487d8, 0x2dcb1b63, 0x82ab524a, 0xb0676abb, 0xa13d9c62,
1415     0xdbb5b86d, 0x5b7f4b59, 0xaddfb44d, 0xad773532, 0x3997054c, 0x72cebd89, 0xb194544c, 0xc5b8046e,
1416     0x6e1adeb2, 0xaa5abb51, 0xefb54b44, 0x15efc54f, 0xe9f1bc4d, 0x5f401b6c, 0x97f018ad, 0xc82f9252,
1417     0x2cdc762e, 0x8e52e56d, 0x1827175e, 0x9b7d7d80, 0xb2ad6845, 0x51065140, 0x71180a18, 0x5b27006c,
1418     0x0621e255, 0x721cbe58, 0x670c0cb8, 0xf8bd715d, 0xe0bdc5d9, 0xed843501, 0x4b84554d, 0x7f1a18bc,
1419     0x53bcaf47, 0x5729d35f, 0xf0dda246, 0x22382bd0, 0x4d641fb0, 0x316afcde, 0x50a22f1f, 0x73608046,
1420     0xc461d84a, 0xb2dbe247,
1421 };
1422
1423
1424
1425 void ThreadOpenConnections(void* parg)
1426 {
1427     IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1428     try
1429     {
1430         vnThreadsRunning[1]++;
1431         ThreadOpenConnections2(parg);
1432         vnThreadsRunning[1]--;
1433     }
1434     catch (std::exception& e) {
1435         vnThreadsRunning[1]--;
1436         PrintException(&e, "ThreadOpenConnections()");
1437     } catch (...) {
1438         vnThreadsRunning[1]--;
1439         PrintException(NULL, "ThreadOpenConnections()");
1440     }
1441     printf("ThreadOpenConnections exiting\n");
1442 }
1443
1444 void ThreadOpenConnections2(void* parg)
1445 {
1446     printf("ThreadOpenConnections started\n");
1447
1448     // Connect to specific addresses
1449     if (mapArgs.count("-connect"))
1450     {
1451         for (int64 nLoop = 0;; nLoop++)
1452         {
1453             BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1454             {
1455                 CAddress addr(strAddr, fAllowDNS);
1456                 if (addr.IsValid())
1457                     OpenNetworkConnection(addr);
1458                 for (int i = 0; i < 10 && i < nLoop; i++)
1459                 {
1460                     Sleep(500);
1461                     if (fShutdown)
1462                         return;
1463                 }
1464             }
1465         }
1466     }
1467
1468     // Connect to manually added nodes first
1469     if (mapArgs.count("-addnode"))
1470     {
1471         BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1472         {
1473             CAddress addr(strAddr, fAllowDNS);
1474             if (addr.IsValid())
1475             {
1476                 OpenNetworkConnection(addr);
1477                 Sleep(500);
1478                 if (fShutdown)
1479                     return;
1480             }
1481         }
1482     }
1483
1484     // Initiate network connections
1485     int64 nStart = GetTime();
1486     loop
1487     {
1488         vnThreadsRunning[1]--;
1489         Sleep(500);
1490         vnThreadsRunning[1]++;
1491         if (fShutdown)
1492             return;
1493
1494         // Limit outbound connections
1495         loop
1496         {
1497             int nOutbound = 0;
1498             CRITICAL_BLOCK(cs_vNodes)
1499                 BOOST_FOREACH(CNode* pnode, vNodes)
1500                     if (!pnode->fInbound)
1501                         nOutbound++;
1502             int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1503             nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1504             if (nOutbound < nMaxOutboundConnections)
1505                 break;
1506             vnThreadsRunning[1]--;
1507             Sleep(2000);
1508             vnThreadsRunning[1]++;
1509             if (fShutdown)
1510                 return;
1511         }
1512
1513         bool fAddSeeds = false;
1514
1515         CRITICAL_BLOCK(cs_mapAddresses)
1516         {
1517             // Add seed nodes if IRC isn't working
1518             bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1519             if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
1520                 fAddSeeds = true;
1521         }
1522
1523         if (fAddSeeds)
1524         {
1525             for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
1526             {
1527                 // It'll only connect to one or two seed nodes because once it connects,
1528                 // it'll get a pile of addresses with newer timestamps.
1529                 // Seed nodes are given a random 'last seen time' of between one and two
1530                 // weeks ago.
1531                 const int64 nOneWeek = 7*24*60*60;
1532                 CAddress addr;
1533                 addr.ip = pnSeed[i];
1534                 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1535                 AddAddress(addr);
1536             }
1537         }
1538
1539         //
1540         // Choose an address to connect to based on most recently seen
1541         //
1542         CAddress addrConnect;
1543         int64 nBest = INT64_MIN;
1544
1545         // Only connect to one address per a.b.?.? range.
1546         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1547         set<unsigned int> setConnected;
1548         CRITICAL_BLOCK(cs_vNodes)
1549             BOOST_FOREACH(CNode* pnode, vNodes)
1550                 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1551
1552         int64 nANow = GetAdjustedTime();
1553
1554         CRITICAL_BLOCK(cs_mapAddresses)
1555         {
1556             BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1557             {
1558                 const CAddress& addr = item.second;
1559                 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1560                     continue;
1561                 int64 nSinceLastSeen = nANow - addr.nTime;
1562                 int64 nSinceLastTry = nANow - addr.nLastTry;
1563
1564                 // Randomize the order in a deterministic way, putting the standard port first
1565                 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1566                 if (addr.port != htons(GetDefaultPort()))
1567                     nRandomizer += 2 * 60 * 60;
1568
1569                 // Last seen  Base retry frequency
1570                 //   <1 hour   10 min
1571                 //    1 hour    1 hour
1572                 //    4 hours   2 hours
1573                 //   24 hours   5 hours
1574                 //   48 hours   7 hours
1575                 //    7 days   13 hours
1576                 //   30 days   27 hours
1577                 //   90 days   46 hours
1578                 //  365 days   93 hours
1579                 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1580
1581                 // Fast reconnect for one hour after last seen
1582                 if (nSinceLastSeen < 60 * 60)
1583                     nDelay = 10 * 60;
1584
1585                 // Limit retry frequency
1586                 if (nSinceLastTry < nDelay)
1587                     continue;
1588
1589                 // If we have IRC, we'll be notified when they first come online,
1590                 // and again every 24 hours by the refresh broadcast.
1591                 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1592                     continue;
1593
1594                 // Only try the old stuff if we don't have enough connections
1595                 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1596                     continue;
1597
1598                 // If multiple addresses are ready, prioritize by time since
1599                 // last seen and time since last tried.
1600                 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1601                 if (nScore > nBest)
1602                 {
1603                     nBest = nScore;
1604                     addrConnect = addr;
1605                 }
1606             }
1607         }
1608
1609         if (addrConnect.IsValid())
1610             OpenNetworkConnection(addrConnect);
1611     }
1612 }
1613
1614 bool OpenNetworkConnection(const CAddress& addrConnect)
1615 {
1616     //
1617     // Initiate outbound network connection
1618     //
1619     if (fShutdown)
1620         return false;
1621     if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
1622         FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
1623         return false;
1624
1625     vnThreadsRunning[1]--;
1626     CNode* pnode = ConnectNode(addrConnect);
1627     vnThreadsRunning[1]++;
1628     if (fShutdown)
1629         return false;
1630     if (!pnode)
1631         return false;
1632     pnode->fNetworkNode = true;
1633
1634     return true;
1635 }
1636
1637
1638
1639
1640
1641
1642
1643
1644 void ThreadMessageHandler(void* parg)
1645 {
1646     IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1647     try
1648     {
1649         vnThreadsRunning[2]++;
1650         ThreadMessageHandler2(parg);
1651         vnThreadsRunning[2]--;
1652     }
1653     catch (std::exception& e) {
1654         vnThreadsRunning[2]--;
1655         PrintException(&e, "ThreadMessageHandler()");
1656     } catch (...) {
1657         vnThreadsRunning[2]--;
1658         PrintException(NULL, "ThreadMessageHandler()");
1659     }
1660     printf("ThreadMessageHandler exiting\n");
1661 }
1662
1663 void ThreadMessageHandler2(void* parg)
1664 {
1665     printf("ThreadMessageHandler started\n");
1666     SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1667     while (!fShutdown)
1668     {
1669         vector<CNode*> vNodesCopy;
1670         CRITICAL_BLOCK(cs_vNodes)
1671         {
1672             vNodesCopy = vNodes;
1673             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1674                 pnode->AddRef();
1675         }
1676
1677         // Poll the connected nodes for messages
1678         CNode* pnodeTrickle = NULL;
1679         if (!vNodesCopy.empty())
1680             pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1681         BOOST_FOREACH(CNode* pnode, vNodesCopy)
1682         {
1683             // Receive messages
1684             TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1685                 ProcessMessages(pnode);
1686             if (fShutdown)
1687                 return;
1688
1689             // Send messages
1690             TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1691                 SendMessages(pnode, pnode == pnodeTrickle);
1692             if (fShutdown)
1693                 return;
1694         }
1695
1696         CRITICAL_BLOCK(cs_vNodes)
1697         {
1698             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1699                 pnode->Release();
1700         }
1701
1702         // Wait and allow messages to bunch up.
1703         // Reduce vnThreadsRunning so StopNode has permission to exit while
1704         // we're sleeping, but we must always check fShutdown after doing this.
1705         vnThreadsRunning[2]--;
1706         Sleep(100);
1707         if (fRequestShutdown)
1708             StartShutdown();
1709         vnThreadsRunning[2]++;
1710         if (fShutdown)
1711             return;
1712     }
1713 }
1714
1715
1716
1717
1718
1719
1720 bool BindListenPort(string& strError)
1721 {
1722     strError = "";
1723     int nOne = 1;
1724     addrLocalHost.port = htons(GetListenPort());
1725
1726 #ifdef WIN32
1727     // Initialize Windows Sockets
1728     WSADATA wsadata;
1729     int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1730     if (ret != NO_ERROR)
1731     {
1732         strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1733         printf("%s\n", strError.c_str());
1734         return false;
1735     }
1736 #endif
1737
1738     // Create socket for listening for incoming connections
1739     hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1740     if (hListenSocket == INVALID_SOCKET)
1741     {
1742         strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1743         printf("%s\n", strError.c_str());
1744         return false;
1745     }
1746
1747 #ifdef SO_NOSIGPIPE
1748     // Different way of disabling SIGPIPE on BSD
1749     setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1750 #endif
1751
1752 #ifndef WIN32
1753     // Allow binding if the port is still in TIME_WAIT state after
1754     // the program was closed and restarted.  Not an issue on windows.
1755     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1756 #endif
1757
1758 #ifdef WIN32
1759     // Set to nonblocking, incoming connections will also inherit this
1760     if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1761 #else
1762     if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1763 #endif
1764     {
1765         strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1766         printf("%s\n", strError.c_str());
1767         return false;
1768     }
1769
1770     // The sockaddr_in structure specifies the address family,
1771     // IP address, and port for the socket that is being bound
1772     struct sockaddr_in sockaddr;
1773     memset(&sockaddr, 0, sizeof(sockaddr));
1774     sockaddr.sin_family = AF_INET;
1775     sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1776     sockaddr.sin_port = htons(GetListenPort());
1777     if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1778     {
1779         int nErr = WSAGetLastError();
1780         if (nErr == WSAEADDRINUSE)
1781             strError = strprintf(_("Unable to bind to port %d on this computer.  Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1782         else
1783             strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1784         printf("%s\n", strError.c_str());
1785         return false;
1786     }
1787     printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1788
1789     // Listen for incoming connections
1790     if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1791     {
1792         strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1793         printf("%s\n", strError.c_str());
1794         return false;
1795     }
1796
1797     return true;
1798 }
1799
1800 void StartNode(void* parg)
1801 {
1802     if (pnodeLocalHost == NULL)
1803         pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1804
1805 #ifdef WIN32
1806     // Get local host ip
1807     char pszHostName[1000] = "";
1808     if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1809     {
1810         vector<CAddress> vaddr;
1811         if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1812             BOOST_FOREACH (const CAddress &addr, vaddr)
1813                 if (addr.GetByte(3) != 127)
1814                 {
1815                     addrLocalHost = addr;
1816                     break;
1817                 }
1818     }
1819 #else
1820     // Get local host ip
1821     struct ifaddrs* myaddrs;
1822     if (getifaddrs(&myaddrs) == 0)
1823     {
1824         for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1825         {
1826             if (ifa->ifa_addr == NULL) continue;
1827             if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1828             if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1829             if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1830             char pszIP[100];
1831             if (ifa->ifa_addr->sa_family == AF_INET)
1832             {
1833                 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1834                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1835                     printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1836
1837                 // Take the first IP that isn't loopback 127.x.x.x
1838                 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1839                 if (addr.IsValid() && addr.GetByte(3) != 127)
1840                 {
1841                     addrLocalHost = addr;
1842                     break;
1843                 }
1844             }
1845             else if (ifa->ifa_addr->sa_family == AF_INET6)
1846             {
1847                 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1848                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1849                     printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1850             }
1851         }
1852         freeifaddrs(myaddrs);
1853     }
1854 #endif
1855     printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1856
1857     if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1858     {
1859         // Proxies can't take incoming connections
1860         addrLocalHost.ip = CAddress("0.0.0.0").ip;
1861         printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1862     }
1863     else
1864     {
1865         CreateThread(ThreadGetMyExternalIP, NULL);
1866     }
1867
1868     //
1869     // Start threads
1870     //
1871
1872     if (GetBoolArg("-nodnsseed"))
1873         printf("DNS seeding disabled\n");
1874     else
1875         if (!CreateThread(ThreadDNSAddressSeed, NULL))
1876             printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1877
1878     // Map ports with UPnP
1879     if (fHaveUPnP)
1880         MapPort(fUseUPnP);
1881
1882     // Get addresses from IRC and advertise ours
1883     if (!CreateThread(ThreadIRCSeed, NULL))
1884         printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1885
1886     // Send and receive from sockets, accept connections
1887     if (!CreateThread(ThreadSocketHandler, NULL))
1888         printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1889
1890     // Initiate outbound connections
1891     if (!CreateThread(ThreadOpenConnections, NULL))
1892         printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1893
1894     // Process messages
1895     if (!CreateThread(ThreadMessageHandler, NULL))
1896         printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1897
1898     // Generate coins in the background
1899     GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1900 }
1901
1902 bool StopNode()
1903 {
1904     printf("StopNode()\n");
1905     fShutdown = true;
1906     nTransactionsUpdated++;
1907     int64 nStart = GetTime();
1908     while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1909 #ifdef USE_UPNP
1910         || vnThreadsRunning[5] > 0
1911 #endif
1912     )
1913     {
1914         if (GetTime() - nStart > 20)
1915             break;
1916         Sleep(20);
1917     }
1918     if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1919     if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1920     if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1921     if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1922     if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1923     if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1924     if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1925     while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1926         Sleep(20);
1927     Sleep(50);
1928
1929     return true;
1930 }
1931
1932 class CNetCleanup
1933 {
1934 public:
1935     CNetCleanup()
1936     {
1937     }
1938     ~CNetCleanup()
1939     {
1940         // Close sockets
1941         BOOST_FOREACH(CNode* pnode, vNodes)
1942             if (pnode->hSocket != INVALID_SOCKET)
1943                 closesocket(pnode->hSocket);
1944         if (hListenSocket != INVALID_SOCKET)
1945             if (closesocket(hListenSocket) == SOCKET_ERROR)
1946                 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1947
1948 #ifdef WIN32
1949         // Shutdown Windows Sockets
1950         WSACleanup();
1951 #endif
1952     }
1953 }
1954 instance_of_cnetcleanup;