src/net.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Distributed under the MIT/X11 software license, see the accompanying
   3 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "headers.h"
   6 #include "irc.h"
   7 #include "db.h"
   8 #include "net.h"
   9 #include "init.h"
  10 #include "strlcpy.h"
  11
  12 #ifdef USE_UPNP
  13 #include <miniupnpc/miniwget.h>
  14 #include <miniupnpc/miniupnpc.h>
  15 #include <miniupnpc/upnpcommands.h>
  16 #include <miniupnpc/upnperrors.h>
  17 #endif
  18
  19 using namespace std;
  20 using namespace boost;
  21
  22 static const int MAX_OUTBOUND_CONNECTIONS = 8;
  23
  24 void ThreadMessageHandler2(void* parg);
  25 void ThreadSocketHandler2(void* parg);
  26 void ThreadOpenConnections2(void* parg);
  27 #ifdef USE_UPNP
  28 void ThreadMapPort2(void* parg);
  29 #endif
  30 bool OpenNetworkConnection(const CAddress& addrConnect);
  31
  32
  33
  34
  35
  36 //
  37 // Global state variables
  38 //
  39 bool fClient = false;
  40 bool fAllowDNS = false;
  41 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
  42 CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
  43 CNode* pnodeLocalHost = NULL;
  44 uint64 nLocalHostNonce = 0;
  45 array<int, 10> vnThreadsRunning;
  46 SOCKET hListenSocket = INVALID_SOCKET;
  47
  48 vector<CNode*> vNodes;
  49 CCriticalSection cs_vNodes;
  50 map<vector<unsigned char>, CAddress> mapAddresses;
  51 CCriticalSection cs_mapAddresses;
  52 map<CInv, CDataStream> mapRelay;
  53 deque<pair<int64, CInv> > vRelayExpiration;
  54 CCriticalSection cs_mapRelay;
  55 map<CInv, int64> mapAlreadyAskedFor;
  56
  57 // Settings
  58 int fUseProxy = false;
  59 int nConnectTimeout = 5000;
  60 CAddress addrProxy("127.0.0.1",9050);
  61
  62
  63
  64
  65 unsigned short GetListenPort()
  66 {
  67     return (unsigned short)(GetArg("-port", GetDefaultPort()));
  68 }
  69
  70 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
  71 {
  72     // Filter out duplicate requests
  73     if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
  74         return;
  75     pindexLastGetBlocksBegin = pindexBegin;
  76     hashLastGetBlocksEnd = hashEnd;
  77
  78     PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
  79 }
  80
  81
  82
  83
  84
  85 bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
  86 {
  87     hSocketRet = INVALID_SOCKET;
  88
  89     SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  90     if (hSocket == INVALID_SOCKET)
  91         return false;
  92 #ifdef BSD
  93     int set = 1;
  94     setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
  95 #endif
  96
  97     bool fProxy = (fUseProxy && addrConnect.IsRoutable());
  98     struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
  99
 100 #ifdef __WXMSW__
 101     u_long fNonblock = 1;
 102     if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
 103 #else
 104     int fFlags = fcntl(hSocket, F_GETFL, 0);
 105     if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
 106 #endif
 107     {
 108         closesocket(hSocket);
 109         return false;
 110     }
 111
 112
 113     if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
 114     {
 115         // WSAEINVAL is here because some legacy version of winsock uses it
 116         if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
 117         {
 118             struct timeval timeout;
 119             timeout.tv_sec  = nTimeout / 1000;
 120             timeout.tv_usec = (nTimeout % 1000) * 1000;
 121
 122             fd_set fdset;
 123             FD_ZERO(&fdset);
 124             FD_SET(hSocket, &fdset);
 125             int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
 126             if (nRet == 0)
 127             {
 128                 printf("connection timeout\n");
 129                 closesocket(hSocket);
 130                 return false;
 131             }
 132             if (nRet == SOCKET_ERROR)
 133             {
 134                 printf("select() for connection failed: %i\n",WSAGetLastError());
 135                 closesocket(hSocket);
 136                 return false;
 137             }
 138             socklen_t nRetSize = sizeof(nRet);
 139 #ifdef __WXMSW__
 140             if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
 141 #else
 142             if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
 143 #endif
 144             {
 145                 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
 146                 closesocket(hSocket);
 147                 return false;
 148             }
 149             if (nRet != 0)
 150             {
 151                 printf("connect() failed after select(): %i\n",nRet);
 152                 closesocket(hSocket);
 153                 return false;
 154             }
 155         }
 156 #ifdef __WXMSW__
 157         else if (WSAGetLastError() != WSAEISCONN)
 158 #else
 159         else
 160 #endif
 161         {
 162             printf("connect() failed: %i\n",WSAGetLastError());
 163             closesocket(hSocket);
 164             return false;
 165         }
 166     }
 167
 168     /*
 169     this isn't even strictly necessary
 170     CNode::ConnectNode immediately turns the socket back to non-blocking
 171     but we'll turn it back to blocking just in case
 172     */
 173 #ifdef __WXMSW__
 174     fNonblock = 0;
 175     if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
 176 #else
 177     fFlags = fcntl(hSocket, F_GETFL, 0);
 178     if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
 179 #endif
 180     {
 181         closesocket(hSocket);
 182         return false;
 183     }
 184
 185     if (fProxy)
 186     {
 187         printf("proxy connecting %s\n", addrConnect.ToString().c_str());
 188         char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
 189         memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
 190         memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
 191         char* pszSocks4 = pszSocks4IP;
 192         int nSize = sizeof(pszSocks4IP);
 193
 194         int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
 195         if (ret != nSize)
 196         {
 197             closesocket(hSocket);
 198             return error("Error sending to proxy");
 199         }
 200         char pchRet[8];
 201         if (recv(hSocket, pchRet, 8, 0) != 8)
 202         {
 203             closesocket(hSocket);
 204             return error("Error reading proxy response");
 205         }
 206         if (pchRet[1] != 0x5a)
 207         {
 208             closesocket(hSocket);
 209             if (pchRet[1] != 0x5b)
 210                 printf("ERROR: Proxy returned error %d\n", pchRet[1]);
 211             return false;
 212         }
 213         printf("proxy connected %s\n", addrConnect.ToString().c_str());
 214     }
 215
 216     hSocketRet = hSocket;
 217     return true;
 218 }
 219
 220 // portDefault is in host order
 221 bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
 222 {
 223     vaddr.clear();
 224     if (pszName[0] == 0)
 225         return false;
 226     int port = portDefault;
 227     char psz[256];
 228     char *pszHost = psz;
 229     strlcpy(psz, pszName, sizeof(psz));
 230     if (fAllowPort)
 231     {
 232         char* pszColon = strrchr(psz+1,':');
 233         char *pszPortEnd = NULL;
 234         int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
 235         if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
 236         {
 237             if (psz[0] == '[' && pszColon[-1] == ']')
 238             {
 239                 // Future: enable IPv6 colon-notation inside []
 240                 pszHost = psz+1;
 241                 pszColon[-1] = 0;
 242             }
 243             else
 244                 pszColon[0] = 0;
 245             port = portParsed;
 246             if (port < 0 || port > USHRT_MAX)
 247                 port = USHRT_MAX;
 248         }
 249     }
 250
 251     unsigned int addrIP = inet_addr(pszHost);
 252     if (addrIP != INADDR_NONE)
 253     {
 254         // valid IP address passed
 255         vaddr.push_back(CAddress(addrIP, port, nServices));
 256         return true;
 257     }
 258
 259     if (!fAllowLookup)
 260         return false;
 261
 262     struct hostent* phostent = gethostbyname(pszHost);
 263     if (!phostent)
 264         return false;
 265
 266     if (phostent->h_addrtype != AF_INET)
 267         return false;
 268
 269     char** ppAddr = phostent->h_addr_list;
 270     while (*ppAddr != NULL && vaddr.size() != nMaxSolutions)
 271     {
 272         CAddress addr(((struct in_addr*)ppAddr[0])->s_addr, port, nServices);
 273         if (addr.IsValid())
 274             vaddr.push_back(addr);
 275         ppAddr++;
 276     }
 277
 278     return (vaddr.size() > 0);
 279 }
 280
 281 // portDefault is in host order
 282 bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup, int portDefault, bool fAllowPort)
 283 {
 284     vector<CAddress> vaddr;
 285     bool fRet = Lookup(pszName, vaddr, nServices, 1, fAllowLookup, portDefault, fAllowPort);
 286     if (fRet)
 287         addr = vaddr[0];
 288     return fRet;
 289 }
 290
 291 bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet)
 292 {
 293     SOCKET hSocket;
 294     if (!ConnectSocket(addrConnect, hSocket))
 295         return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
 296
 297     send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
 298
 299     string strLine;
 300     while (RecvLine(hSocket, strLine))
 301     {
 302         if (strLine.empty()) // HTTP response is separated from headers by blank line
 303         {
 304             loop
 305             {
 306                 if (!RecvLine(hSocket, strLine))
 307                 {
 308                     closesocket(hSocket);
 309                     return false;
 310                 }
 311                 if (pszKeyword == NULL)
 312                     break;
 313                 if (strLine.find(pszKeyword) != -1)
 314                 {
 315                     strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
 316                     break;
 317                 }
 318             }
 319             closesocket(hSocket);
 320             if (strLine.find("<") != -1)
 321                 strLine = strLine.substr(0, strLine.find("<"));
 322             strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
 323             while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
 324                 strLine.resize(strLine.size()-1);
 325             CAddress addr(strLine,0,true);
 326             printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
 327             if (addr.ip == 0 || addr.ip == INADDR_NONE || !addr.IsRoutable())
 328                 return false;
 329             ipRet = addr.ip;
 330             return true;
 331         }
 332     }
 333     closesocket(hSocket);
 334     return error("GetMyExternalIP() : connection closed");
 335 }
 336
 337 // We now get our external IP from the IRC server first and only use this as a backup
 338 bool GetMyExternalIP(unsigned int& ipRet)
 339 {
 340     CAddress addrConnect;
 341     const char* pszGet;
 342     const char* pszKeyword;
 343
 344     if (fUseProxy)
 345         return false;
 346
 347     for (int nLookup = 0; nLookup <= 1; nLookup++)
 348     for (int nHost = 1; nHost <= 2; nHost++)
 349     {
 350         // We should be phasing out our use of sites like these.  If we need
 351         // replacements, we should ask for volunteers to put this simple
 352         // php file on their webserver that prints the client IP:
 353         //  <?php echo $_SERVER["REMOTE_ADDR"]; ?>
 354         if (nHost == 1)
 355         {
 356             addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
 357
 358             if (nLookup == 1)
 359             {
 360                 CAddress addrIP("checkip.dyndns.org", 80, true);
 361                 if (addrIP.IsValid())
 362                     addrConnect = addrIP;
 363             }
 364
 365             pszGet = "GET / HTTP/1.1\r\n"
 366                      "Host: checkip.dyndns.org\r\n"
 367                      "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
 368                      "Connection: close\r\n"
 369                      "\r\n";
 370
 371             pszKeyword = "Address:";
 372         }
 373         else if (nHost == 2)
 374         {
 375             addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
 376
 377             if (nLookup == 1)
 378             {
 379                 CAddress addrIP("www.showmyip.com", 80, true);
 380                 if (addrIP.IsValid())
 381                     addrConnect = addrIP;
 382             }
 383
 384             pszGet = "GET /simple/ HTTP/1.1\r\n"
 385                      "Host: www.showmyip.com\r\n"
 386                      "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
 387                      "Connection: close\r\n"
 388                      "\r\n";
 389
 390             pszKeyword = NULL; // Returns just IP address
 391         }
 392
 393         if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
 394             return true;
 395     }
 396
 397     return false;
 398 }
 399
 400 void ThreadGetMyExternalIP(void* parg)
 401 {
 402     // Wait for IRC to get it first
 403     if (!GetBoolArg("-noirc"))
 404     {
 405         for (int i = 0; i < 2 * 60; i++)
 406         {
 407             Sleep(1000);
 408             if (fGotExternalIP || fShutdown)
 409                 return;
 410         }
 411     }
 412
 413     // Fallback in case IRC fails to get it
 414     if (GetMyExternalIP(addrLocalHost.ip))
 415     {
 416         printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
 417         if (addrLocalHost.IsRoutable())
 418         {
 419             // If we already connected to a few before we had our IP, go back and addr them.
 420             // setAddrKnown automatically filters any duplicate sends.
 421             CAddress addr(addrLocalHost);
 422             addr.nTime = GetAdjustedTime();
 423             CRITICAL_BLOCK(cs_vNodes)
 424                 BOOST_FOREACH(CNode* pnode, vNodes)
 425                     pnode->PushAddress(addr);
 426         }
 427     }
 428 }
 429
 430
 431
 432
 433
 434 bool AddAddress(CAddress addr, int64 nTimePenalty)
 435 {
 436     if (!addr.IsRoutable())
 437         return false;
 438     if (addr.ip == addrLocalHost.ip)
 439         return false;
 440     addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
 441     CRITICAL_BLOCK(cs_mapAddresses)
 442     {
 443         map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
 444         if (it == mapAddresses.end())
 445         {
 446             // New address
 447             printf("AddAddress(%s)\n", addr.ToString().c_str());
 448             mapAddresses.insert(make_pair(addr.GetKey(), addr));
 449             CAddrDB().WriteAddress(addr);
 450             return true;
 451         }
 452         else
 453         {
 454             bool fUpdated = false;
 455             CAddress& addrFound = (*it).second;
 456             if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
 457             {
 458                 // Services have been added
 459                 addrFound.nServices |= addr.nServices;
 460                 fUpdated = true;
 461             }
 462             bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
 463             int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
 464             if (addrFound.nTime < addr.nTime - nUpdateInterval)
 465             {
 466                 // Periodically update most recently seen time
 467                 addrFound.nTime = addr.nTime;
 468                 fUpdated = true;
 469             }
 470             if (fUpdated)
 471                 CAddrDB().WriteAddress(addrFound);
 472         }
 473     }
 474     return false;
 475 }
 476
 477 void AddressCurrentlyConnected(const CAddress& addr)
 478 {
 479     CRITICAL_BLOCK(cs_mapAddresses)
 480     {
 481         // Only if it's been published already
 482         map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
 483         if (it != mapAddresses.end())
 484         {
 485             CAddress& addrFound = (*it).second;
 486             int64 nUpdateInterval = 20 * 60;
 487             if (addrFound.nTime < GetAdjustedTime() - nUpdateInterval)
 488             {
 489                 // Periodically update most recently seen time
 490                 addrFound.nTime = GetAdjustedTime();
 491                 CAddrDB addrdb;
 492                 addrdb.WriteAddress(addrFound);
 493             }
 494         }
 495     }
 496 }
 497
 498
 499
 500
 501
 502 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
 503 {
 504     // If the dialog might get closed before the reply comes back,
 505     // call this in the destructor so it doesn't get called after it's deleted.
 506     CRITICAL_BLOCK(cs_vNodes)
 507     {
 508         BOOST_FOREACH(CNode* pnode, vNodes)
 509         {
 510             CRITICAL_BLOCK(pnode->cs_mapRequests)
 511             {
 512                 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
 513                 {
 514                     CRequestTracker& tracker = (*mi).second;
 515                     if (tracker.fn == fn && tracker.param1 == param1)
 516                         pnode->mapRequests.erase(mi++);
 517                     else
 518                         mi++;
 519                 }
 520             }
 521         }
 522     }
 523 }
 524
 525
 526
 527
 528
 529
 530
 531 //
 532 // Subscription methods for the broadcast and subscription system.
 533 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
 534 //
 535 // The subscription system uses a meet-in-the-middle strategy.
 536 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
 537 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
 538 //
 539
 540 bool AnySubscribed(unsigned int nChannel)
 541 {
 542     if (pnodeLocalHost->IsSubscribed(nChannel))
 543         return true;
 544     CRITICAL_BLOCK(cs_vNodes)
 545         BOOST_FOREACH(CNode* pnode, vNodes)
 546             if (pnode->IsSubscribed(nChannel))
 547                 return true;
 548     return false;
 549 }
 550
 551 bool CNode::IsSubscribed(unsigned int nChannel)
 552 {
 553     if (nChannel >= vfSubscribe.size())
 554         return false;
 555     return vfSubscribe[nChannel];
 556 }
 557
 558 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
 559 {
 560     if (nChannel >= vfSubscribe.size())
 561         return;
 562
 563     if (!AnySubscribed(nChannel))
 564     {
 565         // Relay subscribe
 566         CRITICAL_BLOCK(cs_vNodes)
 567             BOOST_FOREACH(CNode* pnode, vNodes)
 568                 if (pnode != this)
 569                     pnode->PushMessage("subscribe", nChannel, nHops);
 570     }
 571
 572     vfSubscribe[nChannel] = true;
 573 }
 574
 575 void CNode::CancelSubscribe(unsigned int nChannel)
 576 {
 577     if (nChannel >= vfSubscribe.size())
 578         return;
 579
 580     // Prevent from relaying cancel if wasn't subscribed
 581     if (!vfSubscribe[nChannel])
 582         return;
 583     vfSubscribe[nChannel] = false;
 584
 585     if (!AnySubscribed(nChannel))
 586     {
 587         // Relay subscription cancel
 588         CRITICAL_BLOCK(cs_vNodes)
 589             BOOST_FOREACH(CNode* pnode, vNodes)
 590                 if (pnode != this)
 591                     pnode->PushMessage("sub-cancel", nChannel);
 592     }
 593 }
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603 CNode* FindNode(unsigned int ip)
 604 {
 605     CRITICAL_BLOCK(cs_vNodes)
 606     {
 607         BOOST_FOREACH(CNode* pnode, vNodes)
 608             if (pnode->addr.ip == ip)
 609                 return (pnode);
 610     }
 611     return NULL;
 612 }
 613
 614 CNode* FindNode(CAddress addr)
 615 {
 616     CRITICAL_BLOCK(cs_vNodes)
 617     {
 618         BOOST_FOREACH(CNode* pnode, vNodes)
 619             if (pnode->addr == addr)
 620                 return (pnode);
 621     }
 622     return NULL;
 623 }
 624
 625 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
 626 {
 627     if (addrConnect.ip == addrLocalHost.ip)
 628         return NULL;
 629
 630     // Look for an existing connection
 631     CNode* pnode = FindNode(addrConnect.ip);
 632     if (pnode)
 633     {
 634         if (nTimeout != 0)
 635             pnode->AddRef(nTimeout);
 636         else
 637             pnode->AddRef();
 638         return pnode;
 639     }
 640
 641     /// debug print
 642     printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
 643         addrConnect.ToString().c_str(),
 644         (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
 645         (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
 646
 647     CRITICAL_BLOCK(cs_mapAddresses)
 648         mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
 649
 650     // Connect
 651     SOCKET hSocket;
 652     if (ConnectSocket(addrConnect, hSocket))
 653     {
 654         /// debug print
 655         printf("connected %s\n", addrConnect.ToString().c_str());
 656
 657         // Set to nonblocking
 658 #ifdef __WXMSW__
 659         u_long nOne = 1;
 660         if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
 661             printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
 662 #else
 663         if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
 664             printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
 665 #endif
 666
 667         // Add node
 668         CNode* pnode = new CNode(hSocket, addrConnect, false);
 669         if (nTimeout != 0)
 670             pnode->AddRef(nTimeout);
 671         else
 672             pnode->AddRef();
 673         CRITICAL_BLOCK(cs_vNodes)
 674             vNodes.push_back(pnode);
 675
 676         pnode->nTimeConnected = GetTime();
 677         return pnode;
 678     }
 679     else
 680     {
 681         return NULL;
 682     }
 683 }
 684
 685 void CNode::CloseSocketDisconnect()
 686 {
 687     fDisconnect = true;
 688     if (hSocket != INVALID_SOCKET)
 689     {
 690         if (fDebug)
 691             printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
 692         printf("disconnecting node %s\n", addr.ToString().c_str());
 693         closesocket(hSocket);
 694         hSocket = INVALID_SOCKET;
 695     }
 696 }
 697
 698 void CNode::Cleanup()
 699 {
 700     // All of a nodes broadcasts and subscriptions are automatically torn down
 701     // when it goes down, so a node has to stay up to keep its broadcast going.
 702
 703     // Cancel subscriptions
 704     for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
 705         if (vfSubscribe[nChannel])
 706             CancelSubscribe(nChannel);
 707 }
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721 void ThreadSocketHandler(void* parg)
 722 {
 723     IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
 724     try
 725     {
 726         vnThreadsRunning[0]++;
 727         ThreadSocketHandler2(parg);
 728         vnThreadsRunning[0]--;
 729     }
 730     catch (std::exception& e) {
 731         vnThreadsRunning[0]--;
 732         PrintException(&e, "ThreadSocketHandler()");
 733     } catch (...) {
 734         vnThreadsRunning[0]--;
 735         throw; // support pthread_cancel()
 736     }
 737     printf("ThreadSocketHandler exiting\n");
 738 }
 739
 740 void ThreadSocketHandler2(void* parg)
 741 {
 742     printf("ThreadSocketHandler started\n");
 743     list<CNode*> vNodesDisconnected;
 744     int nPrevNodeCount = 0;
 745
 746     loop
 747     {
 748         //
 749         // Disconnect nodes
 750         //
 751         CRITICAL_BLOCK(cs_vNodes)
 752         {
 753             // Disconnect unused nodes
 754             vector<CNode*> vNodesCopy = vNodes;
 755             BOOST_FOREACH(CNode* pnode, vNodesCopy)
 756             {
 757                 if (pnode->fDisconnect ||
 758                     (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
 759                 {
 760                     // remove from vNodes
 761                     vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
 762
 763                     // close socket and cleanup
 764                     pnode->CloseSocketDisconnect();
 765                     pnode->Cleanup();
 766
 767                     // hold in disconnected pool until all refs are released
 768                     pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
 769                     if (pnode->fNetworkNode || pnode->fInbound)
 770                         pnode->Release();
 771                     vNodesDisconnected.push_back(pnode);
 772                 }
 773             }
 774
 775             // Delete disconnected nodes
 776             list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
 777             BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
 778             {
 779                 // wait until threads are done using it
 780                 if (pnode->GetRefCount() <= 0)
 781                 {
 782                     bool fDelete = false;
 783                     TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 784                      TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
 785                       TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
 786                        TRY_CRITICAL_BLOCK(pnode->cs_inventory)
 787                         fDelete = true;
 788                     if (fDelete)
 789                     {
 790                         vNodesDisconnected.remove(pnode);
 791                         delete pnode;
 792                     }
 793                 }
 794             }
 795         }
 796         if (vNodes.size() != nPrevNodeCount)
 797         {
 798             nPrevNodeCount = vNodes.size();
 799             MainFrameRepaint();
 800         }
 801
 802
 803         //
 804         // Find which sockets have data to receive
 805         //
 806         struct timeval timeout;
 807         timeout.tv_sec  = 0;
 808         timeout.tv_usec = 50000; // frequency to poll pnode->vSend
 809
 810         fd_set fdsetRecv;
 811         fd_set fdsetSend;
 812         fd_set fdsetError;
 813         FD_ZERO(&fdsetRecv);
 814         FD_ZERO(&fdsetSend);
 815         FD_ZERO(&fdsetError);
 816         SOCKET hSocketMax = 0;
 817
 818         if(hListenSocket != INVALID_SOCKET)
 819             FD_SET(hListenSocket, &fdsetRecv);
 820         hSocketMax = max(hSocketMax, hListenSocket);
 821         CRITICAL_BLOCK(cs_vNodes)
 822         {
 823             BOOST_FOREACH(CNode* pnode, vNodes)
 824             {
 825                 if (pnode->hSocket == INVALID_SOCKET || pnode->hSocket < 0)
 826                     continue;
 827                 FD_SET(pnode->hSocket, &fdsetRecv);
 828                 FD_SET(pnode->hSocket, &fdsetError);
 829                 hSocketMax = max(hSocketMax, pnode->hSocket);
 830                 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 831                     if (!pnode->vSend.empty())
 832                         FD_SET(pnode->hSocket, &fdsetSend);
 833             }
 834         }
 835
 836         vnThreadsRunning[0]--;
 837         int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
 838         vnThreadsRunning[0]++;
 839         if (fShutdown)
 840             return;
 841         if (nSelect == SOCKET_ERROR)
 842         {
 843             int nErr = WSAGetLastError();
 844             if (hSocketMax > -1)
 845             {
 846                 printf("socket select error %d\n", nErr);
 847                 for (int i = 0; i <= hSocketMax; i++)
 848                     FD_SET(i, &fdsetRecv);
 849             }
 850             FD_ZERO(&fdsetSend);
 851             FD_ZERO(&fdsetError);
 852             Sleep(timeout.tv_usec/1000);
 853         }
 854
 855
 856         //
 857         // Accept new connections
 858         //
 859         if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
 860         {
 861             struct sockaddr_in sockaddr;
 862             socklen_t len = sizeof(sockaddr);
 863             SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
 864             CAddress addr(sockaddr);
 865             int nInbound = 0;
 866
 867             CRITICAL_BLOCK(cs_vNodes)
 868                 BOOST_FOREACH(CNode* pnode, vNodes)
 869                 if (pnode->fInbound)
 870                     nInbound++;
 871             if (hSocket == INVALID_SOCKET)
 872             {
 873                 if (WSAGetLastError() != WSAEWOULDBLOCK)
 874                     printf("socket error accept failed: %d\n", WSAGetLastError());
 875             }
 876             else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
 877             {
 878                 closesocket(hSocket);
 879             }
 880             else
 881             {
 882                 printf("accepted connection %s\n", addr.ToString().c_str());
 883                 CNode* pnode = new CNode(hSocket, addr, true);
 884                 pnode->AddRef();
 885                 CRITICAL_BLOCK(cs_vNodes)
 886                     vNodes.push_back(pnode);
 887             }
 888         }
 889
 890
 891         //
 892         // Service each socket
 893         //
 894         vector<CNode*> vNodesCopy;
 895         CRITICAL_BLOCK(cs_vNodes)
 896         {
 897             vNodesCopy = vNodes;
 898             BOOST_FOREACH(CNode* pnode, vNodesCopy)
 899                 pnode->AddRef();
 900         }
 901         BOOST_FOREACH(CNode* pnode, vNodesCopy)
 902         {
 903             if (fShutdown)
 904                 return;
 905
 906             //
 907             // Receive
 908             //
 909             if (pnode->hSocket == INVALID_SOCKET)
 910                 continue;
 911             if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
 912             {
 913                 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
 914                 {
 915                     CDataStream& vRecv = pnode->vRecv;
 916                     unsigned int nPos = vRecv.size();
 917
 918                     if (nPos > ReceiveBufferSize()) {
 919                         if (!pnode->fDisconnect)
 920                             printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
 921                         pnode->CloseSocketDisconnect();
 922                     }
 923                     else {
 924                         // typical socket buffer is 8K-64K
 925                         char pchBuf[0x10000];
 926                         int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
 927                         if (nBytes > 0)
 928                         {
 929                             vRecv.resize(nPos + nBytes);
 930                             memcpy(&vRecv[nPos], pchBuf, nBytes);
 931                             pnode->nLastRecv = GetTime();
 932                         }
 933                         else if (nBytes == 0)
 934                         {
 935                             // socket closed gracefully
 936                             if (!pnode->fDisconnect)
 937                                 printf("socket closed\n");
 938                             pnode->CloseSocketDisconnect();
 939                         }
 940                         else if (nBytes < 0)
 941                         {
 942                             // error
 943                             int nErr = WSAGetLastError();
 944                             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
 945                             {
 946                                 if (!pnode->fDisconnect)
 947                                     printf("socket recv error %d\n", nErr);
 948                                 pnode->CloseSocketDisconnect();
 949                             }
 950                         }
 951                     }
 952                 }
 953             }
 954
 955             //
 956             // Send
 957             //
 958             if (pnode->hSocket == INVALID_SOCKET)
 959                 continue;
 960             if (FD_ISSET(pnode->hSocket, &fdsetSend))
 961             {
 962                 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
 963                 {
 964                     CDataStream& vSend = pnode->vSend;
 965                     if (!vSend.empty())
 966                     {
 967                         int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
 968                         if (nBytes > 0)
 969                         {
 970                             vSend.erase(vSend.begin(), vSend.begin() + nBytes);
 971                             pnode->nLastSend = GetTime();
 972                         }
 973                         else if (nBytes < 0)
 974                         {
 975                             // error
 976                             int nErr = WSAGetLastError();
 977                             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
 978                             {
 979                                 printf("socket send error %d\n", nErr);
 980                                 pnode->CloseSocketDisconnect();
 981                             }
 982                         }
 983                         if (vSend.size() > SendBufferSize()) {
 984                             if (!pnode->fDisconnect)
 985                                 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
 986                             pnode->CloseSocketDisconnect();
 987                         }
 988                     }
 989                 }
 990             }
 991
 992             //
 993             // Inactivity checking
 994             //
 995             if (pnode->vSend.empty())
 996                 pnode->nLastSendEmpty = GetTime();
 997             if (GetTime() - pnode->nTimeConnected > 60)
 998             {
 999                 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1000                 {
1001                     printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1002                     pnode->fDisconnect = true;
1003                 }
1004                 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1005                 {
1006                     printf("socket not sending\n");
1007                     pnode->fDisconnect = true;
1008                 }
1009                 else if (GetTime() - pnode->nLastRecv > 90*60)
1010                 {
1011                     printf("socket inactivity timeout\n");
1012                     pnode->fDisconnect = true;
1013                 }
1014             }
1015         }
1016         CRITICAL_BLOCK(cs_vNodes)
1017         {
1018             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1019                 pnode->Release();
1020         }
1021
1022         Sleep(10);
1023     }
1024 }
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034 #ifdef USE_UPNP
1035 void ThreadMapPort(void* parg)
1036 {
1037     IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1038     try
1039     {
1040         vnThreadsRunning[5]++;
1041         ThreadMapPort2(parg);
1042         vnThreadsRunning[5]--;
1043     }
1044     catch (std::exception& e) {
1045         vnThreadsRunning[5]--;
1046         PrintException(&e, "ThreadMapPort()");
1047     } catch (...) {
1048         vnThreadsRunning[5]--;
1049         PrintException(NULL, "ThreadMapPort()");
1050     }
1051     printf("ThreadMapPort exiting\n");
1052 }
1053
1054 void ThreadMapPort2(void* parg)
1055 {
1056     printf("ThreadMapPort started\n");
1057
1058     char port[6];
1059     sprintf(port, "%d", GetListenPort());
1060
1061     const char * rootdescurl = 0;
1062     const char * multicastif = 0;
1063     const char * minissdpdpath = 0;
1064     struct UPNPDev * devlist = 0;
1065     char lanaddr[64];
1066
1067     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1068
1069     struct UPNPUrls urls;
1070     struct IGDdatas data;
1071     int r;
1072
1073     r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1074     if (r == 1)
1075     {
1076         char intClient[16];
1077         char intPort[6];
1078
1079 #ifndef __WXMSW__
1080         r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1081                                 port, port, lanaddr, 0, "TCP", 0);
1082 #else
1083         r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1084                                 port, port, lanaddr, 0, "TCP", 0, "0");
1085 #endif
1086         if(r!=UPNPCOMMAND_SUCCESS)
1087             printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1088                 port, port, lanaddr, r, strupnperror(r));
1089         else
1090             printf("UPnP Port Mapping successful.\n");
1091         loop {
1092             if (fShutdown || !fUseUPnP)
1093             {
1094                 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1095                 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1096                 freeUPNPDevlist(devlist); devlist = 0;
1097                 FreeUPNPUrls(&urls);
1098                 return;
1099             }
1100             Sleep(2000);
1101         }
1102     } else {
1103         printf("No valid UPnP IGDs found\n");
1104         freeUPNPDevlist(devlist); devlist = 0;
1105         if (r != 0)
1106             FreeUPNPUrls(&urls);
1107         loop {
1108             if (fShutdown || !fUseUPnP)
1109                 return;
1110             Sleep(2000);
1111         }
1112     }
1113 }
1114
1115 void MapPort(bool fMapPort)
1116 {
1117     if (fUseUPnP != fMapPort)
1118     {
1119         fUseUPnP = fMapPort;
1120         WriteSetting("fUseUPnP", fUseUPnP);
1121     }
1122     if (fUseUPnP && vnThreadsRunning[5] < 1)
1123     {
1124         if (!CreateThread(ThreadMapPort, NULL))
1125             printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1126     }
1127 }
1128 #endif
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139 static const char *strDNSSeed[] = {
1140     "bitseed.xf2.org",
1141     "bitseed.bitcoin.org.uk",
1142     "dnsseed.bluematt.me",
1143 };
1144
1145 void DNSAddressSeed()
1146 {
1147     int found = 0;
1148
1149     printf("Loading addresses from DNS seeds (could take a while)\n");
1150
1151     for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1152         vector<CAddress> vaddr;
1153         if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1154         {
1155             BOOST_FOREACH (CAddress& addr, vaddr)
1156             {
1157                 if (addr.GetByte(3) != 127)
1158                 {
1159                     addr.nTime = 0;
1160                     AddAddress(addr);
1161                     found++;
1162                 }
1163             }
1164         }
1165     }
1166
1167     printf("%d addresses found from DNS seeds\n", found);
1168 }
1169
1170
1171
1172 unsigned int pnSeed[] =
1173 {
1174     0x1ddb1032, 0x6242ce40, 0x52d6a445, 0x2dd7a445, 0x8a53cd47, 0x73263750, 0xda23c257, 0xecd4ed57,
1175     0x0a40ec59, 0x75dce160, 0x7df76791, 0x89370bad, 0xa4f214ad, 0x767700ae, 0x638b0418, 0x868a1018,
1176     0xcd9f332e, 0x0129653e, 0xcc92dc3e, 0x96671640, 0x56487e40, 0x5b66f440, 0xb1d01f41, 0xf1dc6041,
1177     0xc1d12b42, 0x86ba1243, 0x6be4df43, 0x6d4cef43, 0xd18e0644, 0x1ab0b344, 0x6584a345, 0xe7c1a445,
1178     0x58cea445, 0xc5daa445, 0x21dda445, 0x3d3b5346, 0x13e55347, 0x1080d24a, 0x8e611e4b, 0x81518e4b,
1179     0x6c839e4b, 0xe2ad0a4c, 0xfbbc0a4c, 0x7f5b6e4c, 0x7244224e, 0x1300554e, 0x20690652, 0x5a48b652,
1180     0x75c5c752, 0x4335cc54, 0x340fd154, 0x87c07455, 0x087b2b56, 0x8a133a57, 0xac23c257, 0x70374959,
1181     0xfb63d45b, 0xb9a1685c, 0x180d765c, 0x674f645d, 0x04d3495e, 0x1de44b5e, 0x4ee8a362, 0x0ded1b63,
1182     0xc1b04b6d, 0x8d921581, 0x97b7ea82, 0x1cf83a8e, 0x91490bad, 0x09dc75ae, 0x9a6d79ae, 0xa26d79ae,
1183     0x0fd08fae, 0x0f3e3fb2, 0x4f944fb2, 0xcca448b8, 0x3ecd6ab8, 0xa9d5a5bc, 0x8d0119c1, 0x045997d5,
1184     0xca019dd9, 0x0d526c4d, 0xabf1ba44, 0x66b1ab55, 0x1165f462, 0x3ed7cbad, 0xa38fae6e, 0x3bd2cbad,
1185     0xd36f0547, 0x20df7840, 0x7a337742, 0x549f8e4b, 0x9062365c, 0xd399f562, 0x2b5274a1, 0x8edfa153,
1186     0x3bffb347, 0x7074bf58, 0xb74fcbad, 0x5b5a795b, 0x02fa29ce, 0x5a6738d4, 0xe8a1d23e, 0xef98c445,
1187     0x4b0f494c, 0xa2bc1e56, 0x7694ad63, 0xa4a800c3, 0x05fda6cd, 0x9f22175e, 0x364a795b, 0x536285d5,
1188     0xac44c9d4, 0x0b06254d, 0x150c2fd4, 0x32a50dcc, 0xfd79ce48, 0xf15cfa53, 0x66c01e60, 0x6bc26661,
1189     0xc03b47ae, 0x4dda1b81, 0x3285a4c1, 0x883ca96d, 0x35d60a4c, 0xdae09744, 0x2e314d61, 0x84e247cf,
1190     0x6c814552, 0x3a1cc658, 0x98d8f382, 0xe584cb5b, 0x15e86057, 0x7b01504e, 0xd852dd48, 0x56382f56,
1191     0x0a5df454, 0xa0d18d18, 0x2e89b148, 0xa79c114c, 0xcbdcd054, 0x5523bc43, 0xa9832640, 0x8a066144,
1192     0x3894c3bc, 0xab76bf58, 0x6a018ac1, 0xfebf4f43, 0x2f26c658, 0x31102f4e, 0x85e929d5, 0x2a1c175e,
1193     0xfc6c2cd1, 0x27b04b6d, 0xdf024650, 0x161748b8, 0x28be6580, 0x57be6580, 0x1cee677a, 0xaa6bb742,
1194     0x9a53964b, 0x0a5a2d4d, 0x2434c658, 0x9a494f57, 0x1ebb0e48, 0xf610b85d, 0x077ecf44, 0x085128bc,
1195     0x5ba17a18, 0x27ca1b42, 0xf8a00b56, 0xfcd4c257, 0xcf2fc15e, 0xd897e052, 0x4cada04f, 0x2f35f6d5,
1196     0x382ce8c9, 0xe523984b, 0x3f946846, 0x60c8be43, 0x41da6257, 0xde0be142, 0xae8a544b, 0xeff0c254,
1197     0x1e0f795b, 0xaeb28890, 0xca16acd9, 0x1e47ddd8, 0x8c8c4829, 0xd27dc747, 0xd53b1663, 0x4096b163,
1198     0x9c8dd958, 0xcb12f860, 0x9e79305c, 0x40c1a445, 0x4a90c2bc, 0x2c3a464d, 0x2727f23c, 0x30b04b6d,
1199     0x59024cb8, 0xa091e6ad, 0x31b04b6d, 0xc29d46a6, 0x63934fb2, 0xd9224dbe, 0x9f5910d8, 0x7f530a6b,
1200     0x752e9c95, 0x65453548, 0xa484be46, 0xce5a1b59, 0x710e0718, 0x46a13d18, 0xdaaf5318, 0xc4a8ff53,
1201     0x87abaa52, 0xb764cf51, 0xb2025d4a, 0x6d351e41, 0xc035c33e, 0xa432c162, 0x61ef34ae, 0xd16fddbc,
1202     0x0870e8c1, 0x3070e8c1, 0x9c71e8c1, 0xa4992363, 0x85a1f663, 0x4184e559, 0x18d96ed8, 0x17b8dbd5,
1203     0x60e7cd18, 0xe5ee104c, 0xab17ac62, 0x1e786e1b, 0x5d23b762, 0xf2388fae, 0x88270360, 0x9e5b3d80,
1204     0x7da518b2, 0xb5613b45, 0x1ad41f3e, 0xd550854a, 0x8617e9a9, 0x925b229c, 0xf2e92542, 0x47af0544,
1205     0x73b5a843, 0xb9b7a0ad, 0x03a748d0, 0x0a6ff862, 0x6694df62, 0x3bfac948, 0x8e098f4f, 0x746916c3,
1206     0x02f38e4f, 0x40bb1243, 0x6a54d162, 0x6008414b, 0xa513794c, 0x514aa343, 0x63781747, 0xdbb6795b,
1207     0xed065058, 0x42d24b46, 0x1518794c, 0x9b271681, 0x73e4ffad, 0x0654784f, 0x438dc945, 0x641846a6,
1208     0x2d1b0944, 0x94b59148, 0x8d369558, 0xa5a97662, 0x8b705b42, 0xce9204ae, 0x8d584450, 0x2df61555,
1209     0xeebff943, 0x2e75fb4d, 0x3ef8fc57, 0x9921135e, 0x8e31042e, 0xb5afad43, 0x89ecedd1, 0x9cfcc047,
1210     0x8fcd0f4c, 0xbe49f5ad, 0x146a8d45, 0x98669ab8, 0x98d9175e, 0xd1a8e46d, 0x839a3ab8, 0x40a0016c,
1211     0x6d27c257, 0x977fffad, 0x7baa5d5d, 0x1213be43, 0xb167e5a9, 0x640fe8ca, 0xbc9ea655, 0x0f820a4c,
1212     0x0f097059, 0x69ac957c, 0x366d8453, 0xb1ba2844, 0x8857f081, 0x70b5be63, 0xc545454b, 0xaf36ded1,
1213     0xb5a4b052, 0x21f062d1, 0x72ab89b2, 0x74a45318, 0x8312e6bc, 0xb916965f, 0x8aa7c858, 0xfe7effad,
1214 };
1215
1216
1217
1218 void ThreadOpenConnections(void* parg)
1219 {
1220     IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1221     try
1222     {
1223         vnThreadsRunning[1]++;
1224         ThreadOpenConnections2(parg);
1225         vnThreadsRunning[1]--;
1226     }
1227     catch (std::exception& e) {
1228         vnThreadsRunning[1]--;
1229         PrintException(&e, "ThreadOpenConnections()");
1230     } catch (...) {
1231         vnThreadsRunning[1]--;
1232         PrintException(NULL, "ThreadOpenConnections()");
1233     }
1234     printf("ThreadOpenConnections exiting\n");
1235 }
1236
1237 void ThreadOpenConnections2(void* parg)
1238 {
1239     printf("ThreadOpenConnections started\n");
1240
1241     // Connect to specific addresses
1242     if (mapArgs.count("-connect"))
1243     {
1244         for (int64 nLoop = 0;; nLoop++)
1245         {
1246             BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1247             {
1248                 CAddress addr(strAddr, fAllowDNS);
1249                 if (addr.IsValid())
1250                     OpenNetworkConnection(addr);
1251                 for (int i = 0; i < 10 && i < nLoop; i++)
1252                 {
1253                     Sleep(500);
1254                     if (fShutdown)
1255                         return;
1256                 }
1257             }
1258         }
1259     }
1260
1261     // Connect to manually added nodes first
1262     if (mapArgs.count("-addnode"))
1263     {
1264         BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1265         {
1266             CAddress addr(strAddr, fAllowDNS);
1267             if (addr.IsValid())
1268             {
1269                 OpenNetworkConnection(addr);
1270                 Sleep(500);
1271                 if (fShutdown)
1272                     return;
1273             }
1274         }
1275     }
1276
1277     // Initiate network connections
1278     int64 nStart = GetTime();
1279     loop
1280     {
1281         // Limit outbound connections
1282         vnThreadsRunning[1]--;
1283         Sleep(500);
1284         loop
1285         {
1286             int nOutbound = 0;
1287             CRITICAL_BLOCK(cs_vNodes)
1288                 BOOST_FOREACH(CNode* pnode, vNodes)
1289                     if (!pnode->fInbound)
1290                         nOutbound++;
1291             int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1292             nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1293             if (nOutbound < nMaxOutboundConnections)
1294                 break;
1295             Sleep(2000);
1296             if (fShutdown)
1297                 return;
1298         }
1299         vnThreadsRunning[1]++;
1300         if (fShutdown)
1301             return;
1302
1303         CRITICAL_BLOCK(cs_mapAddresses)
1304         {
1305             // Add seed nodes if IRC isn't working
1306             static bool fSeedUsed;
1307             bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1308             if (mapAddresses.empty() && (GetTime() - nStart > 60 || fTOR) && !fTestNet)
1309             {
1310                 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1311                 {
1312                     // It'll only connect to one or two seed nodes because once it connects,
1313                     // it'll get a pile of addresses with newer timestamps.
1314                     CAddress addr;
1315                     addr.ip = pnSeed[i];
1316                     addr.nTime = 0;
1317                     AddAddress(addr);
1318                 }
1319                 fSeedUsed = true;
1320             }
1321
1322             if (fSeedUsed && mapAddresses.size() > ARRAYLEN(pnSeed) + 100)
1323             {
1324                 // Disconnect seed nodes
1325                 set<unsigned int> setSeed(pnSeed, pnSeed + ARRAYLEN(pnSeed));
1326                 static int64 nSeedDisconnected;
1327                 if (nSeedDisconnected == 0)
1328                 {
1329                     nSeedDisconnected = GetTime();
1330                     CRITICAL_BLOCK(cs_vNodes)
1331                         BOOST_FOREACH(CNode* pnode, vNodes)
1332                             if (setSeed.count(pnode->addr.ip))
1333                                 pnode->fDisconnect = true;
1334                 }
1335
1336                 // Keep setting timestamps to 0 so they won't reconnect
1337                 if (GetTime() - nSeedDisconnected < 60 * 60)
1338                 {
1339                     BOOST_FOREACH(PAIRTYPE(const vector<unsigned char>, CAddress)& item, mapAddresses)
1340                     {
1341                         if (setSeed.count(item.second.ip) && item.second.nTime != 0)
1342                         {
1343                             item.second.nTime = 0;
1344                             CAddrDB().WriteAddress(item.second);
1345                         }
1346                     }
1347                 }
1348             }
1349         }
1350
1351
1352         //
1353         // Choose an address to connect to based on most recently seen
1354         //
1355         CAddress addrConnect;
1356         int64 nBest = INT64_MIN;
1357
1358         // Only connect to one address per a.b.?.? range.
1359         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1360         set<unsigned int> setConnected;
1361         CRITICAL_BLOCK(cs_vNodes)
1362             BOOST_FOREACH(CNode* pnode, vNodes)
1363                 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1364
1365         CRITICAL_BLOCK(cs_mapAddresses)
1366         {
1367             BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1368             {
1369                 const CAddress& addr = item.second;
1370                 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1371                     continue;
1372                 int64 nSinceLastSeen = GetAdjustedTime() - addr.nTime;
1373                 int64 nSinceLastTry = GetAdjustedTime() - addr.nLastTry;
1374
1375                 // Randomize the order in a deterministic way, putting the standard port first
1376                 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1377                 if (addr.port != htons(GetDefaultPort()))
1378                     nRandomizer += 2 * 60 * 60;
1379
1380                 // Last seen  Base retry frequency
1381                 //   <1 hour   10 min
1382                 //    1 hour    1 hour
1383                 //    4 hours   2 hours
1384                 //   24 hours   5 hours
1385                 //   48 hours   7 hours
1386                 //    7 days   13 hours
1387                 //   30 days   27 hours
1388                 //   90 days   46 hours
1389                 //  365 days   93 hours
1390                 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1391
1392                 // Fast reconnect for one hour after last seen
1393                 if (nSinceLastSeen < 60 * 60)
1394                     nDelay = 10 * 60;
1395
1396                 // Limit retry frequency
1397                 if (nSinceLastTry < nDelay)
1398                     continue;
1399
1400                 // If we have IRC, we'll be notified when they first come online,
1401                 // and again every 24 hours by the refresh broadcast.
1402                 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1403                     continue;
1404
1405                 // Only try the old stuff if we don't have enough connections
1406                 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1407                     continue;
1408
1409                 // If multiple addresses are ready, prioritize by time since
1410                 // last seen and time since last tried.
1411                 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1412                 if (nScore > nBest)
1413                 {
1414                     nBest = nScore;
1415                     addrConnect = addr;
1416                 }
1417             }
1418         }
1419
1420         if (addrConnect.IsValid())
1421             OpenNetworkConnection(addrConnect);
1422     }
1423 }
1424
1425 bool OpenNetworkConnection(const CAddress& addrConnect)
1426 {
1427     //
1428     // Initiate outbound network connection
1429     //
1430     if (fShutdown)
1431         return false;
1432     if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() || FindNode(addrConnect.ip))
1433         return false;
1434
1435     vnThreadsRunning[1]--;
1436     CNode* pnode = ConnectNode(addrConnect);
1437     vnThreadsRunning[1]++;
1438     if (fShutdown)
1439         return false;
1440     if (!pnode)
1441         return false;
1442     pnode->fNetworkNode = true;
1443
1444     return true;
1445 }
1446
1447
1448
1449
1450
1451
1452
1453
1454 void ThreadMessageHandler(void* parg)
1455 {
1456     IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1457     try
1458     {
1459         vnThreadsRunning[2]++;
1460         ThreadMessageHandler2(parg);
1461         vnThreadsRunning[2]--;
1462     }
1463     catch (std::exception& e) {
1464         vnThreadsRunning[2]--;
1465         PrintException(&e, "ThreadMessageHandler()");
1466     } catch (...) {
1467         vnThreadsRunning[2]--;
1468         PrintException(NULL, "ThreadMessageHandler()");
1469     }
1470     printf("ThreadMessageHandler exiting\n");
1471 }
1472
1473 void ThreadMessageHandler2(void* parg)
1474 {
1475     printf("ThreadMessageHandler started\n");
1476     SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1477     while (!fShutdown)
1478     {
1479         vector<CNode*> vNodesCopy;
1480         CRITICAL_BLOCK(cs_vNodes)
1481         {
1482             vNodesCopy = vNodes;
1483             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1484                 pnode->AddRef();
1485         }
1486
1487         // Poll the connected nodes for messages
1488         CNode* pnodeTrickle = NULL;
1489         if (!vNodesCopy.empty())
1490             pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1491         BOOST_FOREACH(CNode* pnode, vNodesCopy)
1492         {
1493             // Receive messages
1494             TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1495                 ProcessMessages(pnode);
1496             if (fShutdown)
1497                 return;
1498
1499             // Send messages
1500             TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1501                 SendMessages(pnode, pnode == pnodeTrickle);
1502             if (fShutdown)
1503                 return;
1504         }
1505
1506         CRITICAL_BLOCK(cs_vNodes)
1507         {
1508             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1509                 pnode->Release();
1510         }
1511
1512         // Wait and allow messages to bunch up.
1513         // Reduce vnThreadsRunning so StopNode has permission to exit while
1514         // we're sleeping, but we must always check fShutdown after doing this.
1515         vnThreadsRunning[2]--;
1516         Sleep(100);
1517         if (fRequestShutdown)
1518             Shutdown(NULL);
1519         vnThreadsRunning[2]++;
1520         if (fShutdown)
1521             return;
1522     }
1523 }
1524
1525
1526
1527
1528
1529
1530 bool BindListenPort(string& strError)
1531 {
1532     strError = "";
1533     int nOne = 1;
1534     addrLocalHost.port = htons(GetListenPort());
1535
1536 #ifdef __WXMSW__
1537     // Initialize Windows Sockets
1538     WSADATA wsadata;
1539     int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1540     if (ret != NO_ERROR)
1541     {
1542         strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1543         printf("%s\n", strError.c_str());
1544         return false;
1545     }
1546 #endif
1547
1548     // Create socket for listening for incoming connections
1549     hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1550     if (hListenSocket == INVALID_SOCKET)
1551     {
1552         strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1553         printf("%s\n", strError.c_str());
1554         return false;
1555     }
1556
1557 #ifdef BSD
1558     // Different way of disabling SIGPIPE on BSD
1559     setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1560 #endif
1561
1562 #ifndef __WXMSW__
1563     // Allow binding if the port is still in TIME_WAIT state after
1564     // the program was closed and restarted.  Not an issue on windows.
1565     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1566 #endif
1567
1568 #ifdef __WXMSW__
1569     // Set to nonblocking, incoming connections will also inherit this
1570     if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1571 #else
1572     if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1573 #endif
1574     {
1575         strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1576         printf("%s\n", strError.c_str());
1577         return false;
1578     }
1579
1580     // The sockaddr_in structure specifies the address family,
1581     // IP address, and port for the socket that is being bound
1582     struct sockaddr_in sockaddr;
1583     memset(&sockaddr, 0, sizeof(sockaddr));
1584     sockaddr.sin_family = AF_INET;
1585     sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1586     sockaddr.sin_port = htons(GetListenPort());
1587     if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1588     {
1589         int nErr = WSAGetLastError();
1590         if (nErr == WSAEADDRINUSE)
1591             strError = strprintf(_("Unable to bind to port %d on this computer.  Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1592         else
1593             strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1594         printf("%s\n", strError.c_str());
1595         return false;
1596     }
1597     printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1598
1599     // Listen for incoming connections
1600     if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1601     {
1602         strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1603         printf("%s\n", strError.c_str());
1604         return false;
1605     }
1606
1607     return true;
1608 }
1609
1610 void StartNode(void* parg)
1611 {
1612     if (pnodeLocalHost == NULL)
1613         pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1614
1615 #ifdef __WXMSW__
1616     // Get local host ip
1617     char pszHostName[1000] = "";
1618     if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1619     {
1620         vector<CAddress> vaddr;
1621         if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1622             BOOST_FOREACH (const CAddress &addr, vaddr)
1623                 if (addr.GetByte(3) != 127)
1624                 {
1625                     addrLocalHost = addr;
1626                     break;
1627                 }
1628     }
1629 #else
1630     // Get local host ip
1631     struct ifaddrs* myaddrs;
1632     if (getifaddrs(&myaddrs) == 0)
1633     {
1634         for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1635         {
1636             if (ifa->ifa_addr == NULL) continue;
1637             if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1638             if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1639             if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1640             char pszIP[100];
1641             if (ifa->ifa_addr->sa_family == AF_INET)
1642             {
1643                 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1644                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1645                     printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1646
1647                 // Take the first IP that isn't loopback 127.x.x.x
1648                 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1649                 if (addr.IsValid() && addr.GetByte(3) != 127)
1650                 {
1651                     addrLocalHost = addr;
1652                     break;
1653                 }
1654             }
1655             else if (ifa->ifa_addr->sa_family == AF_INET6)
1656             {
1657                 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1658                 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1659                     printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1660             }
1661         }
1662         freeifaddrs(myaddrs);
1663     }
1664 #endif
1665     printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1666
1667     if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1668     {
1669         // Proxies can't take incoming connections
1670         addrLocalHost.ip = CAddress("0.0.0.0").ip;
1671         printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1672     }
1673     else
1674     {
1675         CreateThread(ThreadGetMyExternalIP, NULL);
1676     }
1677
1678     //
1679     // Start threads
1680     //
1681
1682     // Map ports with UPnP
1683     if (fHaveUPnP)
1684         MapPort(fUseUPnP);
1685
1686     // Get addresses from IRC and advertise ours
1687     if (!CreateThread(ThreadIRCSeed, NULL))
1688         printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1689
1690     // Send and receive from sockets, accept connections
1691     pthread_t hThreadSocketHandler = CreateThread(ThreadSocketHandler, NULL, true);
1692
1693     // Initiate outbound connections
1694     if (!CreateThread(ThreadOpenConnections, NULL))
1695         printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1696
1697     // Process messages
1698     if (!CreateThread(ThreadMessageHandler, NULL))
1699         printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1700
1701     // Generate coins in the background
1702     GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1703 }
1704
1705 bool StopNode()
1706 {
1707     printf("StopNode()\n");
1708     fShutdown = true;
1709     nTransactionsUpdated++;
1710     int64 nStart = GetTime();
1711     while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1712 #ifdef USE_UPNP
1713         || vnThreadsRunning[5] > 0
1714 #endif
1715     )
1716     {
1717         if (GetTime() - nStart > 20)
1718             break;
1719         Sleep(20);
1720     }
1721     if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1722     if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1723     if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1724     if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1725     if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1726     if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1727     while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1728         Sleep(20);
1729     Sleep(50);
1730
1731     return true;
1732 }
1733
1734 class CNetCleanup
1735 {
1736 public:
1737     CNetCleanup()
1738     {
1739     }
1740     ~CNetCleanup()
1741     {
1742         // Close sockets
1743         BOOST_FOREACH(CNode* pnode, vNodes)
1744             if (pnode->hSocket != INVALID_SOCKET)
1745                 closesocket(pnode->hSocket);
1746         if (hListenSocket != INVALID_SOCKET)
1747             if (closesocket(hListenSocket) == SOCKET_ERROR)
1748                 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1749
1750 #ifdef __WXMSW__
1751         // Shutdown Windows Sockets
1752         WSACleanup();
1753 #endif
1754     }
1755 }
1756 instance_of_cnetcleanup;