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) != -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);
745 void ThreadSocketHandler(void* parg)
747 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
750 vnThreadsRunning[0]++;
751 ThreadSocketHandler2(parg);
752 vnThreadsRunning[0]--;
754 catch (std::exception& e) {
755 vnThreadsRunning[0]--;
756 PrintException(&e, "ThreadSocketHandler()");
758 vnThreadsRunning[0]--;
759 throw; // support pthread_cancel()
761 printf("ThreadSocketHandler exiting\n");
764 void ThreadSocketHandler2(void* parg)
766 printf("ThreadSocketHandler started\n");
767 list<CNode*> vNodesDisconnected;
768 int nPrevNodeCount = 0;
775 CRITICAL_BLOCK(cs_vNodes)
777 // Disconnect unused nodes
778 vector<CNode*> vNodesCopy = vNodes;
779 BOOST_FOREACH(CNode* pnode, vNodesCopy)
781 if (pnode->fDisconnect ||
782 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
784 // remove from vNodes
785 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
787 // close socket and cleanup
788 pnode->CloseSocketDisconnect();
791 // hold in disconnected pool until all refs are released
792 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
793 if (pnode->fNetworkNode || pnode->fInbound)
795 vNodesDisconnected.push_back(pnode);
799 // Delete disconnected nodes
800 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
801 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
803 // wait until threads are done using it
804 if (pnode->GetRefCount() <= 0)
806 bool fDelete = false;
807 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
808 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
809 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
810 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
814 vNodesDisconnected.remove(pnode);
820 if (vNodes.size() != nPrevNodeCount)
822 nPrevNodeCount = vNodes.size();
828 // Find which sockets have data to receive
830 struct timeval timeout;
832 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
839 FD_ZERO(&fdsetError);
840 SOCKET hSocketMax = 0;
842 if(hListenSocket != INVALID_SOCKET)
843 FD_SET(hListenSocket, &fdsetRecv);
844 hSocketMax = max(hSocketMax, hListenSocket);
845 CRITICAL_BLOCK(cs_vNodes)
847 BOOST_FOREACH(CNode* pnode, vNodes)
849 if (pnode->hSocket == INVALID_SOCKET)
851 FD_SET(pnode->hSocket, &fdsetRecv);
852 FD_SET(pnode->hSocket, &fdsetError);
853 hSocketMax = max(hSocketMax, pnode->hSocket);
854 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
855 if (!pnode->vSend.empty())
856 FD_SET(pnode->hSocket, &fdsetSend);
860 vnThreadsRunning[0]--;
861 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
862 vnThreadsRunning[0]++;
865 if (nSelect == SOCKET_ERROR)
867 int nErr = WSAGetLastError();
870 printf("socket select error %d\n", nErr);
871 for (int i = 0; i <= hSocketMax; i++)
872 FD_SET(i, &fdsetRecv);
875 FD_ZERO(&fdsetError);
876 Sleep(timeout.tv_usec/1000);
881 // Accept new connections
883 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
885 struct sockaddr_in sockaddr;
886 socklen_t len = sizeof(sockaddr);
887 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
891 if (hSocket != INVALID_SOCKET)
892 addr = CAddress(sockaddr);
894 CRITICAL_BLOCK(cs_vNodes)
895 BOOST_FOREACH(CNode* pnode, vNodes)
899 if (hSocket == INVALID_SOCKET)
901 if (WSAGetLastError() != WSAEWOULDBLOCK)
902 printf("socket error accept failed: %d\n", WSAGetLastError());
904 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
906 closesocket(hSocket);
910 printf("accepted connection %s\n", addr.ToString().c_str());
911 CNode* pnode = new CNode(hSocket, addr, true);
913 CRITICAL_BLOCK(cs_vNodes)
914 vNodes.push_back(pnode);
920 // Service each socket
922 vector<CNode*> vNodesCopy;
923 CRITICAL_BLOCK(cs_vNodes)
926 BOOST_FOREACH(CNode* pnode, vNodesCopy)
929 BOOST_FOREACH(CNode* pnode, vNodesCopy)
937 if (pnode->hSocket == INVALID_SOCKET)
939 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
941 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
943 CDataStream& vRecv = pnode->vRecv;
944 unsigned int nPos = vRecv.size();
946 if (nPos > ReceiveBufferSize()) {
947 if (!pnode->fDisconnect)
948 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
949 pnode->CloseSocketDisconnect();
952 // typical socket buffer is 8K-64K
953 char pchBuf[0x10000];
954 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
957 vRecv.resize(nPos + nBytes);
958 memcpy(&vRecv[nPos], pchBuf, nBytes);
959 pnode->nLastRecv = GetTime();
961 else if (nBytes == 0)
963 // socket closed gracefully
964 if (!pnode->fDisconnect)
965 printf("socket closed\n");
966 pnode->CloseSocketDisconnect();
971 int nErr = WSAGetLastError();
972 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
974 if (!pnode->fDisconnect)
975 printf("socket recv error %d\n", nErr);
976 pnode->CloseSocketDisconnect();
986 if (pnode->hSocket == INVALID_SOCKET)
988 if (FD_ISSET(pnode->hSocket, &fdsetSend))
990 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
992 CDataStream& vSend = pnode->vSend;
995 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
998 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
999 pnode->nLastSend = GetTime();
1001 else if (nBytes < 0)
1004 int nErr = WSAGetLastError();
1005 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1007 printf("socket send error %d\n", nErr);
1008 pnode->CloseSocketDisconnect();
1011 if (vSend.size() > SendBufferSize()) {
1012 if (!pnode->fDisconnect)
1013 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1014 pnode->CloseSocketDisconnect();
1021 // Inactivity checking
1023 if (pnode->vSend.empty())
1024 pnode->nLastSendEmpty = GetTime();
1025 if (GetTime() - pnode->nTimeConnected > 60)
1027 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1029 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1030 pnode->fDisconnect = true;
1032 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1034 printf("socket not sending\n");
1035 pnode->fDisconnect = true;
1037 else if (GetTime() - pnode->nLastRecv > 90*60)
1039 printf("socket inactivity timeout\n");
1040 pnode->fDisconnect = true;
1044 CRITICAL_BLOCK(cs_vNodes)
1046 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1063 void ThreadMapPort(void* parg)
1065 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1068 vnThreadsRunning[5]++;
1069 ThreadMapPort2(parg);
1070 vnThreadsRunning[5]--;
1072 catch (std::exception& e) {
1073 vnThreadsRunning[5]--;
1074 PrintException(&e, "ThreadMapPort()");
1076 vnThreadsRunning[5]--;
1077 PrintException(NULL, "ThreadMapPort()");
1079 printf("ThreadMapPort exiting\n");
1082 void ThreadMapPort2(void* parg)
1084 printf("ThreadMapPort started\n");
1087 sprintf(port, "%d", GetListenPort());
1089 const char * multicastif = 0;
1090 const char * minissdpdpath = 0;
1091 struct UPNPDev * devlist = 0;
1094 #ifndef UPNPDISCOVER_SUCCESS
1096 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1100 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1103 struct UPNPUrls urls;
1104 struct IGDdatas data;
1107 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1110 if (!addrLocalHost.IsRoutable())
1112 char externalIPAddress[40];
1113 r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1114 if(r != UPNPCOMMAND_SUCCESS)
1115 printf("UPnP: GetExternalIPAddress() returned %d\n", r);
1118 if(externalIPAddress[0])
1120 printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1121 CAddress addrExternalFromUPnP(externalIPAddress, 0, false, nLocalServices);
1122 if (addrExternalFromUPnP.IsRoutable())
1123 addrLocalHost = addrExternalFromUPnP;
1126 printf("UPnP: GetExternalIPAddress failed.\n");
1130 string strDesc = "Bitcoin " + FormatFullVersion();
1131 #ifndef UPNPDISCOVER_SUCCESS
1133 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1134 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1137 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1138 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1141 if(r!=UPNPCOMMAND_SUCCESS)
1142 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1143 port, port, lanaddr, r, strupnperror(r));
1145 printf("UPnP Port Mapping successful.\n");
1148 if (fShutdown || !fUseUPnP)
1150 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1151 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1152 freeUPNPDevlist(devlist); devlist = 0;
1153 FreeUPNPUrls(&urls);
1156 if (i % 600 == 0) // Refresh every 20 minutes
1158 #ifndef UPNPDISCOVER_SUCCESS
1160 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1161 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1164 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1165 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1168 if(r!=UPNPCOMMAND_SUCCESS)
1169 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1170 port, port, lanaddr, r, strupnperror(r));
1172 printf("UPnP Port Mapping successful.\n");;
1178 printf("No valid UPnP IGDs found\n");
1179 freeUPNPDevlist(devlist); devlist = 0;
1181 FreeUPNPUrls(&urls);
1183 if (fShutdown || !fUseUPnP)
1190 void MapPort(bool fMapPort)
1192 if (fUseUPnP != fMapPort)
1194 fUseUPnP = fMapPort;
1195 WriteSetting("fUseUPnP", fUseUPnP);
1197 if (fUseUPnP && vnThreadsRunning[5] < 1)
1199 if (!CreateThread(ThreadMapPort, NULL))
1200 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1204 void MapPort(bool /* unused fMapPort */)
1206 // Intentionally left blank.
1219 static const char *strDNSSeed[] = {
1221 "dnsseed.bluematt.me",
1222 "seed.bitcoin.sipa.be",
1223 "dnsseed.bitcoin.dashjr.org",
1226 void ThreadDNSAddressSeed(void* parg)
1228 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1231 vnThreadsRunning[6]++;
1232 ThreadDNSAddressSeed2(parg);
1233 vnThreadsRunning[6]--;
1235 catch (std::exception& e) {
1236 vnThreadsRunning[6]--;
1237 PrintException(&e, "ThreadDNSAddressSeed()");
1239 vnThreadsRunning[6]--;
1240 throw; // support pthread_cancel()
1242 printf("ThreadDNSAddressSeed exiting\n");
1245 void ThreadDNSAddressSeed2(void* parg)
1247 printf("ThreadDNSAddressSeed started\n");
1252 printf("Loading addresses from DNS seeds (could take a while)\n");
1254 for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1255 vector<CAddress> vaddr;
1256 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1260 BOOST_FOREACH (CAddress& addr, vaddr)
1262 if (addr.GetByte(3) != 127)
1265 AddAddress(addr, 0, &addrDB);
1269 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1274 printf("%d addresses found from DNS seeds\n", found);
1288 unsigned int pnSeed[] =
1290 0x959bd347, 0xf8de42b2, 0x73bc0518, 0xea6edc50, 0x21b00a4d, 0xc725b43d, 0xd665464d, 0x1a2a770e,
1291 0x27c93946, 0x65b2fa46, 0xb80ae255, 0x66b3b446, 0xb1877a3e, 0x6ee89e3e, 0xc3175b40, 0x2a01a83c,
1292 0x95b1363a, 0xa079ad3d, 0xe6ca801f, 0x027f4f4a, 0x34f7f03a, 0xf790f04a, 0x16ca801f, 0x2f4d5e40,
1293 0x3a4d5e40, 0xc43a322e, 0xc8159753, 0x14d4724c, 0x7919a118, 0xe0bdb34e, 0x68a16b2e, 0xff64b44d,
1294 0x6099115b, 0x9b57b05b, 0x7bd1b4ad, 0xdf95944f, 0x29d2b73d, 0xafa8db79, 0xe247ba41, 0x24078348,
1295 0xf722f03c, 0x33567ebc, 0xace64ed4, 0x984d3932, 0xb5f34e55, 0x27b7024d, 0x94579247, 0x8894042e,
1296 0x9357d34c, 0x1063c24b, 0xcaa228b1, 0xa3c5a8b2, 0x5dc64857, 0xa2c23643, 0xa8369a54, 0x31203077,
1297 0x00707c5c, 0x09fc0b3a, 0x272e9e2e, 0xf80f043e, 0x9449ca3e, 0x5512c33e, 0xd106b555, 0xe8024157,
1298 0xe288ec29, 0xc79c5461, 0xafb63932, 0xdb02ab4b, 0x0e512777, 0x8a145a4c, 0xb201ff4f, 0x5e09314b,
1299 0xcd9bfbcd, 0x1c023765, 0x4394e75c, 0xa728bd4d, 0x65331552, 0xa98420b1, 0x89ecf559, 0x6e80801f,
1300 0xf404f118, 0xefd62b51, 0x05918346, 0x9b186d5f, 0xacabab46, 0xf912e255, 0xc188ea62, 0xcc55734e,
1301 0xc668064d, 0xd77a4558, 0x46201c55, 0xf17dfc80, 0xf7142f2e, 0x87bfb718, 0x8aa54fb2, 0xc451d518,
1302 0xc4ae8831, 0x8dd44d55, 0x5bbd206c, 0x64536b5d, 0x5c667e60, 0x3b064242, 0xfe963a42, 0xa28e6dc8,
1303 0xe8a9604a, 0xc989464e, 0xd124a659, 0x50065140, 0xa44dfe5e, 0x1079e655, 0x3fb986d5, 0x47895b18,
1304 0x7d3ce4ad, 0x4561ba50, 0x296eec62, 0x255b41ad, 0xaed35ec9, 0x55556f12, 0xc7d3154d, 0x3297b65d,
1305 0x8930121f, 0xabf42e4e, 0x4a29e044, 0x1212685d, 0x676c1e40, 0xce009744, 0x383a8948, 0xa2dbd0ad,
1306 0xecc2564d, 0x07dbc252, 0x887ee24b, 0x5171644c, 0x6bb798c1, 0x847f495d, 0x4cbb7145, 0x3bb81c32,
1307 0x45eb262e, 0xc8015a4e, 0x250a361b, 0xf694f946, 0xd64a183e, 0xd4f1dd59, 0x8f20ffd4, 0x51d9e55c,
1308 0x09521763, 0x5e02002e, 0x32c8074d, 0xe685762e, 0x8290b0bc, 0x762a922e, 0xfc5ee754, 0x83a24829,
1309 0x775b224d, 0x6295bb4d, 0x38ec0555, 0xbffbba50, 0xe5560260, 0x86b16a7c, 0xd372234e, 0x49a3c24b,
1310 0x2f6a171f, 0x4d75ed60, 0xae94115b, 0xcb543744, 0x63080c59, 0x3f9c724c, 0xc977ce18, 0x532efb18,
1311 0x69dc3b2e, 0x5f94d929, 0x1732bb4d, 0x9c814b4d, 0xe6b3762e, 0xc024f662, 0x8face35b, 0x6b5b044d,
1312 0x798c7b57, 0x79a6b44c, 0x067d3057, 0xf9e94e5f, 0x91cbe15b, 0x71405eb2, 0x2662234e, 0xcbcc4a6d,
1313 0xbf69d54b, 0xa79b4e55, 0xec6d3e51, 0x7c0b3c02, 0x60f83653, 0x24c1e15c, 0x1110b62e, 0x10350f59,
1314 0xa56f1d55, 0x3509e7a9, 0xeb128354, 0x14268e2e, 0x934e28bc, 0x8e32692e, 0x8331a21f, 0x3e633932,
1315 0xc812b12e, 0xc684bf2e, 0x80112d2e, 0xe0ddc96c, 0xc630ca4a, 0x5c09b3b2, 0x0b580518, 0xc8e9d54b,
1316 0xd169aa43, 0x17d0d655, 0x1d029963, 0x7ff87559, 0xcb701f1f, 0x6fa3e85d, 0xe45e9a54, 0xf05d1802,
1317 0x44d03b2e, 0x837b692e, 0xccd4354e, 0x3d6da13c, 0x3423084d, 0xf707c34a, 0x55f6db3a, 0xad26e442,
1318 0x6233a21f, 0x09e80e59, 0x8caeb54d, 0xbe870941, 0xb407d20e, 0x20b51018, 0x56fb152e, 0x460d2a4e,
1319 0xbb9a2946, 0x560eb12e, 0xed83dd29, 0xd6724f53, 0xa50aafb8, 0x451346d9, 0x88348e2e, 0x7312fead,
1320 0x8ecaf96f, 0x1bda4e5f, 0xf1671e40, 0x3c8c3e3b, 0x4716324d, 0xdde24ede, 0xf98cd17d, 0xa91d4644,
1321 0x28124eb2, 0x147d5129, 0xd022042e, 0x61733d3b, 0xad0d5e02, 0x8ce2932e, 0xe5c18502, 0x549c1e32,
1322 0x9685801f, 0x86e217ad, 0xd948214b, 0x4110f462, 0x3a2e894e, 0xbd35492e, 0x87e0d558, 0x64b8ef7d,
1323 0x7c3eb962, 0x72a84b3e, 0x7cd667c9, 0x28370a2e, 0x4bc60e7b, 0x6fc1ec60, 0x14a6983f, 0x86739a4b,
1324 0x46954e5f, 0x32e2e15c, 0x2e9326cf, 0xe5801c5e, 0x379607b2, 0x32151145, 0xf0e39744, 0xacb54c55,
1325 0xa37dfb60, 0x83b55cc9, 0x388f7ca5, 0x15034f5f, 0x3e94965b, 0x68e0ffad, 0x35280f59, 0x8fe190cf,
1326 0x7c6ba5b2, 0xa5e9db43, 0x4ee1fc60, 0xd9d94e5f, 0x04040677, 0x0ea9b35e, 0x5961f14f, 0x67fda063,
1327 0xa48a5a31, 0xc6524e55, 0x283d325e, 0x3f37515f, 0x96b94b3e, 0xacce620e, 0x6481cc5b, 0xa4a06d4b,
1328 0x9e95d2d9, 0xe40c03d5, 0xc2f4514b, 0xb79aad44, 0xf64be843, 0xb2064070, 0xfca00455, 0x429dfa4e,
1329 0x2323f173, 0xeda4185e, 0xabd5227d, 0x9efd4d58, 0xb1104758, 0x4811e955, 0xbd9ab355, 0xe921f44b,
1330 0x9f166dce, 0x09e279b2, 0xe0c9ac7b, 0x7901a5ad, 0xa145d4b0, 0x79104671, 0xec31e35a, 0x4fe0b555,
1331 0xc7d9cbad, 0xad057f55, 0xe94cc759, 0x7fe0b043, 0xe4529f2e, 0x0d4dd4b2, 0x9f11a54d, 0x031e2e4e,
1332 0xe6014f5f, 0x11d1ca6c, 0x26bd7f61, 0xeb86854f, 0x4d347b57, 0x116bbe2e, 0xdba7234e, 0x7bcbfd2e,
1333 0x174dd4b2, 0x6686762e, 0xb089ba50, 0xc6258246, 0x087e767b, 0xc4a8cb4a, 0x595dba50, 0x7f0ae502,
1334 0x7b1dbd5a, 0xa0603492, 0x57d1af4b, 0x9e21ffd4, 0x6393064d, 0x7407376e, 0xe484762e, 0x122a4e53,
1335 0x4a37aa43, 0x3888a6be, 0xee77864e, 0x039c8dd5, 0x688d89af, 0x0e988f62, 0x08218246, 0xfc2f8246,
1336 0xd1d97040, 0xd64cd4b2, 0x5ae4a6b8, 0x7d0de9bc, 0x8d304d61, 0x06c5c672, 0xa4c8bd4d, 0xe0fd373b,
1337 0x575ebe4d, 0x72d26277, 0x55570f55, 0x77b154d9, 0xe214293a, 0xfc740f4b, 0xfe3f6a57, 0xa9c55f02,
1338 0xae4054db, 0x2394d918, 0xb511b24a, 0xb8741ab2, 0x0758e65e, 0xc7b5795b, 0xb0a30a4c, 0xaf7f170c,
1339 0xf3b4762e, 0x8179576d, 0x738a1581, 0x4b95b64c, 0x9829b618, 0x1bea932e, 0x7bdeaa4b, 0xcb5e0281,
1340 0x65618f54, 0x0658474b, 0x27066acf, 0x40556d65, 0x7d204d53, 0xf28bc244, 0xdce23455, 0xadc0ff54,
1341 0x3863c948, 0xcee34e5f, 0xdeb85e02, 0x2ed17a61, 0x6a7b094d, 0x7f0cfc40, 0x59603f54, 0x3220afbc,
1342 0xb5dfd962, 0x125d21c0, 0x13f8d243, 0xacfefb4e, 0x86c2c147, 0x3d8bbd59, 0xbd02a21f, 0x2593042e,
1343 0xc6a17a7c, 0x28925861, 0xb487ed44, 0xb5f4fd6d, 0x90c28a45, 0x5a14f74d, 0x43d71b4c, 0x728ebb5d,
1344 0x885bf950, 0x08134dd0, 0x38ec046e, 0xc575684b, 0x50082d2e, 0xa2f47757, 0x270f86ae, 0xf3ff6462,
1345 0x10ed3f4e, 0x4b58d462, 0xe01ce23e, 0x8c5b092e, 0x63e52f4e, 0x22c1e85d, 0xa908f54e, 0x8591624f,
1346 0x2c0fb94e, 0xa280ba3c, 0xb6f41b4c, 0x24f9aa47, 0x27201647, 0x3a3ea6dc, 0xa14fc3be, 0x3c34bdd5,
1347 0x5b8d4f5b, 0xaadeaf4b, 0xc71cab50, 0x15697a4c, 0x9a1a734c, 0x2a037d81, 0x2590bd59, 0x48ec2741,
1348 0x53489c5b, 0x7f00314b, 0x2170d362, 0xf2e92542, 0x42c10b44, 0x98f0f118, 0x883a3456, 0x099a932e,
1349 0xea38f7bc, 0x644e9247, 0xbb61b62e, 0x30e0863d, 0x5f51be54, 0x207215c7, 0x5f306c45, 0xaa7f3932,
1350 0x98da7d45, 0x4e339b59, 0x2e411581, 0xa808f618, 0xad2c0c59, 0x54476741, 0x09e99fd1, 0x5db8f752,
1351 0xc16df8bd, 0x1dd4b44f, 0x106edf2e, 0x9e15c180, 0x2ad6b56f, 0x633a5332, 0xff33787c, 0x077cb545,
1352 0x6610be6d, 0x75aad2c4, 0x72fb4d5b, 0xe81e0f59, 0x576f6332, 0x47333373, 0x351ed783, 0x2d90fb50,
1353 0x8d5e0f6c, 0x5b27a552, 0xdb293ebb, 0xe55ef950, 0x4b133ad8, 0x75df975a, 0x7b6a8740, 0xa899464b,
1354 0xfab15161, 0x10f8b64d, 0xd055ea4d, 0xee8e146b, 0x4b14afb8, 0x4bc1c44a, 0x9b961dcc, 0xd111ff43,
1355 0xfca0b745, 0xc800e412, 0x0afad9d1, 0xf751c350, 0xf9f0cccf, 0xa290a545, 0x8ef13763, 0x7ec70d59,
1356 0x2b066acf, 0x65496c45, 0xade02c1b, 0xae6eb077, 0x92c1e65b, 0xc064e6a9, 0xc649e56d, 0x5287a243,
1357 0x36de4f5b, 0x5b1df6ad, 0x65c39a59, 0xdba805b2, 0x20067aa8, 0x6457e56d, 0x3cee26cf, 0xfd3ff26d,
1358 0x04f86d4a, 0x06b8e048, 0xa93bcd5c, 0x91135852, 0xbe90a643, 0x8fa0094d, 0x06d8215f, 0x2677094d,
1359 0xd735685c, 0x164a00c9, 0x5209ac5f, 0xa9564c5c, 0x3b504f5f, 0xcc826bd0, 0x4615042e, 0x5fe13b4a,
1360 0x8c81b86d, 0x879ab68c, 0x1de564b8, 0x434487d8, 0x2dcb1b63, 0x82ab524a, 0xb0676abb, 0xa13d9c62,
1361 0xdbb5b86d, 0x5b7f4b59, 0xaddfb44d, 0xad773532, 0x3997054c, 0x72cebd89, 0xb194544c, 0xc5b8046e,
1362 0x6e1adeb2, 0xaa5abb51, 0xefb54b44, 0x15efc54f, 0xe9f1bc4d, 0x5f401b6c, 0x97f018ad, 0xc82f9252,
1363 0x2cdc762e, 0x8e52e56d, 0x1827175e, 0x9b7d7d80, 0xb2ad6845, 0x51065140, 0x71180a18, 0x5b27006c,
1364 0x0621e255, 0x721cbe58, 0x670c0cb8, 0xf8bd715d, 0xe0bdc5d9, 0xed843501, 0x4b84554d, 0x7f1a18bc,
1365 0x53bcaf47, 0x5729d35f, 0xf0dda246, 0x22382bd0, 0x4d641fb0, 0x316afcde, 0x50a22f1f, 0x73608046,
1366 0xc461d84a, 0xb2dbe247,
1371 void ThreadOpenConnections(void* parg)
1373 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1376 vnThreadsRunning[1]++;
1377 ThreadOpenConnections2(parg);
1378 vnThreadsRunning[1]--;
1380 catch (std::exception& e) {
1381 vnThreadsRunning[1]--;
1382 PrintException(&e, "ThreadOpenConnections()");
1384 vnThreadsRunning[1]--;
1385 PrintException(NULL, "ThreadOpenConnections()");
1387 printf("ThreadOpenConnections exiting\n");
1390 void ThreadOpenConnections2(void* parg)
1392 printf("ThreadOpenConnections started\n");
1394 // Connect to specific addresses
1395 if (mapArgs.count("-connect"))
1397 for (int64 nLoop = 0;; nLoop++)
1399 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1401 CAddress addr(strAddr, fAllowDNS);
1403 OpenNetworkConnection(addr);
1404 for (int i = 0; i < 10 && i < nLoop; i++)
1414 // Connect to manually added nodes first
1415 if (mapArgs.count("-addnode"))
1417 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1419 CAddress addr(strAddr, fAllowDNS);
1422 OpenNetworkConnection(addr);
1430 // Initiate network connections
1431 int64 nStart = GetTime();
1434 vnThreadsRunning[1]--;
1436 vnThreadsRunning[1]++;
1440 // Limit outbound connections
1444 CRITICAL_BLOCK(cs_vNodes)
1445 BOOST_FOREACH(CNode* pnode, vNodes)
1446 if (!pnode->fInbound)
1448 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1449 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1450 if (nOutbound < nMaxOutboundConnections)
1452 vnThreadsRunning[1]--;
1454 vnThreadsRunning[1]++;
1459 bool fAddSeeds = false;
1461 CRITICAL_BLOCK(cs_mapAddresses)
1463 // Add seed nodes if IRC isn't working
1464 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1465 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
1471 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1473 // It'll only connect to one or two seed nodes because once it connects,
1474 // it'll get a pile of addresses with newer timestamps.
1475 // Seed nodes are given a random 'last seen time' of between one and two
1477 const int64 nOneWeek = 7*24*60*60;
1479 addr.ip = pnSeed[i];
1480 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1486 // Choose an address to connect to based on most recently seen
1488 CAddress addrConnect;
1489 int64 nBest = INT64_MIN;
1491 // Only connect to one address per a.b.?.? range.
1492 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1493 set<unsigned int> setConnected;
1494 CRITICAL_BLOCK(cs_vNodes)
1495 BOOST_FOREACH(CNode* pnode, vNodes)
1496 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1498 CRITICAL_BLOCK(cs_mapAddresses)
1500 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1502 const CAddress& addr = item.second;
1503 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1505 int64 nSinceLastSeen = GetAdjustedTime() - addr.nTime;
1506 int64 nSinceLastTry = GetAdjustedTime() - addr.nLastTry;
1508 // Randomize the order in a deterministic way, putting the standard port first
1509 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1510 if (addr.port != htons(GetDefaultPort()))
1511 nRandomizer += 2 * 60 * 60;
1513 // Last seen Base retry frequency
1522 // 365 days 93 hours
1523 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1525 // Fast reconnect for one hour after last seen
1526 if (nSinceLastSeen < 60 * 60)
1529 // Limit retry frequency
1530 if (nSinceLastTry < nDelay)
1533 // If we have IRC, we'll be notified when they first come online,
1534 // and again every 24 hours by the refresh broadcast.
1535 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1538 // Only try the old stuff if we don't have enough connections
1539 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1542 // If multiple addresses are ready, prioritize by time since
1543 // last seen and time since last tried.
1544 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1553 if (addrConnect.IsValid())
1554 OpenNetworkConnection(addrConnect);
1558 bool OpenNetworkConnection(const CAddress& addrConnect)
1561 // Initiate outbound network connection
1565 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() || FindNode(addrConnect.ip))
1568 vnThreadsRunning[1]--;
1569 CNode* pnode = ConnectNode(addrConnect);
1570 vnThreadsRunning[1]++;
1575 pnode->fNetworkNode = true;
1587 void ThreadMessageHandler(void* parg)
1589 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1592 vnThreadsRunning[2]++;
1593 ThreadMessageHandler2(parg);
1594 vnThreadsRunning[2]--;
1596 catch (std::exception& e) {
1597 vnThreadsRunning[2]--;
1598 PrintException(&e, "ThreadMessageHandler()");
1600 vnThreadsRunning[2]--;
1601 PrintException(NULL, "ThreadMessageHandler()");
1603 printf("ThreadMessageHandler exiting\n");
1606 void ThreadMessageHandler2(void* parg)
1608 printf("ThreadMessageHandler started\n");
1609 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1612 vector<CNode*> vNodesCopy;
1613 CRITICAL_BLOCK(cs_vNodes)
1615 vNodesCopy = vNodes;
1616 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1620 // Poll the connected nodes for messages
1621 CNode* pnodeTrickle = NULL;
1622 if (!vNodesCopy.empty())
1623 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1624 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1627 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1628 ProcessMessages(pnode);
1633 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1634 SendMessages(pnode, pnode == pnodeTrickle);
1639 CRITICAL_BLOCK(cs_vNodes)
1641 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1645 // Wait and allow messages to bunch up.
1646 // Reduce vnThreadsRunning so StopNode has permission to exit while
1647 // we're sleeping, but we must always check fShutdown after doing this.
1648 vnThreadsRunning[2]--;
1650 if (fRequestShutdown)
1652 vnThreadsRunning[2]++;
1663 bool BindListenPort(string& strError)
1667 addrLocalHost.port = htons(GetListenPort());
1670 // Initialize Windows Sockets
1672 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1673 if (ret != NO_ERROR)
1675 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1676 printf("%s\n", strError.c_str());
1681 // Create socket for listening for incoming connections
1682 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1683 if (hListenSocket == INVALID_SOCKET)
1685 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1686 printf("%s\n", strError.c_str());
1691 // Different way of disabling SIGPIPE on BSD
1692 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1696 // Allow binding if the port is still in TIME_WAIT state after
1697 // the program was closed and restarted. Not an issue on windows.
1698 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1702 // Set to nonblocking, incoming connections will also inherit this
1703 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1705 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1708 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1709 printf("%s\n", strError.c_str());
1713 // The sockaddr_in structure specifies the address family,
1714 // IP address, and port for the socket that is being bound
1715 struct sockaddr_in sockaddr;
1716 memset(&sockaddr, 0, sizeof(sockaddr));
1717 sockaddr.sin_family = AF_INET;
1718 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1719 sockaddr.sin_port = htons(GetListenPort());
1720 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1722 int nErr = WSAGetLastError();
1723 if (nErr == WSAEADDRINUSE)
1724 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1726 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1727 printf("%s\n", strError.c_str());
1730 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1732 // Listen for incoming connections
1733 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1735 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1736 printf("%s\n", strError.c_str());
1743 void StartNode(void* parg)
1745 if (pnodeLocalHost == NULL)
1746 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1749 // Get local host ip
1750 char pszHostName[1000] = "";
1751 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1753 vector<CAddress> vaddr;
1754 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1755 BOOST_FOREACH (const CAddress &addr, vaddr)
1756 if (addr.GetByte(3) != 127)
1758 addrLocalHost = addr;
1763 // Get local host ip
1764 struct ifaddrs* myaddrs;
1765 if (getifaddrs(&myaddrs) == 0)
1767 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1769 if (ifa->ifa_addr == NULL) continue;
1770 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1771 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1772 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1774 if (ifa->ifa_addr->sa_family == AF_INET)
1776 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1777 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1778 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1780 // Take the first IP that isn't loopback 127.x.x.x
1781 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1782 if (addr.IsValid() && addr.GetByte(3) != 127)
1784 addrLocalHost = addr;
1788 else if (ifa->ifa_addr->sa_family == AF_INET6)
1790 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1791 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1792 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1795 freeifaddrs(myaddrs);
1798 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1800 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1802 // Proxies can't take incoming connections
1803 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1804 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1808 CreateThread(ThreadGetMyExternalIP, NULL);
1815 if (GetBoolArg("-nodnsseed"))
1816 printf("DNS seeding disabled\n");
1818 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1819 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1821 // Map ports with UPnP
1825 // Get addresses from IRC and advertise ours
1826 if (!CreateThread(ThreadIRCSeed, NULL))
1827 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1829 // Send and receive from sockets, accept connections
1830 if (!CreateThread(ThreadSocketHandler, NULL))
1831 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1833 // Initiate outbound connections
1834 if (!CreateThread(ThreadOpenConnections, NULL))
1835 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1838 if (!CreateThread(ThreadMessageHandler, NULL))
1839 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1841 // Generate coins in the background
1842 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1847 printf("StopNode()\n");
1849 nTransactionsUpdated++;
1850 int64 nStart = GetTime();
1851 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1853 || vnThreadsRunning[5] > 0
1857 if (GetTime() - nStart > 20)
1861 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1862 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1863 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1864 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1865 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1866 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1867 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1868 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1884 BOOST_FOREACH(CNode* pnode, vNodes)
1885 if (pnode->hSocket != INVALID_SOCKET)
1886 closesocket(pnode->hSocket);
1887 if (hListenSocket != INVALID_SOCKET)
1888 if (closesocket(hListenSocket) == SOCKET_ERROR)
1889 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1892 // Shutdown Windows Sockets
1897 instance_of_cnetcleanup;