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.
16 #include <netinet/in.h>
20 #include <miniupnpc/miniwget.h>
21 #include <miniupnpc/miniupnpc.h>
22 #include <miniupnpc/upnpcommands.h>
23 #include <miniupnpc/upnperrors.h>
27 using namespace boost;
29 static const int MAX_OUTBOUND_CONNECTIONS = 8;
31 void ThreadMessageHandler2(void* parg);
32 void ThreadSocketHandler2(void* parg);
33 void ThreadOpenConnections2(void* parg);
35 void ThreadMapPort2(void* parg);
37 void ThreadDNSAddressSeed2(void* parg);
38 bool OpenNetworkConnection(const CAddress& addrConnect);
45 // Global state variables
48 bool fAllowDNS = false;
49 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
50 CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
51 static CNode* pnodeLocalHost = NULL;
52 uint64 nLocalHostNonce = 0;
53 array<int, 10> vnThreadsRunning;
54 static SOCKET hListenSocket = INVALID_SOCKET;
56 vector<CNode*> vNodes;
57 CCriticalSection cs_vNodes;
58 map<vector<unsigned char>, CAddress> mapAddresses;
59 CCriticalSection cs_mapAddresses;
60 map<CInv, CDataStream> mapRelay;
61 deque<pair<int64, CInv> > vRelayExpiration;
62 CCriticalSection cs_mapRelay;
63 map<CInv, int64> mapAlreadyAskedFor;
66 int fUseProxy = false;
67 int nConnectTimeout = 5000;
68 CAddress addrProxy("127.0.0.1",9050);
73 unsigned short GetListenPort()
75 return (unsigned short)(GetArg("-port", GetDefaultPort()));
78 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
80 // Filter out duplicate requests
81 if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
83 pindexLastGetBlocksBegin = pindexBegin;
84 hashLastGetBlocksEnd = hashEnd;
86 PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
93 bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
95 hSocketRet = INVALID_SOCKET;
97 SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
98 if (hSocket == INVALID_SOCKET)
102 setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
105 bool fProxy = (fUseProxy && addrConnect.IsRoutable());
106 struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
109 u_long fNonblock = 1;
110 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
112 int fFlags = fcntl(hSocket, F_GETFL, 0);
113 if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
116 closesocket(hSocket);
121 if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
123 // WSAEINVAL is here because some legacy version of winsock uses it
124 if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
126 struct timeval timeout;
127 timeout.tv_sec = nTimeout / 1000;
128 timeout.tv_usec = (nTimeout % 1000) * 1000;
132 FD_SET(hSocket, &fdset);
133 int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
136 printf("connection timeout\n");
137 closesocket(hSocket);
140 if (nRet == SOCKET_ERROR)
142 printf("select() for connection failed: %i\n",WSAGetLastError());
143 closesocket(hSocket);
146 socklen_t nRetSize = sizeof(nRet);
148 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
150 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
153 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
154 closesocket(hSocket);
159 printf("connect() failed after select(): %s\n",strerror(nRet));
160 closesocket(hSocket);
165 else if (WSAGetLastError() != WSAEISCONN)
170 printf("connect() failed: %i\n",WSAGetLastError());
171 closesocket(hSocket);
177 this isn't even strictly necessary
178 CNode::ConnectNode immediately turns the socket back to non-blocking
179 but we'll turn it back to blocking just in case
183 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
185 fFlags = fcntl(hSocket, F_GETFL, 0);
186 if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
189 closesocket(hSocket);
195 printf("proxy connecting %s\n", addrConnect.ToString().c_str());
196 char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
197 memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
198 memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
199 char* pszSocks4 = pszSocks4IP;
200 int nSize = sizeof(pszSocks4IP);
202 int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
205 closesocket(hSocket);
206 return error("Error sending to proxy");
209 if (recv(hSocket, pchRet, 8, 0) != 8)
211 closesocket(hSocket);
212 return error("Error reading proxy response");
214 if (pchRet[1] != 0x5a)
216 closesocket(hSocket);
217 if (pchRet[1] != 0x5b)
218 printf("ERROR: Proxy returned error %d\n", pchRet[1]);
221 printf("proxy connected %s\n", addrConnect.ToString().c_str());
224 hSocketRet = hSocket;
228 // portDefault is in host order
229 bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
234 int port = portDefault;
237 strlcpy(psz, pszName, sizeof(psz));
240 char* pszColon = strrchr(psz+1,':');
241 char *pszPortEnd = NULL;
242 int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
243 if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
245 if (psz[0] == '[' && pszColon[-1] == ']')
247 // Future: enable IPv6 colon-notation inside []
254 if (port < 0 || port > USHRT_MAX)
259 unsigned int addrIP = inet_addr(pszHost);
260 if (addrIP != INADDR_NONE)
262 // valid IP address passed
263 vaddr.push_back(CAddress(addrIP, port, nServices));
270 struct hostent* phostent = gethostbyname(pszHost);
274 if (phostent->h_addrtype != AF_INET)
277 char** ppAddr = phostent->h_addr_list;
278 while (*ppAddr != NULL && vaddr.size() != nMaxSolutions)
280 CAddress addr(((struct in_addr*)ppAddr[0])->s_addr, port, nServices);
282 vaddr.push_back(addr);
286 return (vaddr.size() > 0);
289 // portDefault is in host order
290 bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup, int portDefault, bool fAllowPort)
292 vector<CAddress> vaddr;
293 bool fRet = Lookup(pszName, vaddr, nServices, 1, fAllowLookup, portDefault, fAllowPort);
299 bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet)
302 if (!ConnectSocket(addrConnect, hSocket))
303 return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
305 send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
308 while (RecvLine(hSocket, strLine))
310 if (strLine.empty()) // HTTP response is separated from headers by blank line
314 if (!RecvLine(hSocket, strLine))
316 closesocket(hSocket);
319 if (pszKeyword == NULL)
321 if (strLine.find(pszKeyword) != string::npos)
323 strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
327 closesocket(hSocket);
328 if (strLine.find("<") != string::npos)
329 strLine = strLine.substr(0, strLine.find("<"));
330 strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
331 while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
332 strLine.resize(strLine.size()-1);
333 CAddress addr(strLine,0,true);
334 printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
335 if (addr.ip == 0 || addr.ip == INADDR_NONE || !addr.IsRoutable())
341 closesocket(hSocket);
342 return error("GetMyExternalIP() : connection closed");
345 // We now get our external IP from the IRC server first and only use this as a backup
346 bool GetMyExternalIP(unsigned int& ipRet)
348 CAddress addrConnect;
350 const char* pszKeyword;
355 for (int nLookup = 0; nLookup <= 1; nLookup++)
356 for (int nHost = 1; nHost <= 2; nHost++)
358 // We should be phasing out our use of sites like these. If we need
359 // replacements, we should ask for volunteers to put this simple
360 // php file on their webserver that prints the client IP:
361 // <?php echo $_SERVER["REMOTE_ADDR"]; ?>
364 addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
368 CAddress addrIP("checkip.dyndns.org", 80, true);
369 if (addrIP.IsValid())
370 addrConnect = addrIP;
373 pszGet = "GET / HTTP/1.1\r\n"
374 "Host: checkip.dyndns.org\r\n"
375 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
376 "Connection: close\r\n"
379 pszKeyword = "Address:";
383 addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
387 CAddress addrIP("www.showmyip.com", 80, true);
388 if (addrIP.IsValid())
389 addrConnect = addrIP;
392 pszGet = "GET /simple/ HTTP/1.1\r\n"
393 "Host: www.showmyip.com\r\n"
394 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
395 "Connection: close\r\n"
398 pszKeyword = NULL; // Returns just IP address
401 if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
408 void ThreadGetMyExternalIP(void* parg)
410 // Wait for IRC to get it first
411 if (!GetBoolArg("-noirc"))
413 for (int i = 0; i < 2 * 60; i++)
416 if (fGotExternalIP || fShutdown)
421 // Fallback in case IRC fails to get it
422 if (GetMyExternalIP(addrLocalHost.ip))
424 printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
425 if (addrLocalHost.IsRoutable())
427 // If we already connected to a few before we had our IP, go back and addr them.
428 // setAddrKnown automatically filters any duplicate sends.
429 CAddress addr(addrLocalHost);
430 addr.nTime = GetAdjustedTime();
431 CRITICAL_BLOCK(cs_vNodes)
432 BOOST_FOREACH(CNode* pnode, vNodes)
433 pnode->PushAddress(addr);
442 bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
444 if (!addr.IsRoutable())
446 if (addr.ip == addrLocalHost.ip)
448 addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
449 bool fUpdated = false;
451 CAddress addrFound = addr;
453 CRITICAL_BLOCK(cs_mapAddresses)
455 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
456 if (it == mapAddresses.end())
459 printf("AddAddress(%s)\n", addr.ToString().c_str());
460 mapAddresses.insert(make_pair(addr.GetKey(), addr));
466 addrFound = (*it).second;
467 if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
469 // Services have been added
470 addrFound.nServices |= addr.nServices;
473 bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
474 int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
475 if (addrFound.nTime < addr.nTime - nUpdateInterval)
477 // Periodically update most recently seen time
478 addrFound.nTime = addr.nTime;
483 // There is a nasty deadlock bug if this is done inside the cs_mapAddresses
485 // Thread 1: begin db transaction (locks inside-db-mutex)
486 // then AddAddress (locks cs_mapAddresses)
487 // Thread 2: AddAddress (locks cs_mapAddresses)
488 // ... then db operation hangs waiting for inside-db-mutex
492 pAddrDB->WriteAddress(addrFound);
494 CAddrDB().WriteAddress(addrFound);
499 void AddressCurrentlyConnected(const CAddress& addr)
501 CAddress *paddrFound = NULL;
503 CRITICAL_BLOCK(cs_mapAddresses)
505 // Only if it's been published already
506 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
507 if (it != mapAddresses.end())
508 paddrFound = &(*it).second;
513 int64 nUpdateInterval = 20 * 60;
514 if (paddrFound->nTime < GetAdjustedTime() - nUpdateInterval)
516 // Periodically update most recently seen time
517 paddrFound->nTime = GetAdjustedTime();
519 addrdb.WriteAddress(*paddrFound);
528 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
530 // If the dialog might get closed before the reply comes back,
531 // call this in the destructor so it doesn't get called after it's deleted.
532 CRITICAL_BLOCK(cs_vNodes)
534 BOOST_FOREACH(CNode* pnode, vNodes)
536 CRITICAL_BLOCK(pnode->cs_mapRequests)
538 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
540 CRequestTracker& tracker = (*mi).second;
541 if (tracker.fn == fn && tracker.param1 == param1)
542 pnode->mapRequests.erase(mi++);
558 // Subscription methods for the broadcast and subscription system.
559 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
561 // The subscription system uses a meet-in-the-middle strategy.
562 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
563 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
566 bool AnySubscribed(unsigned int nChannel)
568 if (pnodeLocalHost->IsSubscribed(nChannel))
570 CRITICAL_BLOCK(cs_vNodes)
571 BOOST_FOREACH(CNode* pnode, vNodes)
572 if (pnode->IsSubscribed(nChannel))
577 bool CNode::IsSubscribed(unsigned int nChannel)
579 if (nChannel >= vfSubscribe.size())
581 return vfSubscribe[nChannel];
584 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
586 if (nChannel >= vfSubscribe.size())
589 if (!AnySubscribed(nChannel))
592 CRITICAL_BLOCK(cs_vNodes)
593 BOOST_FOREACH(CNode* pnode, vNodes)
595 pnode->PushMessage("subscribe", nChannel, nHops);
598 vfSubscribe[nChannel] = true;
601 void CNode::CancelSubscribe(unsigned int nChannel)
603 if (nChannel >= vfSubscribe.size())
606 // Prevent from relaying cancel if wasn't subscribed
607 if (!vfSubscribe[nChannel])
609 vfSubscribe[nChannel] = false;
611 if (!AnySubscribed(nChannel))
613 // Relay subscription cancel
614 CRITICAL_BLOCK(cs_vNodes)
615 BOOST_FOREACH(CNode* pnode, vNodes)
617 pnode->PushMessage("sub-cancel", nChannel);
629 CNode* FindNode(unsigned int ip)
631 CRITICAL_BLOCK(cs_vNodes)
633 BOOST_FOREACH(CNode* pnode, vNodes)
634 if (pnode->addr.ip == ip)
640 CNode* FindNode(CAddress addr)
642 CRITICAL_BLOCK(cs_vNodes)
644 BOOST_FOREACH(CNode* pnode, vNodes)
645 if (pnode->addr == addr)
651 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
653 if (addrConnect.ip == addrLocalHost.ip)
656 // Look for an existing connection
657 CNode* pnode = FindNode(addrConnect.ip);
661 pnode->AddRef(nTimeout);
668 printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
669 addrConnect.ToString().c_str(),
670 (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
671 (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
673 CRITICAL_BLOCK(cs_mapAddresses)
674 mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
678 if (ConnectSocket(addrConnect, hSocket))
681 printf("connected %s\n", addrConnect.ToString().c_str());
683 // Set to nonblocking
686 if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
687 printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
689 if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
690 printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
694 CNode* pnode = new CNode(hSocket, addrConnect, false);
696 pnode->AddRef(nTimeout);
699 CRITICAL_BLOCK(cs_vNodes)
700 vNodes.push_back(pnode);
702 pnode->nTimeConnected = GetTime();
711 void CNode::CloseSocketDisconnect()
714 if (hSocket != INVALID_SOCKET)
717 printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
718 printf("disconnecting node %s\n", addr.ToString().c_str());
719 closesocket(hSocket);
720 hSocket = INVALID_SOCKET;
725 void CNode::Cleanup()
727 // All of a nodes broadcasts and subscriptions are automatically torn down
728 // when it goes down, so a node has to stay up to keep its broadcast going.
730 // Cancel subscriptions
731 for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
732 if (vfSubscribe[nChannel])
733 CancelSubscribe(nChannel);
737 std::map<unsigned int, int64> CNode::setBanned;
738 CCriticalSection CNode::cs_setBanned;
740 void CNode::ClearBanned()
745 bool CNode::IsBanned(unsigned int ip)
747 bool fResult = false;
748 CRITICAL_BLOCK(cs_setBanned)
750 std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
751 if (i != setBanned.end())
753 int64 t = (*i).second;
761 bool CNode::Misbehaving(int howmuch)
765 printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
769 nMisbehavior += howmuch;
770 if (nMisbehavior >= GetArg("-banscore", 100))
772 int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
773 CRITICAL_BLOCK(cs_setBanned)
774 if (setBanned[addr.ip] < banTime)
775 setBanned[addr.ip] = banTime;
776 CloseSocketDisconnect();
777 printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
794 void ThreadSocketHandler(void* parg)
796 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
799 vnThreadsRunning[0]++;
800 ThreadSocketHandler2(parg);
801 vnThreadsRunning[0]--;
803 catch (std::exception& e) {
804 vnThreadsRunning[0]--;
805 PrintException(&e, "ThreadSocketHandler()");
807 vnThreadsRunning[0]--;
808 throw; // support pthread_cancel()
810 printf("ThreadSocketHandler exiting\n");
813 void ThreadSocketHandler2(void* parg)
815 printf("ThreadSocketHandler started\n");
816 list<CNode*> vNodesDisconnected;
817 int nPrevNodeCount = 0;
824 CRITICAL_BLOCK(cs_vNodes)
826 // Disconnect unused nodes
827 vector<CNode*> vNodesCopy = vNodes;
828 BOOST_FOREACH(CNode* pnode, vNodesCopy)
830 if (pnode->fDisconnect ||
831 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
833 // remove from vNodes
834 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
836 // close socket and cleanup
837 pnode->CloseSocketDisconnect();
840 // hold in disconnected pool until all refs are released
841 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
842 if (pnode->fNetworkNode || pnode->fInbound)
844 vNodesDisconnected.push_back(pnode);
848 // Delete disconnected nodes
849 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
850 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
852 // wait until threads are done using it
853 if (pnode->GetRefCount() <= 0)
855 bool fDelete = false;
856 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
857 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
858 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
859 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
863 vNodesDisconnected.remove(pnode);
869 if (vNodes.size() != nPrevNodeCount)
871 nPrevNodeCount = vNodes.size();
877 // Find which sockets have data to receive
879 struct timeval timeout;
881 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
888 FD_ZERO(&fdsetError);
889 SOCKET hSocketMax = 0;
891 if(hListenSocket != INVALID_SOCKET)
892 FD_SET(hListenSocket, &fdsetRecv);
893 hSocketMax = max(hSocketMax, hListenSocket);
894 CRITICAL_BLOCK(cs_vNodes)
896 BOOST_FOREACH(CNode* pnode, vNodes)
898 if (pnode->hSocket == INVALID_SOCKET)
900 FD_SET(pnode->hSocket, &fdsetRecv);
901 FD_SET(pnode->hSocket, &fdsetError);
902 hSocketMax = max(hSocketMax, pnode->hSocket);
903 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
904 if (!pnode->vSend.empty())
905 FD_SET(pnode->hSocket, &fdsetSend);
909 vnThreadsRunning[0]--;
910 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
911 vnThreadsRunning[0]++;
914 if (nSelect == SOCKET_ERROR)
916 int nErr = WSAGetLastError();
919 printf("socket select error %d\n", nErr);
920 for (unsigned int i = 0; i <= hSocketMax; i++)
921 FD_SET(i, &fdsetRecv);
924 FD_ZERO(&fdsetError);
925 Sleep(timeout.tv_usec/1000);
930 // Accept new connections
932 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
934 struct sockaddr_in sockaddr;
935 socklen_t len = sizeof(sockaddr);
936 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
940 if (hSocket != INVALID_SOCKET)
941 addr = CAddress(sockaddr);
943 CRITICAL_BLOCK(cs_vNodes)
944 BOOST_FOREACH(CNode* pnode, vNodes)
948 if (hSocket == INVALID_SOCKET)
950 if (WSAGetLastError() != WSAEWOULDBLOCK)
951 printf("socket error accept failed: %d\n", WSAGetLastError());
953 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
955 closesocket(hSocket);
957 else if (CNode::IsBanned(addr.ip))
959 printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
960 closesocket(hSocket);
964 printf("accepted connection %s\n", addr.ToString().c_str());
965 CNode* pnode = new CNode(hSocket, addr, true);
967 CRITICAL_BLOCK(cs_vNodes)
968 vNodes.push_back(pnode);
974 // Service each socket
976 vector<CNode*> vNodesCopy;
977 CRITICAL_BLOCK(cs_vNodes)
980 BOOST_FOREACH(CNode* pnode, vNodesCopy)
983 BOOST_FOREACH(CNode* pnode, vNodesCopy)
991 if (pnode->hSocket == INVALID_SOCKET)
993 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
995 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
997 CDataStream& vRecv = pnode->vRecv;
998 unsigned int nPos = vRecv.size();
1000 if (nPos > ReceiveBufferSize()) {
1001 if (!pnode->fDisconnect)
1002 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
1003 pnode->CloseSocketDisconnect();
1006 // typical socket buffer is 8K-64K
1007 char pchBuf[0x10000];
1008 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1011 vRecv.resize(nPos + nBytes);
1012 memcpy(&vRecv[nPos], pchBuf, nBytes);
1013 pnode->nLastRecv = GetTime();
1015 else if (nBytes == 0)
1017 // socket closed gracefully
1018 if (!pnode->fDisconnect)
1019 printf("socket closed\n");
1020 pnode->CloseSocketDisconnect();
1022 else if (nBytes < 0)
1025 int nErr = WSAGetLastError();
1026 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1028 if (!pnode->fDisconnect)
1029 printf("socket recv error %d\n", nErr);
1030 pnode->CloseSocketDisconnect();
1040 if (pnode->hSocket == INVALID_SOCKET)
1042 if (FD_ISSET(pnode->hSocket, &fdsetSend))
1044 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1046 CDataStream& vSend = pnode->vSend;
1049 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
1052 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1053 pnode->nLastSend = GetTime();
1055 else if (nBytes < 0)
1058 int nErr = WSAGetLastError();
1059 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1061 printf("socket send error %d\n", nErr);
1062 pnode->CloseSocketDisconnect();
1065 if (vSend.size() > SendBufferSize()) {
1066 if (!pnode->fDisconnect)
1067 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1068 pnode->CloseSocketDisconnect();
1075 // Inactivity checking
1077 if (pnode->vSend.empty())
1078 pnode->nLastSendEmpty = GetTime();
1079 if (GetTime() - pnode->nTimeConnected > 60)
1081 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1083 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1084 pnode->fDisconnect = true;
1086 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1088 printf("socket not sending\n");
1089 pnode->fDisconnect = true;
1091 else if (GetTime() - pnode->nLastRecv > 90*60)
1093 printf("socket inactivity timeout\n");
1094 pnode->fDisconnect = true;
1098 CRITICAL_BLOCK(cs_vNodes)
1100 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1117 void ThreadMapPort(void* parg)
1119 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1122 vnThreadsRunning[5]++;
1123 ThreadMapPort2(parg);
1124 vnThreadsRunning[5]--;
1126 catch (std::exception& e) {
1127 vnThreadsRunning[5]--;
1128 PrintException(&e, "ThreadMapPort()");
1130 vnThreadsRunning[5]--;
1131 PrintException(NULL, "ThreadMapPort()");
1133 printf("ThreadMapPort exiting\n");
1136 void ThreadMapPort2(void* parg)
1138 printf("ThreadMapPort started\n");
1141 sprintf(port, "%d", GetListenPort());
1143 const char * multicastif = 0;
1144 const char * minissdpdpath = 0;
1145 struct UPNPDev * devlist = 0;
1148 #ifndef UPNPDISCOVER_SUCCESS
1150 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1154 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1157 struct UPNPUrls urls;
1158 struct IGDdatas data;
1161 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1164 if (!addrLocalHost.IsRoutable())
1166 char externalIPAddress[40];
1167 r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1168 if(r != UPNPCOMMAND_SUCCESS)
1169 printf("UPnP: GetExternalIPAddress() returned %d\n", r);
1172 if(externalIPAddress[0])
1174 printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1175 CAddress addrExternalFromUPnP(externalIPAddress, 0, false, nLocalServices);
1176 if (addrExternalFromUPnP.IsRoutable())
1177 addrLocalHost = addrExternalFromUPnP;
1180 printf("UPnP: GetExternalIPAddress failed.\n");
1184 string strDesc = "Bitcoin " + FormatFullVersion();
1185 #ifndef UPNPDISCOVER_SUCCESS
1187 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1188 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1191 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1192 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1195 if(r!=UPNPCOMMAND_SUCCESS)
1196 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1197 port, port, lanaddr, r, strupnperror(r));
1199 printf("UPnP Port Mapping successful.\n");
1202 if (fShutdown || !fUseUPnP)
1204 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1205 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1206 freeUPNPDevlist(devlist); devlist = 0;
1207 FreeUPNPUrls(&urls);
1210 if (i % 600 == 0) // Refresh every 20 minutes
1212 #ifndef UPNPDISCOVER_SUCCESS
1214 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1215 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1218 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1219 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1222 if(r!=UPNPCOMMAND_SUCCESS)
1223 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1224 port, port, lanaddr, r, strupnperror(r));
1226 printf("UPnP Port Mapping successful.\n");;
1232 printf("No valid UPnP IGDs found\n");
1233 freeUPNPDevlist(devlist); devlist = 0;
1235 FreeUPNPUrls(&urls);
1237 if (fShutdown || !fUseUPnP)
1244 void MapPort(bool fMapPort)
1246 if (fUseUPnP != fMapPort)
1248 fUseUPnP = fMapPort;
1249 WriteSetting("fUseUPnP", fUseUPnP);
1251 if (fUseUPnP && vnThreadsRunning[5] < 1)
1253 if (!CreateThread(ThreadMapPort, NULL))
1254 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1258 void MapPort(bool /* unused fMapPort */)
1260 // Intentionally left blank.
1273 static const char *strDNSSeed[] = {
1275 "dnsseed.bluematt.me",
1276 "seed.bitcoin.sipa.be",
1277 "dnsseed.bitcoin.dashjr.org",
1280 void ThreadDNSAddressSeed(void* parg)
1282 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1285 vnThreadsRunning[6]++;
1286 ThreadDNSAddressSeed2(parg);
1287 vnThreadsRunning[6]--;
1289 catch (std::exception& e) {
1290 vnThreadsRunning[6]--;
1291 PrintException(&e, "ThreadDNSAddressSeed()");
1293 vnThreadsRunning[6]--;
1294 throw; // support pthread_cancel()
1296 printf("ThreadDNSAddressSeed exiting\n");
1299 void ThreadDNSAddressSeed2(void* parg)
1301 printf("ThreadDNSAddressSeed started\n");
1306 printf("Loading addresses from DNS seeds (could take a while)\n");
1308 for (unsigned int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1309 vector<CAddress> vaddr;
1310 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1314 BOOST_FOREACH (CAddress& addr, vaddr)
1316 if (addr.GetByte(3) != 127)
1319 AddAddress(addr, 0, &addrDB);
1323 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1328 printf("%d addresses found from DNS seeds\n", found);
1342 unsigned int pnSeed[] =
1344 0x959bd347, 0xf8de42b2, 0x73bc0518, 0xea6edc50, 0x21b00a4d, 0xc725b43d, 0xd665464d, 0x1a2a770e,
1345 0x27c93946, 0x65b2fa46, 0xb80ae255, 0x66b3b446, 0xb1877a3e, 0x6ee89e3e, 0xc3175b40, 0x2a01a83c,
1346 0x95b1363a, 0xa079ad3d, 0xe6ca801f, 0x027f4f4a, 0x34f7f03a, 0xf790f04a, 0x16ca801f, 0x2f4d5e40,
1347 0x3a4d5e40, 0xc43a322e, 0xc8159753, 0x14d4724c, 0x7919a118, 0xe0bdb34e, 0x68a16b2e, 0xff64b44d,
1348 0x6099115b, 0x9b57b05b, 0x7bd1b4ad, 0xdf95944f, 0x29d2b73d, 0xafa8db79, 0xe247ba41, 0x24078348,
1349 0xf722f03c, 0x33567ebc, 0xace64ed4, 0x984d3932, 0xb5f34e55, 0x27b7024d, 0x94579247, 0x8894042e,
1350 0x9357d34c, 0x1063c24b, 0xcaa228b1, 0xa3c5a8b2, 0x5dc64857, 0xa2c23643, 0xa8369a54, 0x31203077,
1351 0x00707c5c, 0x09fc0b3a, 0x272e9e2e, 0xf80f043e, 0x9449ca3e, 0x5512c33e, 0xd106b555, 0xe8024157,
1352 0xe288ec29, 0xc79c5461, 0xafb63932, 0xdb02ab4b, 0x0e512777, 0x8a145a4c, 0xb201ff4f, 0x5e09314b,
1353 0xcd9bfbcd, 0x1c023765, 0x4394e75c, 0xa728bd4d, 0x65331552, 0xa98420b1, 0x89ecf559, 0x6e80801f,
1354 0xf404f118, 0xefd62b51, 0x05918346, 0x9b186d5f, 0xacabab46, 0xf912e255, 0xc188ea62, 0xcc55734e,
1355 0xc668064d, 0xd77a4558, 0x46201c55, 0xf17dfc80, 0xf7142f2e, 0x87bfb718, 0x8aa54fb2, 0xc451d518,
1356 0xc4ae8831, 0x8dd44d55, 0x5bbd206c, 0x64536b5d, 0x5c667e60, 0x3b064242, 0xfe963a42, 0xa28e6dc8,
1357 0xe8a9604a, 0xc989464e, 0xd124a659, 0x50065140, 0xa44dfe5e, 0x1079e655, 0x3fb986d5, 0x47895b18,
1358 0x7d3ce4ad, 0x4561ba50, 0x296eec62, 0x255b41ad, 0xaed35ec9, 0x55556f12, 0xc7d3154d, 0x3297b65d,
1359 0x8930121f, 0xabf42e4e, 0x4a29e044, 0x1212685d, 0x676c1e40, 0xce009744, 0x383a8948, 0xa2dbd0ad,
1360 0xecc2564d, 0x07dbc252, 0x887ee24b, 0x5171644c, 0x6bb798c1, 0x847f495d, 0x4cbb7145, 0x3bb81c32,
1361 0x45eb262e, 0xc8015a4e, 0x250a361b, 0xf694f946, 0xd64a183e, 0xd4f1dd59, 0x8f20ffd4, 0x51d9e55c,
1362 0x09521763, 0x5e02002e, 0x32c8074d, 0xe685762e, 0x8290b0bc, 0x762a922e, 0xfc5ee754, 0x83a24829,
1363 0x775b224d, 0x6295bb4d, 0x38ec0555, 0xbffbba50, 0xe5560260, 0x86b16a7c, 0xd372234e, 0x49a3c24b,
1364 0x2f6a171f, 0x4d75ed60, 0xae94115b, 0xcb543744, 0x63080c59, 0x3f9c724c, 0xc977ce18, 0x532efb18,
1365 0x69dc3b2e, 0x5f94d929, 0x1732bb4d, 0x9c814b4d, 0xe6b3762e, 0xc024f662, 0x8face35b, 0x6b5b044d,
1366 0x798c7b57, 0x79a6b44c, 0x067d3057, 0xf9e94e5f, 0x91cbe15b, 0x71405eb2, 0x2662234e, 0xcbcc4a6d,
1367 0xbf69d54b, 0xa79b4e55, 0xec6d3e51, 0x7c0b3c02, 0x60f83653, 0x24c1e15c, 0x1110b62e, 0x10350f59,
1368 0xa56f1d55, 0x3509e7a9, 0xeb128354, 0x14268e2e, 0x934e28bc, 0x8e32692e, 0x8331a21f, 0x3e633932,
1369 0xc812b12e, 0xc684bf2e, 0x80112d2e, 0xe0ddc96c, 0xc630ca4a, 0x5c09b3b2, 0x0b580518, 0xc8e9d54b,
1370 0xd169aa43, 0x17d0d655, 0x1d029963, 0x7ff87559, 0xcb701f1f, 0x6fa3e85d, 0xe45e9a54, 0xf05d1802,
1371 0x44d03b2e, 0x837b692e, 0xccd4354e, 0x3d6da13c, 0x3423084d, 0xf707c34a, 0x55f6db3a, 0xad26e442,
1372 0x6233a21f, 0x09e80e59, 0x8caeb54d, 0xbe870941, 0xb407d20e, 0x20b51018, 0x56fb152e, 0x460d2a4e,
1373 0xbb9a2946, 0x560eb12e, 0xed83dd29, 0xd6724f53, 0xa50aafb8, 0x451346d9, 0x88348e2e, 0x7312fead,
1374 0x8ecaf96f, 0x1bda4e5f, 0xf1671e40, 0x3c8c3e3b, 0x4716324d, 0xdde24ede, 0xf98cd17d, 0xa91d4644,
1375 0x28124eb2, 0x147d5129, 0xd022042e, 0x61733d3b, 0xad0d5e02, 0x8ce2932e, 0xe5c18502, 0x549c1e32,
1376 0x9685801f, 0x86e217ad, 0xd948214b, 0x4110f462, 0x3a2e894e, 0xbd35492e, 0x87e0d558, 0x64b8ef7d,
1377 0x7c3eb962, 0x72a84b3e, 0x7cd667c9, 0x28370a2e, 0x4bc60e7b, 0x6fc1ec60, 0x14a6983f, 0x86739a4b,
1378 0x46954e5f, 0x32e2e15c, 0x2e9326cf, 0xe5801c5e, 0x379607b2, 0x32151145, 0xf0e39744, 0xacb54c55,
1379 0xa37dfb60, 0x83b55cc9, 0x388f7ca5, 0x15034f5f, 0x3e94965b, 0x68e0ffad, 0x35280f59, 0x8fe190cf,
1380 0x7c6ba5b2, 0xa5e9db43, 0x4ee1fc60, 0xd9d94e5f, 0x04040677, 0x0ea9b35e, 0x5961f14f, 0x67fda063,
1381 0xa48a5a31, 0xc6524e55, 0x283d325e, 0x3f37515f, 0x96b94b3e, 0xacce620e, 0x6481cc5b, 0xa4a06d4b,
1382 0x9e95d2d9, 0xe40c03d5, 0xc2f4514b, 0xb79aad44, 0xf64be843, 0xb2064070, 0xfca00455, 0x429dfa4e,
1383 0x2323f173, 0xeda4185e, 0xabd5227d, 0x9efd4d58, 0xb1104758, 0x4811e955, 0xbd9ab355, 0xe921f44b,
1384 0x9f166dce, 0x09e279b2, 0xe0c9ac7b, 0x7901a5ad, 0xa145d4b0, 0x79104671, 0xec31e35a, 0x4fe0b555,
1385 0xc7d9cbad, 0xad057f55, 0xe94cc759, 0x7fe0b043, 0xe4529f2e, 0x0d4dd4b2, 0x9f11a54d, 0x031e2e4e,
1386 0xe6014f5f, 0x11d1ca6c, 0x26bd7f61, 0xeb86854f, 0x4d347b57, 0x116bbe2e, 0xdba7234e, 0x7bcbfd2e,
1387 0x174dd4b2, 0x6686762e, 0xb089ba50, 0xc6258246, 0x087e767b, 0xc4a8cb4a, 0x595dba50, 0x7f0ae502,
1388 0x7b1dbd5a, 0xa0603492, 0x57d1af4b, 0x9e21ffd4, 0x6393064d, 0x7407376e, 0xe484762e, 0x122a4e53,
1389 0x4a37aa43, 0x3888a6be, 0xee77864e, 0x039c8dd5, 0x688d89af, 0x0e988f62, 0x08218246, 0xfc2f8246,
1390 0xd1d97040, 0xd64cd4b2, 0x5ae4a6b8, 0x7d0de9bc, 0x8d304d61, 0x06c5c672, 0xa4c8bd4d, 0xe0fd373b,
1391 0x575ebe4d, 0x72d26277, 0x55570f55, 0x77b154d9, 0xe214293a, 0xfc740f4b, 0xfe3f6a57, 0xa9c55f02,
1392 0xae4054db, 0x2394d918, 0xb511b24a, 0xb8741ab2, 0x0758e65e, 0xc7b5795b, 0xb0a30a4c, 0xaf7f170c,
1393 0xf3b4762e, 0x8179576d, 0x738a1581, 0x4b95b64c, 0x9829b618, 0x1bea932e, 0x7bdeaa4b, 0xcb5e0281,
1394 0x65618f54, 0x0658474b, 0x27066acf, 0x40556d65, 0x7d204d53, 0xf28bc244, 0xdce23455, 0xadc0ff54,
1395 0x3863c948, 0xcee34e5f, 0xdeb85e02, 0x2ed17a61, 0x6a7b094d, 0x7f0cfc40, 0x59603f54, 0x3220afbc,
1396 0xb5dfd962, 0x125d21c0, 0x13f8d243, 0xacfefb4e, 0x86c2c147, 0x3d8bbd59, 0xbd02a21f, 0x2593042e,
1397 0xc6a17a7c, 0x28925861, 0xb487ed44, 0xb5f4fd6d, 0x90c28a45, 0x5a14f74d, 0x43d71b4c, 0x728ebb5d,
1398 0x885bf950, 0x08134dd0, 0x38ec046e, 0xc575684b, 0x50082d2e, 0xa2f47757, 0x270f86ae, 0xf3ff6462,
1399 0x10ed3f4e, 0x4b58d462, 0xe01ce23e, 0x8c5b092e, 0x63e52f4e, 0x22c1e85d, 0xa908f54e, 0x8591624f,
1400 0x2c0fb94e, 0xa280ba3c, 0xb6f41b4c, 0x24f9aa47, 0x27201647, 0x3a3ea6dc, 0xa14fc3be, 0x3c34bdd5,
1401 0x5b8d4f5b, 0xaadeaf4b, 0xc71cab50, 0x15697a4c, 0x9a1a734c, 0x2a037d81, 0x2590bd59, 0x48ec2741,
1402 0x53489c5b, 0x7f00314b, 0x2170d362, 0xf2e92542, 0x42c10b44, 0x98f0f118, 0x883a3456, 0x099a932e,
1403 0xea38f7bc, 0x644e9247, 0xbb61b62e, 0x30e0863d, 0x5f51be54, 0x207215c7, 0x5f306c45, 0xaa7f3932,
1404 0x98da7d45, 0x4e339b59, 0x2e411581, 0xa808f618, 0xad2c0c59, 0x54476741, 0x09e99fd1, 0x5db8f752,
1405 0xc16df8bd, 0x1dd4b44f, 0x106edf2e, 0x9e15c180, 0x2ad6b56f, 0x633a5332, 0xff33787c, 0x077cb545,
1406 0x6610be6d, 0x75aad2c4, 0x72fb4d5b, 0xe81e0f59, 0x576f6332, 0x47333373, 0x351ed783, 0x2d90fb50,
1407 0x8d5e0f6c, 0x5b27a552, 0xdb293ebb, 0xe55ef950, 0x4b133ad8, 0x75df975a, 0x7b6a8740, 0xa899464b,
1408 0xfab15161, 0x10f8b64d, 0xd055ea4d, 0xee8e146b, 0x4b14afb8, 0x4bc1c44a, 0x9b961dcc, 0xd111ff43,
1409 0xfca0b745, 0xc800e412, 0x0afad9d1, 0xf751c350, 0xf9f0cccf, 0xa290a545, 0x8ef13763, 0x7ec70d59,
1410 0x2b066acf, 0x65496c45, 0xade02c1b, 0xae6eb077, 0x92c1e65b, 0xc064e6a9, 0xc649e56d, 0x5287a243,
1411 0x36de4f5b, 0x5b1df6ad, 0x65c39a59, 0xdba805b2, 0x20067aa8, 0x6457e56d, 0x3cee26cf, 0xfd3ff26d,
1412 0x04f86d4a, 0x06b8e048, 0xa93bcd5c, 0x91135852, 0xbe90a643, 0x8fa0094d, 0x06d8215f, 0x2677094d,
1413 0xd735685c, 0x164a00c9, 0x5209ac5f, 0xa9564c5c, 0x3b504f5f, 0xcc826bd0, 0x4615042e, 0x5fe13b4a,
1414 0x8c81b86d, 0x879ab68c, 0x1de564b8, 0x434487d8, 0x2dcb1b63, 0x82ab524a, 0xb0676abb, 0xa13d9c62,
1415 0xdbb5b86d, 0x5b7f4b59, 0xaddfb44d, 0xad773532, 0x3997054c, 0x72cebd89, 0xb194544c, 0xc5b8046e,
1416 0x6e1adeb2, 0xaa5abb51, 0xefb54b44, 0x15efc54f, 0xe9f1bc4d, 0x5f401b6c, 0x97f018ad, 0xc82f9252,
1417 0x2cdc762e, 0x8e52e56d, 0x1827175e, 0x9b7d7d80, 0xb2ad6845, 0x51065140, 0x71180a18, 0x5b27006c,
1418 0x0621e255, 0x721cbe58, 0x670c0cb8, 0xf8bd715d, 0xe0bdc5d9, 0xed843501, 0x4b84554d, 0x7f1a18bc,
1419 0x53bcaf47, 0x5729d35f, 0xf0dda246, 0x22382bd0, 0x4d641fb0, 0x316afcde, 0x50a22f1f, 0x73608046,
1420 0xc461d84a, 0xb2dbe247,
1425 void ThreadOpenConnections(void* parg)
1427 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1430 vnThreadsRunning[1]++;
1431 ThreadOpenConnections2(parg);
1432 vnThreadsRunning[1]--;
1434 catch (std::exception& e) {
1435 vnThreadsRunning[1]--;
1436 PrintException(&e, "ThreadOpenConnections()");
1438 vnThreadsRunning[1]--;
1439 PrintException(NULL, "ThreadOpenConnections()");
1441 printf("ThreadOpenConnections exiting\n");
1444 void ThreadOpenConnections2(void* parg)
1446 printf("ThreadOpenConnections started\n");
1448 // Connect to specific addresses
1449 if (mapArgs.count("-connect"))
1451 for (int64 nLoop = 0;; nLoop++)
1453 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1455 CAddress addr(strAddr, fAllowDNS);
1457 OpenNetworkConnection(addr);
1458 for (int i = 0; i < 10 && i < nLoop; i++)
1468 // Connect to manually added nodes first
1469 if (mapArgs.count("-addnode"))
1471 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1473 CAddress addr(strAddr, fAllowDNS);
1476 OpenNetworkConnection(addr);
1484 // Initiate network connections
1485 int64 nStart = GetTime();
1488 vnThreadsRunning[1]--;
1490 vnThreadsRunning[1]++;
1494 // Limit outbound connections
1498 CRITICAL_BLOCK(cs_vNodes)
1499 BOOST_FOREACH(CNode* pnode, vNodes)
1500 if (!pnode->fInbound)
1502 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1503 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1504 if (nOutbound < nMaxOutboundConnections)
1506 vnThreadsRunning[1]--;
1508 vnThreadsRunning[1]++;
1513 bool fAddSeeds = false;
1515 CRITICAL_BLOCK(cs_mapAddresses)
1517 // Add seed nodes if IRC isn't working
1518 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1519 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
1525 for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
1527 // It'll only connect to one or two seed nodes because once it connects,
1528 // it'll get a pile of addresses with newer timestamps.
1529 // Seed nodes are given a random 'last seen time' of between one and two
1531 const int64 nOneWeek = 7*24*60*60;
1533 addr.ip = pnSeed[i];
1534 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1540 // Choose an address to connect to based on most recently seen
1542 CAddress addrConnect;
1543 int64 nBest = INT64_MIN;
1545 // Only connect to one address per a.b.?.? range.
1546 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1547 set<unsigned int> setConnected;
1548 CRITICAL_BLOCK(cs_vNodes)
1549 BOOST_FOREACH(CNode* pnode, vNodes)
1550 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1552 int64 nANow = GetAdjustedTime();
1554 CRITICAL_BLOCK(cs_mapAddresses)
1556 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1558 const CAddress& addr = item.second;
1559 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1561 int64 nSinceLastSeen = nANow - addr.nTime;
1562 int64 nSinceLastTry = nANow - addr.nLastTry;
1564 // Randomize the order in a deterministic way, putting the standard port first
1565 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1566 if (addr.port != htons(GetDefaultPort()))
1567 nRandomizer += 2 * 60 * 60;
1569 // Last seen Base retry frequency
1578 // 365 days 93 hours
1579 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1581 // Fast reconnect for one hour after last seen
1582 if (nSinceLastSeen < 60 * 60)
1585 // Limit retry frequency
1586 if (nSinceLastTry < nDelay)
1589 // If we have IRC, we'll be notified when they first come online,
1590 // and again every 24 hours by the refresh broadcast.
1591 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1594 // Only try the old stuff if we don't have enough connections
1595 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1598 // If multiple addresses are ready, prioritize by time since
1599 // last seen and time since last tried.
1600 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1609 if (addrConnect.IsValid())
1610 OpenNetworkConnection(addrConnect);
1614 bool OpenNetworkConnection(const CAddress& addrConnect)
1617 // Initiate outbound network connection
1621 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
1622 FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
1625 vnThreadsRunning[1]--;
1626 CNode* pnode = ConnectNode(addrConnect);
1627 vnThreadsRunning[1]++;
1632 pnode->fNetworkNode = true;
1644 void ThreadMessageHandler(void* parg)
1646 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1649 vnThreadsRunning[2]++;
1650 ThreadMessageHandler2(parg);
1651 vnThreadsRunning[2]--;
1653 catch (std::exception& e) {
1654 vnThreadsRunning[2]--;
1655 PrintException(&e, "ThreadMessageHandler()");
1657 vnThreadsRunning[2]--;
1658 PrintException(NULL, "ThreadMessageHandler()");
1660 printf("ThreadMessageHandler exiting\n");
1663 void ThreadMessageHandler2(void* parg)
1665 printf("ThreadMessageHandler started\n");
1666 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1669 vector<CNode*> vNodesCopy;
1670 CRITICAL_BLOCK(cs_vNodes)
1672 vNodesCopy = vNodes;
1673 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1677 // Poll the connected nodes for messages
1678 CNode* pnodeTrickle = NULL;
1679 if (!vNodesCopy.empty())
1680 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1681 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1684 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1685 ProcessMessages(pnode);
1690 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1691 SendMessages(pnode, pnode == pnodeTrickle);
1696 CRITICAL_BLOCK(cs_vNodes)
1698 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1702 // Wait and allow messages to bunch up.
1703 // Reduce vnThreadsRunning so StopNode has permission to exit while
1704 // we're sleeping, but we must always check fShutdown after doing this.
1705 vnThreadsRunning[2]--;
1707 if (fRequestShutdown)
1709 vnThreadsRunning[2]++;
1720 bool BindListenPort(string& strError)
1724 addrLocalHost.port = htons(GetListenPort());
1727 // Initialize Windows Sockets
1729 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1730 if (ret != NO_ERROR)
1732 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1733 printf("%s\n", strError.c_str());
1738 // Create socket for listening for incoming connections
1739 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1740 if (hListenSocket == INVALID_SOCKET)
1742 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1743 printf("%s\n", strError.c_str());
1748 // Different way of disabling SIGPIPE on BSD
1749 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1753 // Allow binding if the port is still in TIME_WAIT state after
1754 // the program was closed and restarted. Not an issue on windows.
1755 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1759 // Set to nonblocking, incoming connections will also inherit this
1760 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1762 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1765 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1766 printf("%s\n", strError.c_str());
1770 // The sockaddr_in structure specifies the address family,
1771 // IP address, and port for the socket that is being bound
1772 struct sockaddr_in sockaddr;
1773 memset(&sockaddr, 0, sizeof(sockaddr));
1774 sockaddr.sin_family = AF_INET;
1775 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1776 sockaddr.sin_port = htons(GetListenPort());
1777 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1779 int nErr = WSAGetLastError();
1780 if (nErr == WSAEADDRINUSE)
1781 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1783 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1784 printf("%s\n", strError.c_str());
1787 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1789 // Listen for incoming connections
1790 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1792 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1793 printf("%s\n", strError.c_str());
1800 void StartNode(void* parg)
1802 if (pnodeLocalHost == NULL)
1803 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1806 // Get local host ip
1807 char pszHostName[1000] = "";
1808 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1810 vector<CAddress> vaddr;
1811 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1812 BOOST_FOREACH (const CAddress &addr, vaddr)
1813 if (addr.GetByte(3) != 127)
1815 addrLocalHost = addr;
1820 // Get local host ip
1821 struct ifaddrs* myaddrs;
1822 if (getifaddrs(&myaddrs) == 0)
1824 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1826 if (ifa->ifa_addr == NULL) continue;
1827 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1828 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1829 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1831 if (ifa->ifa_addr->sa_family == AF_INET)
1833 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1834 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1835 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1837 // Take the first IP that isn't loopback 127.x.x.x
1838 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1839 if (addr.IsValid() && addr.GetByte(3) != 127)
1841 addrLocalHost = addr;
1845 else if (ifa->ifa_addr->sa_family == AF_INET6)
1847 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1848 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1849 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1852 freeifaddrs(myaddrs);
1855 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1857 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1859 // Proxies can't take incoming connections
1860 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1861 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1865 CreateThread(ThreadGetMyExternalIP, NULL);
1872 if (GetBoolArg("-nodnsseed"))
1873 printf("DNS seeding disabled\n");
1875 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1876 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1878 // Map ports with UPnP
1882 // Get addresses from IRC and advertise ours
1883 if (!CreateThread(ThreadIRCSeed, NULL))
1884 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1886 // Send and receive from sockets, accept connections
1887 if (!CreateThread(ThreadSocketHandler, NULL))
1888 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1890 // Initiate outbound connections
1891 if (!CreateThread(ThreadOpenConnections, NULL))
1892 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1895 if (!CreateThread(ThreadMessageHandler, NULL))
1896 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1898 // Generate coins in the background
1899 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1904 printf("StopNode()\n");
1906 nTransactionsUpdated++;
1907 int64 nStart = GetTime();
1908 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1910 || vnThreadsRunning[5] > 0
1914 if (GetTime() - nStart > 20)
1918 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1919 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1920 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1921 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1922 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1923 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1924 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1925 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1941 BOOST_FOREACH(CNode* pnode, vNodes)
1942 if (pnode->hSocket != INVALID_SOCKET)
1943 closesocket(pnode->hSocket);
1944 if (hListenSocket != INVALID_SOCKET)
1945 if (closesocket(hListenSocket) == SOCKET_ERROR)
1946 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1949 // Shutdown Windows Sockets
1954 instance_of_cnetcleanup;