1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2012 The Bitcoin developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file 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 > USHRT_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) != string::npos)
321 strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
325 closesocket(hSocket);
326 if (strLine.find("<") != string::npos)
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;
723 void CNode::Cleanup()
725 // All of a nodes broadcasts and subscriptions are automatically torn down
726 // when it goes down, so a node has to stay up to keep its broadcast going.
728 // Cancel subscriptions
729 for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
730 if (vfSubscribe[nChannel])
731 CancelSubscribe(nChannel);
746 void ThreadSocketHandler(void* parg)
748 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
751 vnThreadsRunning[0]++;
752 ThreadSocketHandler2(parg);
753 vnThreadsRunning[0]--;
755 catch (std::exception& e) {
756 vnThreadsRunning[0]--;
757 PrintException(&e, "ThreadSocketHandler()");
759 vnThreadsRunning[0]--;
760 throw; // support pthread_cancel()
762 printf("ThreadSocketHandler exiting\n");
765 void ThreadSocketHandler2(void* parg)
767 printf("ThreadSocketHandler started\n");
768 list<CNode*> vNodesDisconnected;
769 int nPrevNodeCount = 0;
776 CRITICAL_BLOCK(cs_vNodes)
778 // Disconnect unused nodes
779 vector<CNode*> vNodesCopy = vNodes;
780 BOOST_FOREACH(CNode* pnode, vNodesCopy)
782 if (pnode->fDisconnect ||
783 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
785 // remove from vNodes
786 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
788 // close socket and cleanup
789 pnode->CloseSocketDisconnect();
792 // hold in disconnected pool until all refs are released
793 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
794 if (pnode->fNetworkNode || pnode->fInbound)
796 vNodesDisconnected.push_back(pnode);
800 // Delete disconnected nodes
801 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
802 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
804 // wait until threads are done using it
805 if (pnode->GetRefCount() <= 0)
807 bool fDelete = false;
808 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
809 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
810 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
811 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
815 vNodesDisconnected.remove(pnode);
821 if (vNodes.size() != nPrevNodeCount)
823 nPrevNodeCount = vNodes.size();
829 // Find which sockets have data to receive
831 struct timeval timeout;
833 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
840 FD_ZERO(&fdsetError);
841 SOCKET hSocketMax = 0;
843 if(hListenSocket != INVALID_SOCKET)
844 FD_SET(hListenSocket, &fdsetRecv);
845 hSocketMax = max(hSocketMax, hListenSocket);
846 CRITICAL_BLOCK(cs_vNodes)
848 BOOST_FOREACH(CNode* pnode, vNodes)
850 if (pnode->hSocket == INVALID_SOCKET)
852 FD_SET(pnode->hSocket, &fdsetRecv);
853 FD_SET(pnode->hSocket, &fdsetError);
854 hSocketMax = max(hSocketMax, pnode->hSocket);
855 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
856 if (!pnode->vSend.empty())
857 FD_SET(pnode->hSocket, &fdsetSend);
861 vnThreadsRunning[0]--;
862 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
863 vnThreadsRunning[0]++;
866 if (nSelect == SOCKET_ERROR)
868 int nErr = WSAGetLastError();
871 printf("socket select error %d\n", nErr);
872 for (int i = 0; i <= hSocketMax; i++)
873 FD_SET(i, &fdsetRecv);
876 FD_ZERO(&fdsetError);
877 Sleep(timeout.tv_usec/1000);
882 // Accept new connections
884 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
886 struct sockaddr_in sockaddr;
887 socklen_t len = sizeof(sockaddr);
888 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
892 if (hSocket != INVALID_SOCKET)
893 addr = CAddress(sockaddr);
895 CRITICAL_BLOCK(cs_vNodes)
896 BOOST_FOREACH(CNode* pnode, vNodes)
900 if (hSocket == INVALID_SOCKET)
902 if (WSAGetLastError() != WSAEWOULDBLOCK)
903 printf("socket error accept failed: %d\n", WSAGetLastError());
905 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
907 closesocket(hSocket);
911 printf("accepted connection %s\n", addr.ToString().c_str());
912 CNode* pnode = new CNode(hSocket, addr, true);
914 CRITICAL_BLOCK(cs_vNodes)
915 vNodes.push_back(pnode);
921 // Service each socket
923 vector<CNode*> vNodesCopy;
924 CRITICAL_BLOCK(cs_vNodes)
927 BOOST_FOREACH(CNode* pnode, vNodesCopy)
930 BOOST_FOREACH(CNode* pnode, vNodesCopy)
938 if (pnode->hSocket == INVALID_SOCKET)
940 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
942 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
944 CDataStream& vRecv = pnode->vRecv;
945 unsigned int nPos = vRecv.size();
947 if (nPos > ReceiveBufferSize()) {
948 if (!pnode->fDisconnect)
949 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
950 pnode->CloseSocketDisconnect();
953 // typical socket buffer is 8K-64K
954 char pchBuf[0x10000];
955 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
958 vRecv.resize(nPos + nBytes);
959 memcpy(&vRecv[nPos], pchBuf, nBytes);
960 pnode->nLastRecv = GetTime();
962 else if (nBytes == 0)
964 // socket closed gracefully
965 if (!pnode->fDisconnect)
966 printf("socket closed\n");
967 pnode->CloseSocketDisconnect();
972 int nErr = WSAGetLastError();
973 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
975 if (!pnode->fDisconnect)
976 printf("socket recv error %d\n", nErr);
977 pnode->CloseSocketDisconnect();
987 if (pnode->hSocket == INVALID_SOCKET)
989 if (FD_ISSET(pnode->hSocket, &fdsetSend))
991 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
993 CDataStream& vSend = pnode->vSend;
996 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
999 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1000 pnode->nLastSend = GetTime();
1002 else if (nBytes < 0)
1005 int nErr = WSAGetLastError();
1006 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1008 printf("socket send error %d\n", nErr);
1009 pnode->CloseSocketDisconnect();
1012 if (vSend.size() > SendBufferSize()) {
1013 if (!pnode->fDisconnect)
1014 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1015 pnode->CloseSocketDisconnect();
1022 // Inactivity checking
1024 if (pnode->vSend.empty())
1025 pnode->nLastSendEmpty = GetTime();
1026 if (GetTime() - pnode->nTimeConnected > 60)
1028 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1030 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1031 pnode->fDisconnect = true;
1033 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1035 printf("socket not sending\n");
1036 pnode->fDisconnect = true;
1038 else if (GetTime() - pnode->nLastRecv > 90*60)
1040 printf("socket inactivity timeout\n");
1041 pnode->fDisconnect = true;
1045 CRITICAL_BLOCK(cs_vNodes)
1047 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1064 void ThreadMapPort(void* parg)
1066 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1069 vnThreadsRunning[5]++;
1070 ThreadMapPort2(parg);
1071 vnThreadsRunning[5]--;
1073 catch (std::exception& e) {
1074 vnThreadsRunning[5]--;
1075 PrintException(&e, "ThreadMapPort()");
1077 vnThreadsRunning[5]--;
1078 PrintException(NULL, "ThreadMapPort()");
1080 printf("ThreadMapPort exiting\n");
1083 void ThreadMapPort2(void* parg)
1085 printf("ThreadMapPort started\n");
1088 sprintf(port, "%d", GetListenPort());
1090 const char * multicastif = 0;
1091 const char * minissdpdpath = 0;
1092 struct UPNPDev * devlist = 0;
1095 #ifndef UPNPDISCOVER_SUCCESS
1097 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1101 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1104 struct UPNPUrls urls;
1105 struct IGDdatas data;
1108 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1111 if (!addrLocalHost.IsRoutable())
1113 char externalIPAddress[40];
1114 r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1115 if(r != UPNPCOMMAND_SUCCESS)
1116 printf("UPnP: GetExternalIPAddress() returned %d\n", r);
1119 if(externalIPAddress[0])
1121 printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1122 CAddress addrExternalFromUPnP(externalIPAddress, 0, false, nLocalServices);
1123 if (addrExternalFromUPnP.IsRoutable())
1124 addrLocalHost = addrExternalFromUPnP;
1127 printf("UPnP: GetExternalIPAddress failed.\n");
1131 string strDesc = "Bitcoin " + FormatFullVersion();
1132 #ifndef UPNPDISCOVER_SUCCESS
1134 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1135 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1138 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1139 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1142 if(r!=UPNPCOMMAND_SUCCESS)
1143 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1144 port, port, lanaddr, r, strupnperror(r));
1146 printf("UPnP Port Mapping successful.\n");
1149 if (fShutdown || !fUseUPnP)
1151 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1152 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1153 freeUPNPDevlist(devlist); devlist = 0;
1154 FreeUPNPUrls(&urls);
1157 if (i % 600 == 0) // Refresh every 20 minutes
1159 #ifndef UPNPDISCOVER_SUCCESS
1161 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1162 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1165 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1166 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1169 if(r!=UPNPCOMMAND_SUCCESS)
1170 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1171 port, port, lanaddr, r, strupnperror(r));
1173 printf("UPnP Port Mapping successful.\n");;
1179 printf("No valid UPnP IGDs found\n");
1180 freeUPNPDevlist(devlist); devlist = 0;
1182 FreeUPNPUrls(&urls);
1184 if (fShutdown || !fUseUPnP)
1191 void MapPort(bool fMapPort)
1193 if (fUseUPnP != fMapPort)
1195 fUseUPnP = fMapPort;
1196 WriteSetting("fUseUPnP", fUseUPnP);
1198 if (fUseUPnP && vnThreadsRunning[5] < 1)
1200 if (!CreateThread(ThreadMapPort, NULL))
1201 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1205 void MapPort(bool /* unused fMapPort */)
1207 // Intentionally left blank.
1220 static const char *strDNSSeed[] = {
1222 "dnsseed.bluematt.me",
1223 "seed.bitcoin.sipa.be",
1224 "dnsseed.bitcoin.dashjr.org",
1227 void ThreadDNSAddressSeed(void* parg)
1229 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1232 vnThreadsRunning[6]++;
1233 ThreadDNSAddressSeed2(parg);
1234 vnThreadsRunning[6]--;
1236 catch (std::exception& e) {
1237 vnThreadsRunning[6]--;
1238 PrintException(&e, "ThreadDNSAddressSeed()");
1240 vnThreadsRunning[6]--;
1241 throw; // support pthread_cancel()
1243 printf("ThreadDNSAddressSeed exiting\n");
1246 void ThreadDNSAddressSeed2(void* parg)
1248 printf("ThreadDNSAddressSeed started\n");
1253 printf("Loading addresses from DNS seeds (could take a while)\n");
1255 for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1256 vector<CAddress> vaddr;
1257 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1261 BOOST_FOREACH (CAddress& addr, vaddr)
1263 if (addr.GetByte(3) != 127)
1266 AddAddress(addr, 0, &addrDB);
1270 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1275 printf("%d addresses found from DNS seeds\n", found);
1289 unsigned int pnSeed[] =
1291 0x959bd347, 0xf8de42b2, 0x73bc0518, 0xea6edc50, 0x21b00a4d, 0xc725b43d, 0xd665464d, 0x1a2a770e,
1292 0x27c93946, 0x65b2fa46, 0xb80ae255, 0x66b3b446, 0xb1877a3e, 0x6ee89e3e, 0xc3175b40, 0x2a01a83c,
1293 0x95b1363a, 0xa079ad3d, 0xe6ca801f, 0x027f4f4a, 0x34f7f03a, 0xf790f04a, 0x16ca801f, 0x2f4d5e40,
1294 0x3a4d5e40, 0xc43a322e, 0xc8159753, 0x14d4724c, 0x7919a118, 0xe0bdb34e, 0x68a16b2e, 0xff64b44d,
1295 0x6099115b, 0x9b57b05b, 0x7bd1b4ad, 0xdf95944f, 0x29d2b73d, 0xafa8db79, 0xe247ba41, 0x24078348,
1296 0xf722f03c, 0x33567ebc, 0xace64ed4, 0x984d3932, 0xb5f34e55, 0x27b7024d, 0x94579247, 0x8894042e,
1297 0x9357d34c, 0x1063c24b, 0xcaa228b1, 0xa3c5a8b2, 0x5dc64857, 0xa2c23643, 0xa8369a54, 0x31203077,
1298 0x00707c5c, 0x09fc0b3a, 0x272e9e2e, 0xf80f043e, 0x9449ca3e, 0x5512c33e, 0xd106b555, 0xe8024157,
1299 0xe288ec29, 0xc79c5461, 0xafb63932, 0xdb02ab4b, 0x0e512777, 0x8a145a4c, 0xb201ff4f, 0x5e09314b,
1300 0xcd9bfbcd, 0x1c023765, 0x4394e75c, 0xa728bd4d, 0x65331552, 0xa98420b1, 0x89ecf559, 0x6e80801f,
1301 0xf404f118, 0xefd62b51, 0x05918346, 0x9b186d5f, 0xacabab46, 0xf912e255, 0xc188ea62, 0xcc55734e,
1302 0xc668064d, 0xd77a4558, 0x46201c55, 0xf17dfc80, 0xf7142f2e, 0x87bfb718, 0x8aa54fb2, 0xc451d518,
1303 0xc4ae8831, 0x8dd44d55, 0x5bbd206c, 0x64536b5d, 0x5c667e60, 0x3b064242, 0xfe963a42, 0xa28e6dc8,
1304 0xe8a9604a, 0xc989464e, 0xd124a659, 0x50065140, 0xa44dfe5e, 0x1079e655, 0x3fb986d5, 0x47895b18,
1305 0x7d3ce4ad, 0x4561ba50, 0x296eec62, 0x255b41ad, 0xaed35ec9, 0x55556f12, 0xc7d3154d, 0x3297b65d,
1306 0x8930121f, 0xabf42e4e, 0x4a29e044, 0x1212685d, 0x676c1e40, 0xce009744, 0x383a8948, 0xa2dbd0ad,
1307 0xecc2564d, 0x07dbc252, 0x887ee24b, 0x5171644c, 0x6bb798c1, 0x847f495d, 0x4cbb7145, 0x3bb81c32,
1308 0x45eb262e, 0xc8015a4e, 0x250a361b, 0xf694f946, 0xd64a183e, 0xd4f1dd59, 0x8f20ffd4, 0x51d9e55c,
1309 0x09521763, 0x5e02002e, 0x32c8074d, 0xe685762e, 0x8290b0bc, 0x762a922e, 0xfc5ee754, 0x83a24829,
1310 0x775b224d, 0x6295bb4d, 0x38ec0555, 0xbffbba50, 0xe5560260, 0x86b16a7c, 0xd372234e, 0x49a3c24b,
1311 0x2f6a171f, 0x4d75ed60, 0xae94115b, 0xcb543744, 0x63080c59, 0x3f9c724c, 0xc977ce18, 0x532efb18,
1312 0x69dc3b2e, 0x5f94d929, 0x1732bb4d, 0x9c814b4d, 0xe6b3762e, 0xc024f662, 0x8face35b, 0x6b5b044d,
1313 0x798c7b57, 0x79a6b44c, 0x067d3057, 0xf9e94e5f, 0x91cbe15b, 0x71405eb2, 0x2662234e, 0xcbcc4a6d,
1314 0xbf69d54b, 0xa79b4e55, 0xec6d3e51, 0x7c0b3c02, 0x60f83653, 0x24c1e15c, 0x1110b62e, 0x10350f59,
1315 0xa56f1d55, 0x3509e7a9, 0xeb128354, 0x14268e2e, 0x934e28bc, 0x8e32692e, 0x8331a21f, 0x3e633932,
1316 0xc812b12e, 0xc684bf2e, 0x80112d2e, 0xe0ddc96c, 0xc630ca4a, 0x5c09b3b2, 0x0b580518, 0xc8e9d54b,
1317 0xd169aa43, 0x17d0d655, 0x1d029963, 0x7ff87559, 0xcb701f1f, 0x6fa3e85d, 0xe45e9a54, 0xf05d1802,
1318 0x44d03b2e, 0x837b692e, 0xccd4354e, 0x3d6da13c, 0x3423084d, 0xf707c34a, 0x55f6db3a, 0xad26e442,
1319 0x6233a21f, 0x09e80e59, 0x8caeb54d, 0xbe870941, 0xb407d20e, 0x20b51018, 0x56fb152e, 0x460d2a4e,
1320 0xbb9a2946, 0x560eb12e, 0xed83dd29, 0xd6724f53, 0xa50aafb8, 0x451346d9, 0x88348e2e, 0x7312fead,
1321 0x8ecaf96f, 0x1bda4e5f, 0xf1671e40, 0x3c8c3e3b, 0x4716324d, 0xdde24ede, 0xf98cd17d, 0xa91d4644,
1322 0x28124eb2, 0x147d5129, 0xd022042e, 0x61733d3b, 0xad0d5e02, 0x8ce2932e, 0xe5c18502, 0x549c1e32,
1323 0x9685801f, 0x86e217ad, 0xd948214b, 0x4110f462, 0x3a2e894e, 0xbd35492e, 0x87e0d558, 0x64b8ef7d,
1324 0x7c3eb962, 0x72a84b3e, 0x7cd667c9, 0x28370a2e, 0x4bc60e7b, 0x6fc1ec60, 0x14a6983f, 0x86739a4b,
1325 0x46954e5f, 0x32e2e15c, 0x2e9326cf, 0xe5801c5e, 0x379607b2, 0x32151145, 0xf0e39744, 0xacb54c55,
1326 0xa37dfb60, 0x83b55cc9, 0x388f7ca5, 0x15034f5f, 0x3e94965b, 0x68e0ffad, 0x35280f59, 0x8fe190cf,
1327 0x7c6ba5b2, 0xa5e9db43, 0x4ee1fc60, 0xd9d94e5f, 0x04040677, 0x0ea9b35e, 0x5961f14f, 0x67fda063,
1328 0xa48a5a31, 0xc6524e55, 0x283d325e, 0x3f37515f, 0x96b94b3e, 0xacce620e, 0x6481cc5b, 0xa4a06d4b,
1329 0x9e95d2d9, 0xe40c03d5, 0xc2f4514b, 0xb79aad44, 0xf64be843, 0xb2064070, 0xfca00455, 0x429dfa4e,
1330 0x2323f173, 0xeda4185e, 0xabd5227d, 0x9efd4d58, 0xb1104758, 0x4811e955, 0xbd9ab355, 0xe921f44b,
1331 0x9f166dce, 0x09e279b2, 0xe0c9ac7b, 0x7901a5ad, 0xa145d4b0, 0x79104671, 0xec31e35a, 0x4fe0b555,
1332 0xc7d9cbad, 0xad057f55, 0xe94cc759, 0x7fe0b043, 0xe4529f2e, 0x0d4dd4b2, 0x9f11a54d, 0x031e2e4e,
1333 0xe6014f5f, 0x11d1ca6c, 0x26bd7f61, 0xeb86854f, 0x4d347b57, 0x116bbe2e, 0xdba7234e, 0x7bcbfd2e,
1334 0x174dd4b2, 0x6686762e, 0xb089ba50, 0xc6258246, 0x087e767b, 0xc4a8cb4a, 0x595dba50, 0x7f0ae502,
1335 0x7b1dbd5a, 0xa0603492, 0x57d1af4b, 0x9e21ffd4, 0x6393064d, 0x7407376e, 0xe484762e, 0x122a4e53,
1336 0x4a37aa43, 0x3888a6be, 0xee77864e, 0x039c8dd5, 0x688d89af, 0x0e988f62, 0x08218246, 0xfc2f8246,
1337 0xd1d97040, 0xd64cd4b2, 0x5ae4a6b8, 0x7d0de9bc, 0x8d304d61, 0x06c5c672, 0xa4c8bd4d, 0xe0fd373b,
1338 0x575ebe4d, 0x72d26277, 0x55570f55, 0x77b154d9, 0xe214293a, 0xfc740f4b, 0xfe3f6a57, 0xa9c55f02,
1339 0xae4054db, 0x2394d918, 0xb511b24a, 0xb8741ab2, 0x0758e65e, 0xc7b5795b, 0xb0a30a4c, 0xaf7f170c,
1340 0xf3b4762e, 0x8179576d, 0x738a1581, 0x4b95b64c, 0x9829b618, 0x1bea932e, 0x7bdeaa4b, 0xcb5e0281,
1341 0x65618f54, 0x0658474b, 0x27066acf, 0x40556d65, 0x7d204d53, 0xf28bc244, 0xdce23455, 0xadc0ff54,
1342 0x3863c948, 0xcee34e5f, 0xdeb85e02, 0x2ed17a61, 0x6a7b094d, 0x7f0cfc40, 0x59603f54, 0x3220afbc,
1343 0xb5dfd962, 0x125d21c0, 0x13f8d243, 0xacfefb4e, 0x86c2c147, 0x3d8bbd59, 0xbd02a21f, 0x2593042e,
1344 0xc6a17a7c, 0x28925861, 0xb487ed44, 0xb5f4fd6d, 0x90c28a45, 0x5a14f74d, 0x43d71b4c, 0x728ebb5d,
1345 0x885bf950, 0x08134dd0, 0x38ec046e, 0xc575684b, 0x50082d2e, 0xa2f47757, 0x270f86ae, 0xf3ff6462,
1346 0x10ed3f4e, 0x4b58d462, 0xe01ce23e, 0x8c5b092e, 0x63e52f4e, 0x22c1e85d, 0xa908f54e, 0x8591624f,
1347 0x2c0fb94e, 0xa280ba3c, 0xb6f41b4c, 0x24f9aa47, 0x27201647, 0x3a3ea6dc, 0xa14fc3be, 0x3c34bdd5,
1348 0x5b8d4f5b, 0xaadeaf4b, 0xc71cab50, 0x15697a4c, 0x9a1a734c, 0x2a037d81, 0x2590bd59, 0x48ec2741,
1349 0x53489c5b, 0x7f00314b, 0x2170d362, 0xf2e92542, 0x42c10b44, 0x98f0f118, 0x883a3456, 0x099a932e,
1350 0xea38f7bc, 0x644e9247, 0xbb61b62e, 0x30e0863d, 0x5f51be54, 0x207215c7, 0x5f306c45, 0xaa7f3932,
1351 0x98da7d45, 0x4e339b59, 0x2e411581, 0xa808f618, 0xad2c0c59, 0x54476741, 0x09e99fd1, 0x5db8f752,
1352 0xc16df8bd, 0x1dd4b44f, 0x106edf2e, 0x9e15c180, 0x2ad6b56f, 0x633a5332, 0xff33787c, 0x077cb545,
1353 0x6610be6d, 0x75aad2c4, 0x72fb4d5b, 0xe81e0f59, 0x576f6332, 0x47333373, 0x351ed783, 0x2d90fb50,
1354 0x8d5e0f6c, 0x5b27a552, 0xdb293ebb, 0xe55ef950, 0x4b133ad8, 0x75df975a, 0x7b6a8740, 0xa899464b,
1355 0xfab15161, 0x10f8b64d, 0xd055ea4d, 0xee8e146b, 0x4b14afb8, 0x4bc1c44a, 0x9b961dcc, 0xd111ff43,
1356 0xfca0b745, 0xc800e412, 0x0afad9d1, 0xf751c350, 0xf9f0cccf, 0xa290a545, 0x8ef13763, 0x7ec70d59,
1357 0x2b066acf, 0x65496c45, 0xade02c1b, 0xae6eb077, 0x92c1e65b, 0xc064e6a9, 0xc649e56d, 0x5287a243,
1358 0x36de4f5b, 0x5b1df6ad, 0x65c39a59, 0xdba805b2, 0x20067aa8, 0x6457e56d, 0x3cee26cf, 0xfd3ff26d,
1359 0x04f86d4a, 0x06b8e048, 0xa93bcd5c, 0x91135852, 0xbe90a643, 0x8fa0094d, 0x06d8215f, 0x2677094d,
1360 0xd735685c, 0x164a00c9, 0x5209ac5f, 0xa9564c5c, 0x3b504f5f, 0xcc826bd0, 0x4615042e, 0x5fe13b4a,
1361 0x8c81b86d, 0x879ab68c, 0x1de564b8, 0x434487d8, 0x2dcb1b63, 0x82ab524a, 0xb0676abb, 0xa13d9c62,
1362 0xdbb5b86d, 0x5b7f4b59, 0xaddfb44d, 0xad773532, 0x3997054c, 0x72cebd89, 0xb194544c, 0xc5b8046e,
1363 0x6e1adeb2, 0xaa5abb51, 0xefb54b44, 0x15efc54f, 0xe9f1bc4d, 0x5f401b6c, 0x97f018ad, 0xc82f9252,
1364 0x2cdc762e, 0x8e52e56d, 0x1827175e, 0x9b7d7d80, 0xb2ad6845, 0x51065140, 0x71180a18, 0x5b27006c,
1365 0x0621e255, 0x721cbe58, 0x670c0cb8, 0xf8bd715d, 0xe0bdc5d9, 0xed843501, 0x4b84554d, 0x7f1a18bc,
1366 0x53bcaf47, 0x5729d35f, 0xf0dda246, 0x22382bd0, 0x4d641fb0, 0x316afcde, 0x50a22f1f, 0x73608046,
1367 0xc461d84a, 0xb2dbe247,
1372 void ThreadOpenConnections(void* parg)
1374 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1377 vnThreadsRunning[1]++;
1378 ThreadOpenConnections2(parg);
1379 vnThreadsRunning[1]--;
1381 catch (std::exception& e) {
1382 vnThreadsRunning[1]--;
1383 PrintException(&e, "ThreadOpenConnections()");
1385 vnThreadsRunning[1]--;
1386 PrintException(NULL, "ThreadOpenConnections()");
1388 printf("ThreadOpenConnections exiting\n");
1391 void ThreadOpenConnections2(void* parg)
1393 printf("ThreadOpenConnections started\n");
1395 // Connect to specific addresses
1396 if (mapArgs.count("-connect"))
1398 for (int64 nLoop = 0;; nLoop++)
1400 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1402 CAddress addr(strAddr, fAllowDNS);
1404 OpenNetworkConnection(addr);
1405 for (int i = 0; i < 10 && i < nLoop; i++)
1415 // Connect to manually added nodes first
1416 if (mapArgs.count("-addnode"))
1418 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1420 CAddress addr(strAddr, fAllowDNS);
1423 OpenNetworkConnection(addr);
1431 // Initiate network connections
1432 int64 nStart = GetTime();
1435 vnThreadsRunning[1]--;
1437 vnThreadsRunning[1]++;
1441 // Limit outbound connections
1445 CRITICAL_BLOCK(cs_vNodes)
1446 BOOST_FOREACH(CNode* pnode, vNodes)
1447 if (!pnode->fInbound)
1449 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1450 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1451 if (nOutbound < nMaxOutboundConnections)
1453 vnThreadsRunning[1]--;
1455 vnThreadsRunning[1]++;
1460 bool fAddSeeds = false;
1462 CRITICAL_BLOCK(cs_mapAddresses)
1464 // Add seed nodes if IRC isn't working
1465 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1466 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
1472 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1474 // It'll only connect to one or two seed nodes because once it connects,
1475 // it'll get a pile of addresses with newer timestamps.
1476 // Seed nodes are given a random 'last seen time' of between one and two
1478 const int64 nOneWeek = 7*24*60*60;
1480 addr.ip = pnSeed[i];
1481 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1487 // Choose an address to connect to based on most recently seen
1489 CAddress addrConnect;
1490 int64 nBest = INT64_MIN;
1492 // Only connect to one address per a.b.?.? range.
1493 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1494 set<unsigned int> setConnected;
1495 CRITICAL_BLOCK(cs_vNodes)
1496 BOOST_FOREACH(CNode* pnode, vNodes)
1497 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1499 CRITICAL_BLOCK(cs_mapAddresses)
1501 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1503 const CAddress& addr = item.second;
1504 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1506 int64 nSinceLastSeen = GetAdjustedTime() - addr.nTime;
1507 int64 nSinceLastTry = GetAdjustedTime() - addr.nLastTry;
1509 // Randomize the order in a deterministic way, putting the standard port first
1510 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1511 if (addr.port != htons(GetDefaultPort()))
1512 nRandomizer += 2 * 60 * 60;
1514 // Last seen Base retry frequency
1523 // 365 days 93 hours
1524 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1526 // Fast reconnect for one hour after last seen
1527 if (nSinceLastSeen < 60 * 60)
1530 // Limit retry frequency
1531 if (nSinceLastTry < nDelay)
1534 // If we have IRC, we'll be notified when they first come online,
1535 // and again every 24 hours by the refresh broadcast.
1536 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1539 // Only try the old stuff if we don't have enough connections
1540 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1543 // If multiple addresses are ready, prioritize by time since
1544 // last seen and time since last tried.
1545 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1554 if (addrConnect.IsValid())
1555 OpenNetworkConnection(addrConnect);
1559 bool OpenNetworkConnection(const CAddress& addrConnect)
1562 // Initiate outbound network connection
1566 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() || FindNode(addrConnect.ip))
1569 vnThreadsRunning[1]--;
1570 CNode* pnode = ConnectNode(addrConnect);
1571 vnThreadsRunning[1]++;
1576 pnode->fNetworkNode = true;
1588 void ThreadMessageHandler(void* parg)
1590 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1593 vnThreadsRunning[2]++;
1594 ThreadMessageHandler2(parg);
1595 vnThreadsRunning[2]--;
1597 catch (std::exception& e) {
1598 vnThreadsRunning[2]--;
1599 PrintException(&e, "ThreadMessageHandler()");
1601 vnThreadsRunning[2]--;
1602 PrintException(NULL, "ThreadMessageHandler()");
1604 printf("ThreadMessageHandler exiting\n");
1607 void ThreadMessageHandler2(void* parg)
1609 printf("ThreadMessageHandler started\n");
1610 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1613 vector<CNode*> vNodesCopy;
1614 CRITICAL_BLOCK(cs_vNodes)
1616 vNodesCopy = vNodes;
1617 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1621 // Poll the connected nodes for messages
1622 CNode* pnodeTrickle = NULL;
1623 if (!vNodesCopy.empty())
1624 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1625 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1628 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1629 ProcessMessages(pnode);
1634 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1635 SendMessages(pnode, pnode == pnodeTrickle);
1640 CRITICAL_BLOCK(cs_vNodes)
1642 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1646 // Wait and allow messages to bunch up.
1647 // Reduce vnThreadsRunning so StopNode has permission to exit while
1648 // we're sleeping, but we must always check fShutdown after doing this.
1649 vnThreadsRunning[2]--;
1651 if (fRequestShutdown)
1653 vnThreadsRunning[2]++;
1664 bool BindListenPort(string& strError)
1668 addrLocalHost.port = htons(GetListenPort());
1671 // Initialize Windows Sockets
1673 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1674 if (ret != NO_ERROR)
1676 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1677 printf("%s\n", strError.c_str());
1682 // Create socket for listening for incoming connections
1683 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1684 if (hListenSocket == INVALID_SOCKET)
1686 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1687 printf("%s\n", strError.c_str());
1692 // Different way of disabling SIGPIPE on BSD
1693 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1697 // Allow binding if the port is still in TIME_WAIT state after
1698 // the program was closed and restarted. Not an issue on windows.
1699 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1703 // Set to nonblocking, incoming connections will also inherit this
1704 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1706 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1709 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1710 printf("%s\n", strError.c_str());
1714 // The sockaddr_in structure specifies the address family,
1715 // IP address, and port for the socket that is being bound
1716 struct sockaddr_in sockaddr;
1717 memset(&sockaddr, 0, sizeof(sockaddr));
1718 sockaddr.sin_family = AF_INET;
1719 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1720 sockaddr.sin_port = htons(GetListenPort());
1721 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1723 int nErr = WSAGetLastError();
1724 if (nErr == WSAEADDRINUSE)
1725 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1727 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1728 printf("%s\n", strError.c_str());
1731 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1733 // Listen for incoming connections
1734 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1736 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1737 printf("%s\n", strError.c_str());
1744 void StartNode(void* parg)
1746 if (pnodeLocalHost == NULL)
1747 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1750 // Get local host ip
1751 char pszHostName[1000] = "";
1752 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1754 vector<CAddress> vaddr;
1755 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1756 BOOST_FOREACH (const CAddress &addr, vaddr)
1757 if (addr.GetByte(3) != 127)
1759 addrLocalHost = addr;
1764 // Get local host ip
1765 struct ifaddrs* myaddrs;
1766 if (getifaddrs(&myaddrs) == 0)
1768 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1770 if (ifa->ifa_addr == NULL) continue;
1771 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1772 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1773 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1775 if (ifa->ifa_addr->sa_family == AF_INET)
1777 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1778 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1779 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1781 // Take the first IP that isn't loopback 127.x.x.x
1782 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1783 if (addr.IsValid() && addr.GetByte(3) != 127)
1785 addrLocalHost = addr;
1789 else if (ifa->ifa_addr->sa_family == AF_INET6)
1791 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1792 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1793 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1796 freeifaddrs(myaddrs);
1799 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1801 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1803 // Proxies can't take incoming connections
1804 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1805 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1809 CreateThread(ThreadGetMyExternalIP, NULL);
1816 if (GetBoolArg("-nodnsseed"))
1817 printf("DNS seeding disabled\n");
1819 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1820 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1822 // Map ports with UPnP
1826 // Get addresses from IRC and advertise ours
1827 if (!CreateThread(ThreadIRCSeed, NULL))
1828 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1830 // Send and receive from sockets, accept connections
1831 if (!CreateThread(ThreadSocketHandler, NULL))
1832 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1834 // Initiate outbound connections
1835 if (!CreateThread(ThreadOpenConnections, NULL))
1836 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1839 if (!CreateThread(ThreadMessageHandler, NULL))
1840 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1842 // Generate coins in the background
1843 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1848 printf("StopNode()\n");
1850 nTransactionsUpdated++;
1851 int64 nStart = GetTime();
1852 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1854 || vnThreadsRunning[5] > 0
1858 if (GetTime() - nStart > 20)
1862 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1863 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1864 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1865 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1866 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1867 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1868 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1869 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1885 BOOST_FOREACH(CNode* pnode, vNodes)
1886 if (pnode->hSocket != INVALID_SOCKET)
1887 closesocket(pnode->hSocket);
1888 if (hListenSocket != INVALID_SOCKET)
1889 if (closesocket(hListenSocket) == SOCKET_ERROR)
1890 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1893 // Shutdown Windows Sockets
1898 instance_of_cnetcleanup;