1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2011 The Bitcoin developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
18 #include <miniupnpc/miniwget.h>
19 #include <miniupnpc/miniupnpc.h>
20 #include <miniupnpc/upnpcommands.h>
21 #include <miniupnpc/upnperrors.h>
25 using namespace boost;
27 static const int MAX_OUTBOUND_CONNECTIONS = 8;
29 void ThreadMessageHandler2(void* parg);
30 void ThreadSocketHandler2(void* parg);
31 void ThreadOpenConnections2(void* parg);
33 void ThreadMapPort2(void* parg);
35 void ThreadDNSAddressSeed2(void* parg);
36 bool OpenNetworkConnection(const CAddress& addrConnect);
43 // Global state variables
46 bool fAllowDNS = false;
47 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
48 CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
49 static CNode* pnodeLocalHost = NULL;
50 uint64 nLocalHostNonce = 0;
51 array<int, 10> vnThreadsRunning;
52 static SOCKET hListenSocket = INVALID_SOCKET;
54 vector<CNode*> vNodes;
55 CCriticalSection cs_vNodes;
56 map<vector<unsigned char>, CAddress> mapAddresses;
57 CCriticalSection cs_mapAddresses;
58 map<CInv, CDataStream> mapRelay;
59 deque<pair<int64, CInv> > vRelayExpiration;
60 CCriticalSection cs_mapRelay;
61 map<CInv, int64> mapAlreadyAskedFor;
64 int fUseProxy = false;
65 int nConnectTimeout = 5000;
66 CAddress addrProxy("127.0.0.1",9050);
71 unsigned short GetListenPort()
73 return (unsigned short)(GetArg("-port", GetDefaultPort()));
76 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
78 // Filter out duplicate requests
79 if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
81 pindexLastGetBlocksBegin = pindexBegin;
82 hashLastGetBlocksEnd = hashEnd;
84 PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
91 bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
93 hSocketRet = INVALID_SOCKET;
95 SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
96 if (hSocket == INVALID_SOCKET)
100 setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
103 bool fProxy = (fUseProxy && addrConnect.IsRoutable());
104 struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
107 u_long fNonblock = 1;
108 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
110 int fFlags = fcntl(hSocket, F_GETFL, 0);
111 if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
114 closesocket(hSocket);
119 if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
121 // WSAEINVAL is here because some legacy version of winsock uses it
122 if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
124 struct timeval timeout;
125 timeout.tv_sec = nTimeout / 1000;
126 timeout.tv_usec = (nTimeout % 1000) * 1000;
130 FD_SET(hSocket, &fdset);
131 int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
134 printf("connection timeout\n");
135 closesocket(hSocket);
138 if (nRet == SOCKET_ERROR)
140 printf("select() for connection failed: %i\n",WSAGetLastError());
141 closesocket(hSocket);
144 socklen_t nRetSize = sizeof(nRet);
146 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
148 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
151 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
152 closesocket(hSocket);
157 printf("connect() failed after select(): %s\n",strerror(nRet));
158 closesocket(hSocket);
163 else if (WSAGetLastError() != WSAEISCONN)
168 printf("connect() failed: %i\n",WSAGetLastError());
169 closesocket(hSocket);
175 this isn't even strictly necessary
176 CNode::ConnectNode immediately turns the socket back to non-blocking
177 but we'll turn it back to blocking just in case
181 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
183 fFlags = fcntl(hSocket, F_GETFL, 0);
184 if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
187 closesocket(hSocket);
193 printf("proxy connecting %s\n", addrConnect.ToString().c_str());
194 char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
195 memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
196 memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
197 char* pszSocks4 = pszSocks4IP;
198 int nSize = sizeof(pszSocks4IP);
200 int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
203 closesocket(hSocket);
204 return error("Error sending to proxy");
207 if (recv(hSocket, pchRet, 8, 0) != 8)
209 closesocket(hSocket);
210 return error("Error reading proxy response");
212 if (pchRet[1] != 0x5a)
214 closesocket(hSocket);
215 if (pchRet[1] != 0x5b)
216 printf("ERROR: Proxy returned error %d\n", pchRet[1]);
219 printf("proxy connected %s\n", addrConnect.ToString().c_str());
222 hSocketRet = hSocket;
226 // portDefault is in host order
227 bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
232 int port = portDefault;
235 strlcpy(psz, pszName, sizeof(psz));
238 char* pszColon = strrchr(psz+1,':');
239 char *pszPortEnd = NULL;
240 int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
241 if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
243 if (psz[0] == '[' && pszColon[-1] == ']')
245 // Future: enable IPv6 colon-notation inside []
252 if (port < 0 || port > std::numeric_limits<unsigned short>::max())
253 port = std::numeric_limits<unsigned short>::max();
257 unsigned int addrIP = inet_addr(pszHost);
258 if (addrIP != INADDR_NONE)
260 // valid IP address passed
261 vaddr.push_back(CAddress(addrIP, port, nServices));
268 struct hostent* phostent = gethostbyname(pszHost);
272 if (phostent->h_addrtype != AF_INET)
275 char** ppAddr = phostent->h_addr_list;
276 while (*ppAddr != NULL && vaddr.size() != nMaxSolutions)
278 CAddress addr(((struct in_addr*)ppAddr[0])->s_addr, port, nServices);
280 vaddr.push_back(addr);
284 return (vaddr.size() > 0);
287 // portDefault is in host order
288 bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup, int portDefault, bool fAllowPort)
290 vector<CAddress> vaddr;
291 bool fRet = Lookup(pszName, vaddr, nServices, 1, fAllowLookup, portDefault, fAllowPort);
297 bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet)
300 if (!ConnectSocket(addrConnect, hSocket))
301 return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
303 send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
306 while (RecvLine(hSocket, strLine))
308 if (strLine.empty()) // HTTP response is separated from headers by blank line
312 if (!RecvLine(hSocket, strLine))
314 closesocket(hSocket);
317 if (pszKeyword == NULL)
319 if (strLine.find(pszKeyword) != -1)
321 strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
325 closesocket(hSocket);
326 if (strLine.find("<") != -1)
327 strLine = strLine.substr(0, strLine.find("<"));
328 strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
329 while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
330 strLine.resize(strLine.size()-1);
331 CAddress addr(strLine,0,true);
332 printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
333 if (addr.ip == 0 || addr.ip == INADDR_NONE || !addr.IsRoutable())
339 closesocket(hSocket);
340 return error("GetMyExternalIP() : connection closed");
343 // We now get our external IP from the IRC server first and only use this as a backup
344 bool GetMyExternalIP(unsigned int& ipRet)
346 CAddress addrConnect;
348 const char* pszKeyword;
353 for (int nLookup = 0; nLookup <= 1; nLookup++)
354 for (int nHost = 1; nHost <= 2; nHost++)
356 // We should be phasing out our use of sites like these. If we need
357 // replacements, we should ask for volunteers to put this simple
358 // php file on their webserver that prints the client IP:
359 // <?php echo $_SERVER["REMOTE_ADDR"]; ?>
362 addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
366 CAddress addrIP("checkip.dyndns.org", 80, true);
367 if (addrIP.IsValid())
368 addrConnect = addrIP;
371 pszGet = "GET / HTTP/1.1\r\n"
372 "Host: checkip.dyndns.org\r\n"
373 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
374 "Connection: close\r\n"
377 pszKeyword = "Address:";
381 addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
385 CAddress addrIP("www.showmyip.com", 80, true);
386 if (addrIP.IsValid())
387 addrConnect = addrIP;
390 pszGet = "GET /simple/ HTTP/1.1\r\n"
391 "Host: www.showmyip.com\r\n"
392 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
393 "Connection: close\r\n"
396 pszKeyword = NULL; // Returns just IP address
399 if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
406 void ThreadGetMyExternalIP(void* parg)
408 // Wait for IRC to get it first
409 if (!GetBoolArg("-noirc"))
411 for (int i = 0; i < 2 * 60; i++)
414 if (fGotExternalIP || fShutdown)
419 // Fallback in case IRC fails to get it
420 if (GetMyExternalIP(addrLocalHost.ip))
422 printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
423 if (addrLocalHost.IsRoutable())
425 // If we already connected to a few before we had our IP, go back and addr them.
426 // setAddrKnown automatically filters any duplicate sends.
427 CAddress addr(addrLocalHost);
428 addr.nTime = GetAdjustedTime();
429 CRITICAL_BLOCK(cs_vNodes)
430 BOOST_FOREACH(CNode* pnode, vNodes)
431 pnode->PushAddress(addr);
440 bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
442 if (!addr.IsRoutable())
444 if (addr.ip == addrLocalHost.ip)
446 addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
447 bool fUpdated = false;
449 CAddress addrFound = addr;
451 CRITICAL_BLOCK(cs_mapAddresses)
453 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
454 if (it == mapAddresses.end())
457 printf("AddAddress(%s)\n", addr.ToString().c_str());
458 mapAddresses.insert(make_pair(addr.GetKey(), addr));
464 addrFound = (*it).second;
465 if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
467 // Services have been added
468 addrFound.nServices |= addr.nServices;
471 bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
472 int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
473 if (addrFound.nTime < addr.nTime - nUpdateInterval)
475 // Periodically update most recently seen time
476 addrFound.nTime = addr.nTime;
481 // There is a nasty deadlock bug if this is done inside the cs_mapAddresses
483 // Thread 1: begin db transaction (locks inside-db-mutex)
484 // then AddAddress (locks cs_mapAddresses)
485 // Thread 2: AddAddress (locks cs_mapAddresses)
486 // ... then db operation hangs waiting for inside-db-mutex
490 pAddrDB->WriteAddress(addrFound);
492 CAddrDB().WriteAddress(addrFound);
497 void AddressCurrentlyConnected(const CAddress& addr)
499 CAddress *paddrFound = NULL;
501 CRITICAL_BLOCK(cs_mapAddresses)
503 // Only if it's been published already
504 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
505 if (it != mapAddresses.end())
506 paddrFound = &(*it).second;
511 int64 nUpdateInterval = 20 * 60;
512 if (paddrFound->nTime < GetAdjustedTime() - nUpdateInterval)
514 // Periodically update most recently seen time
515 paddrFound->nTime = GetAdjustedTime();
517 addrdb.WriteAddress(*paddrFound);
526 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
528 // If the dialog might get closed before the reply comes back,
529 // call this in the destructor so it doesn't get called after it's deleted.
530 CRITICAL_BLOCK(cs_vNodes)
532 BOOST_FOREACH(CNode* pnode, vNodes)
534 CRITICAL_BLOCK(pnode->cs_mapRequests)
536 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
538 CRequestTracker& tracker = (*mi).second;
539 if (tracker.fn == fn && tracker.param1 == param1)
540 pnode->mapRequests.erase(mi++);
556 // Subscription methods for the broadcast and subscription system.
557 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
559 // The subscription system uses a meet-in-the-middle strategy.
560 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
561 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
564 bool AnySubscribed(unsigned int nChannel)
566 if (pnodeLocalHost->IsSubscribed(nChannel))
568 CRITICAL_BLOCK(cs_vNodes)
569 BOOST_FOREACH(CNode* pnode, vNodes)
570 if (pnode->IsSubscribed(nChannel))
575 bool CNode::IsSubscribed(unsigned int nChannel)
577 if (nChannel >= vfSubscribe.size())
579 return vfSubscribe[nChannel];
582 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
584 if (nChannel >= vfSubscribe.size())
587 if (!AnySubscribed(nChannel))
590 CRITICAL_BLOCK(cs_vNodes)
591 BOOST_FOREACH(CNode* pnode, vNodes)
593 pnode->PushMessage("subscribe", nChannel, nHops);
596 vfSubscribe[nChannel] = true;
599 void CNode::CancelSubscribe(unsigned int nChannel)
601 if (nChannel >= vfSubscribe.size())
604 // Prevent from relaying cancel if wasn't subscribed
605 if (!vfSubscribe[nChannel])
607 vfSubscribe[nChannel] = false;
609 if (!AnySubscribed(nChannel))
611 // Relay subscription cancel
612 CRITICAL_BLOCK(cs_vNodes)
613 BOOST_FOREACH(CNode* pnode, vNodes)
615 pnode->PushMessage("sub-cancel", nChannel);
627 CNode* FindNode(unsigned int ip)
629 CRITICAL_BLOCK(cs_vNodes)
631 BOOST_FOREACH(CNode* pnode, vNodes)
632 if (pnode->addr.ip == ip)
638 CNode* FindNode(CAddress addr)
640 CRITICAL_BLOCK(cs_vNodes)
642 BOOST_FOREACH(CNode* pnode, vNodes)
643 if (pnode->addr == addr)
649 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
651 if (addrConnect.ip == addrLocalHost.ip)
654 // Look for an existing connection
655 CNode* pnode = FindNode(addrConnect.ip);
659 pnode->AddRef(nTimeout);
666 printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
667 addrConnect.ToString().c_str(),
668 (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
669 (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
671 CRITICAL_BLOCK(cs_mapAddresses)
672 mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
676 if (ConnectSocket(addrConnect, hSocket))
679 printf("connected %s\n", addrConnect.ToString().c_str());
681 // Set to nonblocking
684 if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
685 printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
687 if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
688 printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
692 CNode* pnode = new CNode(hSocket, addrConnect, false);
694 pnode->AddRef(nTimeout);
697 CRITICAL_BLOCK(cs_vNodes)
698 vNodes.push_back(pnode);
700 pnode->nTimeConnected = GetTime();
709 void CNode::CloseSocketDisconnect()
712 if (hSocket != INVALID_SOCKET)
715 printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
716 printf("disconnecting node %s\n", addr.ToString().c_str());
717 closesocket(hSocket);
718 hSocket = INVALID_SOCKET;
722 void CNode::Cleanup()
724 // All of a nodes broadcasts and subscriptions are automatically torn down
725 // when it goes down, so a node has to stay up to keep its broadcast going.
727 // Cancel subscriptions
728 for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
729 if (vfSubscribe[nChannel])
730 CancelSubscribe(nChannel);
734 void CNode::PushVersion()
736 /// when NTP implemented, change to just nTime = GetAdjustedTime()
737 int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
738 CAddress addrYou = (fUseProxy ? CAddress("0.0.0.0") : addr);
739 CAddress addrMe = (fUseProxy ? CAddress("0.0.0.0") : addrLocalHost);
740 RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
741 PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
742 nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight);
749 std::map<unsigned int, int64> CNode::setBanned;
750 CCriticalSection CNode::cs_setBanned;
752 void CNode::ClearBanned()
757 bool CNode::IsBanned(unsigned int ip)
759 bool fResult = false;
760 CRITICAL_BLOCK(cs_setBanned)
762 std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
763 if (i != setBanned.end())
765 int64 t = (*i).second;
773 bool CNode::Misbehaving(int howmuch)
777 printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
781 nMisbehavior += howmuch;
782 if (nMisbehavior >= GetArg("-banscore", 100))
784 int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
785 CRITICAL_BLOCK(cs_setBanned)
786 if (setBanned[addr.ip] < banTime)
787 setBanned[addr.ip] = banTime;
788 CloseSocketDisconnect();
789 printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
806 void ThreadSocketHandler(void* parg)
808 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
811 vnThreadsRunning[0]++;
812 ThreadSocketHandler2(parg);
813 vnThreadsRunning[0]--;
815 catch (std::exception& e) {
816 vnThreadsRunning[0]--;
817 PrintException(&e, "ThreadSocketHandler()");
819 vnThreadsRunning[0]--;
820 throw; // support pthread_cancel()
822 printf("ThreadSocketHandler exiting\n");
825 void ThreadSocketHandler2(void* parg)
827 printf("ThreadSocketHandler started\n");
828 list<CNode*> vNodesDisconnected;
829 int nPrevNodeCount = 0;
836 CRITICAL_BLOCK(cs_vNodes)
838 // Disconnect unused nodes
839 vector<CNode*> vNodesCopy = vNodes;
840 BOOST_FOREACH(CNode* pnode, vNodesCopy)
842 if (pnode->fDisconnect ||
843 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
845 // remove from vNodes
846 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
848 // close socket and cleanup
849 pnode->CloseSocketDisconnect();
852 // hold in disconnected pool until all refs are released
853 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
854 if (pnode->fNetworkNode || pnode->fInbound)
856 vNodesDisconnected.push_back(pnode);
860 // Delete disconnected nodes
861 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
862 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
864 // wait until threads are done using it
865 if (pnode->GetRefCount() <= 0)
867 bool fDelete = false;
868 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
869 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
870 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
871 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
875 vNodesDisconnected.remove(pnode);
881 if (vNodes.size() != nPrevNodeCount)
883 nPrevNodeCount = vNodes.size();
889 // Find which sockets have data to receive
891 struct timeval timeout;
893 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
900 FD_ZERO(&fdsetError);
901 SOCKET hSocketMax = 0;
903 if(hListenSocket != INVALID_SOCKET)
904 FD_SET(hListenSocket, &fdsetRecv);
905 hSocketMax = max(hSocketMax, hListenSocket);
906 CRITICAL_BLOCK(cs_vNodes)
908 BOOST_FOREACH(CNode* pnode, vNodes)
910 if (pnode->hSocket == INVALID_SOCKET)
912 FD_SET(pnode->hSocket, &fdsetRecv);
913 FD_SET(pnode->hSocket, &fdsetError);
914 hSocketMax = max(hSocketMax, pnode->hSocket);
915 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
916 if (!pnode->vSend.empty())
917 FD_SET(pnode->hSocket, &fdsetSend);
921 vnThreadsRunning[0]--;
922 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
923 vnThreadsRunning[0]++;
926 if (nSelect == SOCKET_ERROR)
928 int nErr = WSAGetLastError();
931 printf("socket select error %d\n", nErr);
932 for (int i = 0; i <= hSocketMax; i++)
933 FD_SET(i, &fdsetRecv);
936 FD_ZERO(&fdsetError);
937 Sleep(timeout.tv_usec/1000);
942 // Accept new connections
944 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
946 struct sockaddr_in sockaddr;
947 socklen_t len = sizeof(sockaddr);
948 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
949 CAddress addr(sockaddr);
952 CRITICAL_BLOCK(cs_vNodes)
953 BOOST_FOREACH(CNode* pnode, vNodes)
956 if (hSocket == INVALID_SOCKET)
958 if (WSAGetLastError() != WSAEWOULDBLOCK)
959 printf("socket error accept failed: %d\n", WSAGetLastError());
961 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
963 closesocket(hSocket);
965 else if (CNode::IsBanned(addr.ip))
967 printf("connetion from %s dropped (banned)\n", addr.ToString().c_str());
968 closesocket(hSocket);
972 printf("accepted connection %s\n", addr.ToString().c_str());
973 CNode* pnode = new CNode(hSocket, addr, true);
975 CRITICAL_BLOCK(cs_vNodes)
976 vNodes.push_back(pnode);
982 // Service each socket
984 vector<CNode*> vNodesCopy;
985 CRITICAL_BLOCK(cs_vNodes)
988 BOOST_FOREACH(CNode* pnode, vNodesCopy)
991 BOOST_FOREACH(CNode* pnode, vNodesCopy)
999 if (pnode->hSocket == INVALID_SOCKET)
1001 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
1003 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1005 CDataStream& vRecv = pnode->vRecv;
1006 unsigned int nPos = vRecv.size();
1008 if (nPos > ReceiveBufferSize()) {
1009 if (!pnode->fDisconnect)
1010 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
1011 pnode->CloseSocketDisconnect();
1014 // typical socket buffer is 8K-64K
1015 char pchBuf[0x10000];
1016 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1019 vRecv.resize(nPos + nBytes);
1020 memcpy(&vRecv[nPos], pchBuf, nBytes);
1021 pnode->nLastRecv = GetTime();
1023 else if (nBytes == 0)
1025 // socket closed gracefully
1026 if (!pnode->fDisconnect)
1027 printf("socket closed\n");
1028 pnode->CloseSocketDisconnect();
1030 else if (nBytes < 0)
1033 int nErr = WSAGetLastError();
1034 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1036 if (!pnode->fDisconnect)
1037 printf("socket recv error %d\n", nErr);
1038 pnode->CloseSocketDisconnect();
1048 if (pnode->hSocket == INVALID_SOCKET)
1050 if (FD_ISSET(pnode->hSocket, &fdsetSend))
1052 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1054 CDataStream& vSend = pnode->vSend;
1057 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
1060 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1061 pnode->nLastSend = GetTime();
1063 else if (nBytes < 0)
1066 int nErr = WSAGetLastError();
1067 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1069 printf("socket send error %d\n", nErr);
1070 pnode->CloseSocketDisconnect();
1073 if (vSend.size() > SendBufferSize()) {
1074 if (!pnode->fDisconnect)
1075 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1076 pnode->CloseSocketDisconnect();
1083 // Inactivity checking
1085 if (pnode->vSend.empty())
1086 pnode->nLastSendEmpty = GetTime();
1087 if (GetTime() - pnode->nTimeConnected > 60)
1089 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1091 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1092 pnode->fDisconnect = true;
1094 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1096 printf("socket not sending\n");
1097 pnode->fDisconnect = true;
1099 else if (GetTime() - pnode->nLastRecv > 90*60)
1101 printf("socket inactivity timeout\n");
1102 pnode->fDisconnect = true;
1106 CRITICAL_BLOCK(cs_vNodes)
1108 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1125 void ThreadMapPort(void* parg)
1127 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1130 vnThreadsRunning[5]++;
1131 ThreadMapPort2(parg);
1132 vnThreadsRunning[5]--;
1134 catch (std::exception& e) {
1135 vnThreadsRunning[5]--;
1136 PrintException(&e, "ThreadMapPort()");
1138 vnThreadsRunning[5]--;
1139 PrintException(NULL, "ThreadMapPort()");
1141 printf("ThreadMapPort exiting\n");
1144 void ThreadMapPort2(void* parg)
1146 printf("ThreadMapPort started\n");
1149 sprintf(port, "%d", GetListenPort());
1151 const char * rootdescurl = 0;
1152 const char * multicastif = 0;
1153 const char * minissdpdpath = 0;
1154 struct UPNPDev * devlist = 0;
1157 #ifndef UPNPDISCOVER_SUCCESS
1159 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1163 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1166 struct UPNPUrls urls;
1167 struct IGDdatas data;
1170 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1175 string strDesc = "Bitcoin " + FormatFullVersion();
1176 #ifndef UPNPDISCOVER_SUCCESS
1178 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1179 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1182 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1183 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1186 if(r!=UPNPCOMMAND_SUCCESS)
1187 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1188 port, port, lanaddr, r, strupnperror(r));
1190 printf("UPnP Port Mapping successful.\n");
1192 if (fShutdown || !fUseUPnP)
1194 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1195 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1196 freeUPNPDevlist(devlist); devlist = 0;
1197 FreeUPNPUrls(&urls);
1203 printf("No valid UPnP IGDs found\n");
1204 freeUPNPDevlist(devlist); devlist = 0;
1206 FreeUPNPUrls(&urls);
1208 if (fShutdown || !fUseUPnP)
1215 void MapPort(bool fMapPort)
1217 if (fUseUPnP != fMapPort)
1219 fUseUPnP = fMapPort;
1220 WriteSetting("fUseUPnP", fUseUPnP);
1222 if (fUseUPnP && vnThreadsRunning[5] < 1)
1224 if (!CreateThread(ThreadMapPort, NULL))
1225 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1229 void MapPort(bool /* unused fMapPort */)
1231 // Intentionally left blank.
1244 static const char *strDNSSeed[] = {
1246 "dnsseed.bluematt.me",
1247 "seed.bitcoin.sipa.be",
1248 "dnsseed.bitcoin.dashjr.org",
1251 void ThreadDNSAddressSeed(void* parg)
1253 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1256 vnThreadsRunning[6]++;
1257 ThreadDNSAddressSeed2(parg);
1258 vnThreadsRunning[6]--;
1260 catch (std::exception& e) {
1261 vnThreadsRunning[6]--;
1262 PrintException(&e, "ThreadDNSAddressSeed()");
1264 vnThreadsRunning[6]--;
1265 throw; // support pthread_cancel()
1267 printf("ThreadDNSAddressSeed exiting\n");
1270 void ThreadDNSAddressSeed2(void* parg)
1272 printf("ThreadDNSAddressSeed started\n");
1277 printf("Loading addresses from DNS seeds (could take a while)\n");
1279 for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1280 vector<CAddress> vaddr;
1281 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1285 BOOST_FOREACH (CAddress& addr, vaddr)
1287 if (addr.GetByte(3) != 127)
1290 AddAddress(addr, 0, &addrDB);
1294 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1299 printf("%d addresses found from DNS seeds\n", found);
1313 unsigned int pnSeed[] =
1315 0x6884ac63, 0x3ffecead, 0x2919b953, 0x0942fe50, 0x7a1d922e, 0xcdd6734a, 0x953a5bb6, 0x2c46922e,
1316 0xe2a5f143, 0xaa39103a, 0xa06afa5c, 0x135ffd59, 0xe8e82863, 0xf61ef029, 0xf75f042e, 0x2b363532,
1317 0x29b2df42, 0x16b1f64e, 0xd46e281b, 0x5280bf58, 0x60372229, 0x1be58e4f, 0xa8496f45, 0x1fb1a057,
1318 0x756b3844, 0x3bb79445, 0x0b375518, 0xcccb0102, 0xb682bf2e, 0x46431c02, 0x3a81073a, 0xa3771f1f,
1319 0x213a121f, 0x85dc2c1b, 0x56b4323b, 0xb34e8945, 0x3c40b33d, 0xfa276418, 0x1f818d29, 0xebe1e344,
1320 0xf6160a18, 0xf4fa384a, 0x34b09558, 0xb882b543, 0xe3ce2253, 0x6abf56d8, 0xe91b1155, 0x688ee6ad,
1321 0x2efc6058, 0x4792cd47, 0x0c32f757, 0x4c813a46, 0x8c93644a, 0x37507444, 0x813ad218, 0xdac06d4a,
1322 0xe4c63e4b, 0x21a1ea3c, 0x8d88556f, 0x30e9173a, 0x041f681b, 0xdc77ba50, 0xc0072753, 0xceddd44f,
1323 0x052d1743, 0xe3c77a4a, 0x13981c3a, 0x5685d918, 0x3c0e4e70, 0x3e56fb54, 0xb676ae0c, 0xac93c859,
1324 0x22279f43, 0x975a4542, 0xe527f071, 0xea162f2e, 0x3c65a32e, 0x5be5713b, 0x961ec418, 0xb202922e,
1325 0x5ef7be50, 0xce49f53e, 0x05803b47, 0x8463b055, 0x78576153, 0x3ec2ae3a, 0x4bbd7118, 0xafcee043,
1326 0x56a3e8ba, 0x6174de4d, 0x8d01ba4b, 0xc9af564e, 0xdbc9c547, 0xa627474d, 0xdada9244, 0xd3b3083a,
1327 0x523e071f, 0xd6b96f18, 0xbd527c46, 0xdf2bbb4d, 0xd37b4a4b, 0x3a6a2158, 0xc064b055, 0x18a8e055,
1328 0xec4dae3b, 0x0540416c, 0x475b4fbe, 0x064803b2, 0x48e9f062, 0x2898524b, 0xd315ff43, 0xf786d247,
1329 0xc7ea2f3e, 0xc087f043, 0xc163354b, 0x8250284d, 0xed300029, 0xbf36e05c, 0x8eb3ae4c, 0xe7aa623e,
1330 0x7ced0274, 0xdd362c1b, 0x362b995a, 0xca26b629, 0x3fc41618, 0xb97b364e, 0xa05b8729, 0x0f5e3c43,
1331 0xdf942618, 0x6aeb9b5b, 0xbf04762e, 0xfaaeb118, 0x87579958, 0x76520044, 0xc2660c5b, 0x628b201b,
1332 0xf193932e, 0x1c0ad045, 0xff908346, 0x8da9d4da, 0xed201c1f, 0xa47a2b1b, 0x330007d4, 0x8ba1ed47,
1333 0xb2f02d44, 0x7db62c1b, 0x781c454b, 0xc0300029, 0xb7062a45, 0x88b52e3a, 0x78dd6b63, 0x1cb9b718,
1334 0x5d358e47, 0x59912c3b, 0x79607544, 0x5197f759, 0xc023be48, 0xd1013743, 0x0f354057, 0x8e3aac3b,
1335 0x4114693e, 0x22316318, 0xe27dda50, 0x878eac3b, 0x4948a21f, 0x5db7f24c, 0x8ccb6157, 0x26a5de18,
1336 0x0a11bd43, 0x27bb1e41, 0x60a7a951, 0x3e16b35e, 0x07888b53, 0x5648a853, 0x0149fe50, 0xd070a34f,
1337 0x6454c96d, 0xd6e54758, 0xa96dc152, 0x65447861, 0xf6bdf95e, 0x10400202, 0x2c29d483, 0x18174732,
1338 0x1d840618, 0x12e61818, 0x089d3f3c, 0x917e931f, 0xd1b0c90e, 0x25bd3c42, 0xeb05775b, 0x7d550c59,
1339 0x6cfacb01, 0xe4224444, 0xa41dd943, 0x0f5aa643, 0x5e33731b, 0x81036d50, 0x6f46a0d1, 0x7731be43,
1340 0x14840e18, 0xf1e8d059, 0x661d2b1f, 0x40a3201b, 0x9407b843, 0xedf0254d, 0x7bd1a5bc, 0x073dbe51,
1341 0xe864a97b, 0x2efd947b, 0xb9ca0e45, 0x4e2113ad, 0xcc305731, 0xd39ca63c, 0x733df918, 0xda172b1f,
1342 0xaa03b34d, 0x7230fd4d, 0xf1ce6e3a, 0x2e9fab43, 0xa4010750, 0xa928bd18, 0x6809be42, 0xb19de348,
1343 0xff956270, 0x0d795f51, 0xd2dec247, 0x6df5774b, 0xbac11f79, 0xdfb05c75, 0x887683d8, 0xa1e83632,
1344 0x2c0f7671, 0x28bcb65d, 0xac2a7545, 0x3eebfc60, 0x304ad7c4, 0xa215a462, 0xc86f0f58, 0xcfb92ebe,
1345 0x5e23ed82, 0xf506184b, 0xec0f19b7, 0x060c59ad, 0x86ee3174, 0x85380774, 0xa199a562, 0x02b507ae,
1346 0x33eb2163, 0xf2112b1f, 0xb702ba50, 0x131b9618, 0x90ccd04a, 0x08f3273b, 0xecb61718, 0x64b8b44d,
1347 0x182bf4dc, 0xc7b68286, 0x6e318d5f, 0xfdb03654, 0xb3272e54, 0xe014ad4b, 0x274e4a31, 0x7806375c,
1348 0xbc34a748, 0x1b5ad94a, 0x6b54d10e, 0x73e2ae6e, 0x5529d483, 0x8455a76d, 0x99c13f47, 0x1d811741,
1349 0xa9782a78, 0x0b00464d, 0x7266ea50, 0x532dab46, 0x33e1413e, 0x780d0c18, 0x0fb0854e, 0x03370155,
1350 0x2693042e, 0xfa3d824a, 0x2bb1681b, 0x37ea2a18, 0x7fb8414b, 0x32e0713b, 0xacf38d3f, 0xa282716f,
1351 0xb1a09d7b, 0xa04b764b, 0x83c94d18, 0x05ee4c6d, 0x0e795f51, 0x46984352, 0xf80fc247, 0x3fccb946,
1352 0xd7ae244b, 0x0a8e0a4c, 0x57b141bc, 0x3647bed1, 0x1431b052, 0x803a8bbb, 0xfc69056b, 0xf5991862,
1353 0x14963b2e, 0xd35d5dda, 0xc6c73574, 0xc8f1405b, 0x0ca4224d, 0xecd36071, 0xa9461754, 0xe7a0ed72,
1354 0x559e8346, 0x1c9beec1, 0xc786ea4a, 0x9561b44d, 0x9788074d, 0x1a69934f, 0x23c5614c, 0x07c79d4b,
1355 0xc7ee52db, 0xc72df351, 0xcb135e44, 0xa0988346, 0xc211fc4c, 0x87dec34b, 0x1381074d, 0x04a65cb7,
1356 0x4409083a, 0x4a407a4c, 0x92b8d37d, 0xacf50b4d, 0xa58aa5bc, 0x448f801f, 0x9c83762e, 0x6fd5734a,
1357 0xfe2d454b, 0x84144c55, 0x05190e4c, 0xb2151448, 0x63867a3e, 0x16099018, 0x9c010d3c, 0x962d8f3d,
1358 0xd51ee453, 0x9d86801f, 0x68e87b47, 0x6bf7bb73, 0x5fc7910e, 0x10d90118, 0x3db04442, 0x729d3e4b,
1359 0xc397d842, 0x57bb15ad, 0x72f31f4e, 0xc9380043, 0x2bb24e18, 0xd9b8ab50, 0xb786801f, 0xf4dc4847,
1360 0x85f4bb51, 0x4435995b, 0x5ba07e40, 0x2c57392e, 0x3628124b, 0x9839b64b, 0x6fe8b24d, 0xaddce847,
1361 0x75260e45, 0x0c572a43, 0xfea21902, 0xb9f9742e, 0x5a70d443, 0x8fc5910e, 0x868d4744, 0x56245e02,
1362 0xd7eb5f02, 0x35c12c1b, 0x4373034b, 0x8786554c, 0xa6facf18, 0x4b11a31f, 0x3570664e, 0x5a64bc42,
1363 0x0b03983f, 0x8f457e4c, 0x0fd874c3, 0xb6cf31b2, 0x2bbc2d4e, 0x146ca5b2, 0x9d00b150, 0x048a4153,
1364 0xca4dcd43, 0xc1607cca, 0x8234cf57, 0x9c7daead, 0x3dc07658, 0xea5c6e4c, 0xf1a0084e, 0x16d2ee53,
1365 0x1b849418, 0xfe913a47, 0x1e988f62, 0x208b644c, 0xc55ee980, 0xbdbce747, 0xf59a384e, 0x0f56091b,
1366 0x7417b745, 0x0c37344e, 0x2c62ab47, 0xf8533a4d, 0x8030084d, 0x76b93c4b, 0xda6ea0ad, 0x3c54f618,
1367 0x63b0de1f, 0x7370d858, 0x1a70bb4c, 0xdda63b2e, 0x60b2ba50, 0x1ba7d048, 0xbe1b2c1b, 0xabea5747,
1368 0x29ad2e4d, 0xe8cd7642, 0x66c80e18, 0x138bf34a, 0xc6145e44, 0x2586794c, 0x07bc5478, 0x0da0b14d,
1369 0x8f95354e, 0x9eb11c62, 0xa1545e46, 0x2e7a2602, 0x408c9c3d, 0x59065d55, 0xf51d1a4c, 0x3bbc6a4e,
1370 0xc71b2a2e, 0xcdaaa545, 0x17d659d0, 0x5202e7ad, 0xf1b68445, 0x93375961, 0xbd88a043, 0x066ad655,
1371 0x890f6318, 0x7b7dca47, 0x99bdd662, 0x3bb4fc53, 0x1231efdc, 0xc0a99444, 0x96bbea47, 0x61ed8748,
1372 0x27dfa73b, 0x8d4d1754, 0x3460042e, 0x551f0c4c, 0x8d0e0718, 0x162ddc53, 0x53231718, 0x1ecd65d0,
1373 0x944d28bc, 0x3b79d058, 0xaff97fbc, 0x4860006c, 0xc101c90e, 0xace41743, 0xa5975d4c, 0x5cc2703e,
1374 0xb55a4450, 0x02d18840, 0xee2765ae, 0xd6012fd5, 0x24c94d7d, 0x8c6eec47, 0x7520ba5d, 0x9e15e460,
1375 0x8510b04c, 0x75ec3847, 0x1dfa6661, 0xe172b3ad, 0x5744c90e, 0x52a0a152, 0x8d6fad18, 0x67b74b6d,
1376 0x93a089b2, 0x0f3ac5d5, 0xe5de1855, 0x43d25747, 0x4bad804a, 0x55b408d8, 0x60a36441, 0xf553e860,
1377 0xdb2fa2c8, 0x03152b32, 0xdd27a7d5, 0x3116a8b8, 0x0a1d708c, 0xeee2f13c, 0x6acf436f, 0xce6eb4ca,
1378 0x101cd3d9, 0x1c48a6b8, 0xe57d6f44, 0x93dcf562,
1383 void ThreadOpenConnections(void* parg)
1385 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1388 vnThreadsRunning[1]++;
1389 ThreadOpenConnections2(parg);
1390 vnThreadsRunning[1]--;
1392 catch (std::exception& e) {
1393 vnThreadsRunning[1]--;
1394 PrintException(&e, "ThreadOpenConnections()");
1396 vnThreadsRunning[1]--;
1397 PrintException(NULL, "ThreadOpenConnections()");
1399 printf("ThreadOpenConnections exiting\n");
1402 void ThreadOpenConnections2(void* parg)
1404 printf("ThreadOpenConnections started\n");
1406 // Connect to specific addresses
1407 if (mapArgs.count("-connect"))
1409 for (int64 nLoop = 0;; nLoop++)
1411 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1413 CAddress addr(strAddr, fAllowDNS);
1415 OpenNetworkConnection(addr);
1416 for (int i = 0; i < 10 && i < nLoop; i++)
1426 // Connect to manually added nodes first
1427 if (mapArgs.count("-addnode"))
1429 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1431 CAddress addr(strAddr, fAllowDNS);
1434 OpenNetworkConnection(addr);
1442 // Initiate network connections
1443 int64 nStart = GetTime();
1446 // Limit outbound connections
1447 vnThreadsRunning[1]--;
1452 CRITICAL_BLOCK(cs_vNodes)
1453 BOOST_FOREACH(CNode* pnode, vNodes)
1454 if (!pnode->fInbound)
1456 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1457 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1458 if (nOutbound < nMaxOutboundConnections)
1464 vnThreadsRunning[1]++;
1468 bool fAddSeeds = false;
1470 CRITICAL_BLOCK(cs_mapAddresses)
1472 // Add seed nodes if IRC isn't working
1473 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1474 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
1480 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1482 // It'll only connect to one or two seed nodes because once it connects,
1483 // it'll get a pile of addresses with newer timestamps.
1484 // Seed nodes are given a random 'last seen time' of between one and two
1486 const int64 nOneWeek = 7*24*60*60;
1488 addr.ip = pnSeed[i];
1489 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1495 // Choose an address to connect to based on most recently seen
1497 CAddress addrConnect;
1498 int64 nBest = std::numeric_limits<int64>::min();
1500 // Only connect to one address per a.b.?.? range.
1501 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1502 set<unsigned int> setConnected;
1503 CRITICAL_BLOCK(cs_vNodes)
1504 BOOST_FOREACH(CNode* pnode, vNodes)
1505 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1507 int64 nANow = GetAdjustedTime();
1509 CRITICAL_BLOCK(cs_mapAddresses)
1511 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1513 const CAddress& addr = item.second;
1514 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1516 int64 nSinceLastSeen = nANow - addr.nTime;
1517 int64 nSinceLastTry = nANow - addr.nLastTry;
1519 // Randomize the order in a deterministic way, putting the standard port first
1520 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1521 if (addr.port != htons(GetDefaultPort()))
1522 nRandomizer += 2 * 60 * 60;
1524 // Last seen Base retry frequency
1533 // 365 days 93 hours
1534 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1536 // Fast reconnect for one hour after last seen
1537 if (nSinceLastSeen < 60 * 60)
1540 // Limit retry frequency
1541 if (nSinceLastTry < nDelay)
1544 // If we have IRC, we'll be notified when they first come online,
1545 // and again every 24 hours by the refresh broadcast.
1546 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1549 // Only try the old stuff if we don't have enough connections
1550 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1553 // If multiple addresses are ready, prioritize by time since
1554 // last seen and time since last tried.
1555 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1564 if (addrConnect.IsValid())
1565 OpenNetworkConnection(addrConnect);
1569 bool OpenNetworkConnection(const CAddress& addrConnect)
1572 // Initiate outbound network connection
1576 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
1577 FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
1580 vnThreadsRunning[1]--;
1581 CNode* pnode = ConnectNode(addrConnect);
1582 vnThreadsRunning[1]++;
1587 pnode->fNetworkNode = true;
1599 void ThreadMessageHandler(void* parg)
1601 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1604 vnThreadsRunning[2]++;
1605 ThreadMessageHandler2(parg);
1606 vnThreadsRunning[2]--;
1608 catch (std::exception& e) {
1609 vnThreadsRunning[2]--;
1610 PrintException(&e, "ThreadMessageHandler()");
1612 vnThreadsRunning[2]--;
1613 PrintException(NULL, "ThreadMessageHandler()");
1615 printf("ThreadMessageHandler exiting\n");
1618 void ThreadMessageHandler2(void* parg)
1620 printf("ThreadMessageHandler started\n");
1621 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1624 vector<CNode*> vNodesCopy;
1625 CRITICAL_BLOCK(cs_vNodes)
1627 vNodesCopy = vNodes;
1628 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1632 // Poll the connected nodes for messages
1633 CNode* pnodeTrickle = NULL;
1634 if (!vNodesCopy.empty())
1635 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1636 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1639 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1640 ProcessMessages(pnode);
1645 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1646 SendMessages(pnode, pnode == pnodeTrickle);
1651 CRITICAL_BLOCK(cs_vNodes)
1653 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1657 // Wait and allow messages to bunch up.
1658 // Reduce vnThreadsRunning so StopNode has permission to exit while
1659 // we're sleeping, but we must always check fShutdown after doing this.
1660 vnThreadsRunning[2]--;
1662 if (fRequestShutdown)
1664 vnThreadsRunning[2]++;
1675 bool BindListenPort(string& strError)
1679 addrLocalHost.port = htons(GetListenPort());
1682 // Initialize Windows Sockets
1684 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1685 if (ret != NO_ERROR)
1687 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1688 printf("%s\n", strError.c_str());
1693 // Create socket for listening for incoming connections
1694 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1695 if (hListenSocket == INVALID_SOCKET)
1697 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1698 printf("%s\n", strError.c_str());
1703 // Different way of disabling SIGPIPE on BSD
1704 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1708 // Allow binding if the port is still in TIME_WAIT state after
1709 // the program was closed and restarted. Not an issue on windows.
1710 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1714 // Set to nonblocking, incoming connections will also inherit this
1715 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1717 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1720 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1721 printf("%s\n", strError.c_str());
1725 // The sockaddr_in structure specifies the address family,
1726 // IP address, and port for the socket that is being bound
1727 struct sockaddr_in sockaddr;
1728 memset(&sockaddr, 0, sizeof(sockaddr));
1729 sockaddr.sin_family = AF_INET;
1730 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1731 sockaddr.sin_port = htons(GetListenPort());
1732 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1734 int nErr = WSAGetLastError();
1735 if (nErr == WSAEADDRINUSE)
1736 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1738 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1739 printf("%s\n", strError.c_str());
1742 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1744 // Listen for incoming connections
1745 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1747 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1748 printf("%s\n", strError.c_str());
1755 void StartNode(void* parg)
1757 if (pnodeLocalHost == NULL)
1758 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1761 // Get local host ip
1762 char pszHostName[1000] = "";
1763 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1765 vector<CAddress> vaddr;
1766 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1767 BOOST_FOREACH (const CAddress &addr, vaddr)
1768 if (addr.GetByte(3) != 127)
1770 addrLocalHost = addr;
1775 // Get local host ip
1776 struct ifaddrs* myaddrs;
1777 if (getifaddrs(&myaddrs) == 0)
1779 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1781 if (ifa->ifa_addr == NULL) continue;
1782 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1783 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1784 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1786 if (ifa->ifa_addr->sa_family == AF_INET)
1788 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1789 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1790 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1792 // Take the first IP that isn't loopback 127.x.x.x
1793 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1794 if (addr.IsValid() && addr.GetByte(3) != 127)
1796 addrLocalHost = addr;
1800 else if (ifa->ifa_addr->sa_family == AF_INET6)
1802 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1803 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1804 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1807 freeifaddrs(myaddrs);
1810 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1812 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1814 // Proxies can't take incoming connections
1815 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1816 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1820 CreateThread(ThreadGetMyExternalIP, NULL);
1827 if (GetBoolArg("-nodnsseed"))
1828 printf("DNS seeding disabled\n");
1830 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1831 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1833 // Map ports with UPnP
1837 // Get addresses from IRC and advertise ours
1838 if (!CreateThread(ThreadIRCSeed, NULL))
1839 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1841 // Send and receive from sockets, accept connections
1842 if (!CreateThread(ThreadSocketHandler, NULL))
1843 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1845 // Initiate outbound connections
1846 if (!CreateThread(ThreadOpenConnections, NULL))
1847 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1850 if (!CreateThread(ThreadMessageHandler, NULL))
1851 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1853 // Generate coins in the background
1854 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1859 printf("StopNode()\n");
1861 nTransactionsUpdated++;
1862 int64 nStart = GetTime();
1863 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1865 || vnThreadsRunning[5] > 0
1869 if (GetTime() - nStart > 20)
1873 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1874 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1875 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1876 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1877 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1878 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1879 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1880 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1896 BOOST_FOREACH(CNode* pnode, vNodes)
1897 if (pnode->hSocket != INVALID_SOCKET)
1898 closesocket(pnode->hSocket);
1899 if (hListenSocket != INVALID_SOCKET)
1900 if (closesocket(hListenSocket) == SOCKET_ERROR)
1901 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1904 // Shutdown Windows Sockets
1909 instance_of_cnetcleanup;