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