1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2011 The Bitcoin developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
18 #include <miniupnpc/miniwget.h>
19 #include <miniupnpc/miniupnpc.h>
20 #include <miniupnpc/upnpcommands.h>
21 #include <miniupnpc/upnperrors.h>
25 using namespace boost;
27 static const int MAX_OUTBOUND_CONNECTIONS = 8;
29 void ThreadMessageHandler2(void* parg);
30 void ThreadSocketHandler2(void* parg);
31 void ThreadOpenConnections2(void* parg);
33 void ThreadMapPort2(void* parg);
35 void ThreadDNSAddressSeed2(void* parg);
36 bool OpenNetworkConnection(const CAddress& addrConnect);
43 // Global state variables
46 bool fAllowDNS = false;
47 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
48 CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
49 static CNode* pnodeLocalHost = NULL;
50 uint64 nLocalHostNonce = 0;
51 array<int, 10> vnThreadsRunning;
52 static SOCKET hListenSocket = INVALID_SOCKET;
54 vector<CNode*> vNodes;
55 CCriticalSection cs_vNodes;
56 map<vector<unsigned char>, CAddress> mapAddresses;
57 CCriticalSection cs_mapAddresses;
58 map<CInv, CDataStream> mapRelay;
59 deque<pair<int64, CInv> > vRelayExpiration;
60 CCriticalSection cs_mapRelay;
61 map<CInv, int64> mapAlreadyAskedFor;
64 int fUseProxy = false;
65 int nConnectTimeout = 5000;
66 CAddress addrProxy("127.0.0.1",9050);
71 unsigned short GetListenPort()
73 return (unsigned short)(GetArg("-port", GetDefaultPort()));
76 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
78 // Filter out duplicate requests
79 if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
81 pindexLastGetBlocksBegin = pindexBegin;
82 hashLastGetBlocksEnd = hashEnd;
84 PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
91 bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
93 hSocketRet = INVALID_SOCKET;
95 SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
96 if (hSocket == INVALID_SOCKET)
100 setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
103 bool fProxy = (fUseProxy && addrConnect.IsRoutable());
104 struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
107 u_long fNonblock = 1;
108 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
110 int fFlags = fcntl(hSocket, F_GETFL, 0);
111 if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
114 closesocket(hSocket);
119 if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
121 // WSAEINVAL is here because some legacy version of winsock uses it
122 if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
124 struct timeval timeout;
125 timeout.tv_sec = nTimeout / 1000;
126 timeout.tv_usec = (nTimeout % 1000) * 1000;
130 FD_SET(hSocket, &fdset);
131 int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
134 printf("connection timeout\n");
135 closesocket(hSocket);
138 if (nRet == SOCKET_ERROR)
140 printf("select() for connection failed: %i\n",WSAGetLastError());
141 closesocket(hSocket);
144 socklen_t nRetSize = sizeof(nRet);
146 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
148 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
151 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
152 closesocket(hSocket);
157 printf("connect() failed after select(): %s\n",strerror(nRet));
158 closesocket(hSocket);
163 else if (WSAGetLastError() != WSAEISCONN)
168 printf("connect() failed: %i\n",WSAGetLastError());
169 closesocket(hSocket);
175 this isn't even strictly necessary
176 CNode::ConnectNode immediately turns the socket back to non-blocking
177 but we'll turn it back to blocking just in case
181 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
183 fFlags = fcntl(hSocket, F_GETFL, 0);
184 if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
187 closesocket(hSocket);
193 printf("proxy connecting %s\n", addrConnect.ToString().c_str());
194 char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
195 memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
196 memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
197 char* pszSocks4 = pszSocks4IP;
198 int nSize = sizeof(pszSocks4IP);
200 int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
203 closesocket(hSocket);
204 return error("Error sending to proxy");
207 if (recv(hSocket, pchRet, 8, 0) != 8)
209 closesocket(hSocket);
210 return error("Error reading proxy response");
212 if (pchRet[1] != 0x5a)
214 closesocket(hSocket);
215 if (pchRet[1] != 0x5b)
216 printf("ERROR: Proxy returned error %d\n", pchRet[1]);
219 printf("proxy connected %s\n", addrConnect.ToString().c_str());
222 hSocketRet = hSocket;
226 // portDefault is in host order
227 bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
232 int port = portDefault;
235 strlcpy(psz, pszName, sizeof(psz));
238 char* pszColon = strrchr(psz+1,':');
239 char *pszPortEnd = NULL;
240 int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
241 if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
243 if (psz[0] == '[' && pszColon[-1] == ']')
245 // Future: enable IPv6 colon-notation inside []
252 if (port < 0 || port > 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 CRITICAL_BLOCK(cs_mapAddresses)
501 // Only if it's been published already
502 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
503 if (it != mapAddresses.end())
505 CAddress& addrFound = (*it).second;
506 int64 nUpdateInterval = 20 * 60;
507 if (addrFound.nTime < GetAdjustedTime() - nUpdateInterval)
509 // Periodically update most recently seen time
510 addrFound.nTime = GetAdjustedTime();
512 addrdb.WriteAddress(addrFound);
522 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
524 // If the dialog might get closed before the reply comes back,
525 // call this in the destructor so it doesn't get called after it's deleted.
526 CRITICAL_BLOCK(cs_vNodes)
528 BOOST_FOREACH(CNode* pnode, vNodes)
530 CRITICAL_BLOCK(pnode->cs_mapRequests)
532 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
534 CRequestTracker& tracker = (*mi).second;
535 if (tracker.fn == fn && tracker.param1 == param1)
536 pnode->mapRequests.erase(mi++);
552 // Subscription methods for the broadcast and subscription system.
553 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
555 // The subscription system uses a meet-in-the-middle strategy.
556 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
557 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
560 bool AnySubscribed(unsigned int nChannel)
562 if (pnodeLocalHost->IsSubscribed(nChannel))
564 CRITICAL_BLOCK(cs_vNodes)
565 BOOST_FOREACH(CNode* pnode, vNodes)
566 if (pnode->IsSubscribed(nChannel))
571 bool CNode::IsSubscribed(unsigned int nChannel)
573 if (nChannel >= vfSubscribe.size())
575 return vfSubscribe[nChannel];
578 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
580 if (nChannel >= vfSubscribe.size())
583 if (!AnySubscribed(nChannel))
586 CRITICAL_BLOCK(cs_vNodes)
587 BOOST_FOREACH(CNode* pnode, vNodes)
589 pnode->PushMessage("subscribe", nChannel, nHops);
592 vfSubscribe[nChannel] = true;
595 void CNode::CancelSubscribe(unsigned int nChannel)
597 if (nChannel >= vfSubscribe.size())
600 // Prevent from relaying cancel if wasn't subscribed
601 if (!vfSubscribe[nChannel])
603 vfSubscribe[nChannel] = false;
605 if (!AnySubscribed(nChannel))
607 // Relay subscription cancel
608 CRITICAL_BLOCK(cs_vNodes)
609 BOOST_FOREACH(CNode* pnode, vNodes)
611 pnode->PushMessage("sub-cancel", nChannel);
623 CNode* FindNode(unsigned int ip)
625 CRITICAL_BLOCK(cs_vNodes)
627 BOOST_FOREACH(CNode* pnode, vNodes)
628 if (pnode->addr.ip == ip)
634 CNode* FindNode(CAddress addr)
636 CRITICAL_BLOCK(cs_vNodes)
638 BOOST_FOREACH(CNode* pnode, vNodes)
639 if (pnode->addr == addr)
645 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
647 if (addrConnect.ip == addrLocalHost.ip)
650 // Look for an existing connection
651 CNode* pnode = FindNode(addrConnect.ip);
655 pnode->AddRef(nTimeout);
662 printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
663 addrConnect.ToString().c_str(),
664 (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
665 (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
667 CRITICAL_BLOCK(cs_mapAddresses)
668 mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
672 if (ConnectSocket(addrConnect, hSocket))
675 printf("connected %s\n", addrConnect.ToString().c_str());
677 // Set to nonblocking
680 if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
681 printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
683 if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
684 printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
688 CNode* pnode = new CNode(hSocket, addrConnect, false);
690 pnode->AddRef(nTimeout);
693 CRITICAL_BLOCK(cs_vNodes)
694 vNodes.push_back(pnode);
696 pnode->nTimeConnected = GetTime();
705 void CNode::CloseSocketDisconnect()
708 if (hSocket != INVALID_SOCKET)
711 printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
712 printf("disconnecting node %s\n", addr.ToString().c_str());
713 closesocket(hSocket);
714 hSocket = INVALID_SOCKET;
718 void CNode::Cleanup()
720 // All of a nodes broadcasts and subscriptions are automatically torn down
721 // when it goes down, so a node has to stay up to keep its broadcast going.
723 // Cancel subscriptions
724 for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
725 if (vfSubscribe[nChannel])
726 CancelSubscribe(nChannel);
730 std::map<unsigned int, int64> CNode::setBanned;
731 CCriticalSection CNode::cs_setBanned;
733 void CNode::ClearBanned()
738 bool CNode::IsBanned(unsigned int ip)
740 bool fResult = false;
741 CRITICAL_BLOCK(cs_setBanned)
743 std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
744 if (i != setBanned.end())
746 int64 t = (*i).second;
754 bool CNode::Misbehaving(int howmuch)
758 printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
762 nMisbehavior += howmuch;
763 if (nMisbehavior >= GetArg("-banscore", 100))
765 int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
766 CRITICAL_BLOCK(cs_setBanned)
767 if (setBanned[addr.ip] < banTime)
768 setBanned[addr.ip] = banTime;
769 CloseSocketDisconnect();
770 printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
787 void ThreadSocketHandler(void* parg)
789 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
792 vnThreadsRunning[0]++;
793 ThreadSocketHandler2(parg);
794 vnThreadsRunning[0]--;
796 catch (std::exception& e) {
797 vnThreadsRunning[0]--;
798 PrintException(&e, "ThreadSocketHandler()");
800 vnThreadsRunning[0]--;
801 throw; // support pthread_cancel()
803 printf("ThreadSocketHandler exiting\n");
806 void ThreadSocketHandler2(void* parg)
808 printf("ThreadSocketHandler started\n");
809 list<CNode*> vNodesDisconnected;
810 int nPrevNodeCount = 0;
817 CRITICAL_BLOCK(cs_vNodes)
819 // Disconnect unused nodes
820 vector<CNode*> vNodesCopy = vNodes;
821 BOOST_FOREACH(CNode* pnode, vNodesCopy)
823 if (pnode->fDisconnect ||
824 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
826 // remove from vNodes
827 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
829 // close socket and cleanup
830 pnode->CloseSocketDisconnect();
833 // hold in disconnected pool until all refs are released
834 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
835 if (pnode->fNetworkNode || pnode->fInbound)
837 vNodesDisconnected.push_back(pnode);
841 // Delete disconnected nodes
842 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
843 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
845 // wait until threads are done using it
846 if (pnode->GetRefCount() <= 0)
848 bool fDelete = false;
849 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
850 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
851 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
852 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
856 vNodesDisconnected.remove(pnode);
862 if (vNodes.size() != nPrevNodeCount)
864 nPrevNodeCount = vNodes.size();
870 // Find which sockets have data to receive
872 struct timeval timeout;
874 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
881 FD_ZERO(&fdsetError);
882 SOCKET hSocketMax = 0;
884 if(hListenSocket != INVALID_SOCKET)
885 FD_SET(hListenSocket, &fdsetRecv);
886 hSocketMax = max(hSocketMax, hListenSocket);
887 CRITICAL_BLOCK(cs_vNodes)
889 BOOST_FOREACH(CNode* pnode, vNodes)
891 if (pnode->hSocket == INVALID_SOCKET)
893 FD_SET(pnode->hSocket, &fdsetRecv);
894 FD_SET(pnode->hSocket, &fdsetError);
895 hSocketMax = max(hSocketMax, pnode->hSocket);
896 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
897 if (!pnode->vSend.empty())
898 FD_SET(pnode->hSocket, &fdsetSend);
902 vnThreadsRunning[0]--;
903 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
904 vnThreadsRunning[0]++;
907 if (nSelect == SOCKET_ERROR)
909 int nErr = WSAGetLastError();
912 printf("socket select error %d\n", nErr);
913 for (int i = 0; i <= hSocketMax; i++)
914 FD_SET(i, &fdsetRecv);
917 FD_ZERO(&fdsetError);
918 Sleep(timeout.tv_usec/1000);
923 // Accept new connections
925 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
927 struct sockaddr_in sockaddr;
928 socklen_t len = sizeof(sockaddr);
929 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
930 CAddress addr(sockaddr);
933 CRITICAL_BLOCK(cs_vNodes)
934 BOOST_FOREACH(CNode* pnode, vNodes)
937 if (hSocket == INVALID_SOCKET)
939 if (WSAGetLastError() != WSAEWOULDBLOCK)
940 printf("socket error accept failed: %d\n", WSAGetLastError());
942 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
944 closesocket(hSocket);
946 else if (CNode::IsBanned(addr.ip))
948 printf("connetion from %s dropped (banned)\n", addr.ToString().c_str());
949 closesocket(hSocket);
953 printf("accepted connection %s\n", addr.ToString().c_str());
954 CNode* pnode = new CNode(hSocket, addr, true);
956 CRITICAL_BLOCK(cs_vNodes)
957 vNodes.push_back(pnode);
963 // Service each socket
965 vector<CNode*> vNodesCopy;
966 CRITICAL_BLOCK(cs_vNodes)
969 BOOST_FOREACH(CNode* pnode, vNodesCopy)
972 BOOST_FOREACH(CNode* pnode, vNodesCopy)
980 if (pnode->hSocket == INVALID_SOCKET)
982 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
984 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
986 CDataStream& vRecv = pnode->vRecv;
987 unsigned int nPos = vRecv.size();
989 if (nPos > ReceiveBufferSize()) {
990 if (!pnode->fDisconnect)
991 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
992 pnode->CloseSocketDisconnect();
995 // typical socket buffer is 8K-64K
996 char pchBuf[0x10000];
997 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1000 vRecv.resize(nPos + nBytes);
1001 memcpy(&vRecv[nPos], pchBuf, nBytes);
1002 pnode->nLastRecv = GetTime();
1004 else if (nBytes == 0)
1006 // socket closed gracefully
1007 if (!pnode->fDisconnect)
1008 printf("socket closed\n");
1009 pnode->CloseSocketDisconnect();
1011 else if (nBytes < 0)
1014 int nErr = WSAGetLastError();
1015 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1017 if (!pnode->fDisconnect)
1018 printf("socket recv error %d\n", nErr);
1019 pnode->CloseSocketDisconnect();
1029 if (pnode->hSocket == INVALID_SOCKET)
1031 if (FD_ISSET(pnode->hSocket, &fdsetSend))
1033 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1035 CDataStream& vSend = pnode->vSend;
1038 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
1041 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1042 pnode->nLastSend = GetTime();
1044 else if (nBytes < 0)
1047 int nErr = WSAGetLastError();
1048 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1050 printf("socket send error %d\n", nErr);
1051 pnode->CloseSocketDisconnect();
1054 if (vSend.size() > SendBufferSize()) {
1055 if (!pnode->fDisconnect)
1056 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1057 pnode->CloseSocketDisconnect();
1064 // Inactivity checking
1066 if (pnode->vSend.empty())
1067 pnode->nLastSendEmpty = GetTime();
1068 if (GetTime() - pnode->nTimeConnected > 60)
1070 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1072 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1073 pnode->fDisconnect = true;
1075 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1077 printf("socket not sending\n");
1078 pnode->fDisconnect = true;
1080 else if (GetTime() - pnode->nLastRecv > 90*60)
1082 printf("socket inactivity timeout\n");
1083 pnode->fDisconnect = true;
1087 CRITICAL_BLOCK(cs_vNodes)
1089 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1106 void ThreadMapPort(void* parg)
1108 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1111 vnThreadsRunning[5]++;
1112 ThreadMapPort2(parg);
1113 vnThreadsRunning[5]--;
1115 catch (std::exception& e) {
1116 vnThreadsRunning[5]--;
1117 PrintException(&e, "ThreadMapPort()");
1119 vnThreadsRunning[5]--;
1120 PrintException(NULL, "ThreadMapPort()");
1122 printf("ThreadMapPort exiting\n");
1125 void ThreadMapPort2(void* parg)
1127 printf("ThreadMapPort started\n");
1130 sprintf(port, "%d", GetListenPort());
1132 const char * rootdescurl = 0;
1133 const char * multicastif = 0;
1134 const char * minissdpdpath = 0;
1135 struct UPNPDev * devlist = 0;
1138 #ifndef UPNPDISCOVER_SUCCESS
1140 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1144 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1147 struct UPNPUrls urls;
1148 struct IGDdatas data;
1151 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1156 string strDesc = "Bitcoin " + FormatFullVersion();
1157 #ifndef UPNPDISCOVER_SUCCESS
1159 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1160 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1163 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1164 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1167 if(r!=UPNPCOMMAND_SUCCESS)
1168 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1169 port, port, lanaddr, r, strupnperror(r));
1171 printf("UPnP Port Mapping successful.\n");
1173 if (fShutdown || !fUseUPnP)
1175 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1176 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1177 freeUPNPDevlist(devlist); devlist = 0;
1178 FreeUPNPUrls(&urls);
1184 printf("No valid UPnP IGDs found\n");
1185 freeUPNPDevlist(devlist); devlist = 0;
1187 FreeUPNPUrls(&urls);
1189 if (fShutdown || !fUseUPnP)
1196 void MapPort(bool fMapPort)
1198 if (fUseUPnP != fMapPort)
1200 fUseUPnP = fMapPort;
1201 WriteSetting("fUseUPnP", fUseUPnP);
1203 if (fUseUPnP && vnThreadsRunning[5] < 1)
1205 if (!CreateThread(ThreadMapPort, NULL))
1206 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1210 void MapPort(bool /* unused fMapPort */)
1212 // Intentionally left blank.
1225 static const char *strDNSSeed[] = {
1227 "dnsseed.bluematt.me",
1228 "seed.bitcoin.sipa.be",
1229 "dnsseed.bitcoin.dashjr.org",
1232 void ThreadDNSAddressSeed(void* parg)
1234 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1237 vnThreadsRunning[6]++;
1238 ThreadDNSAddressSeed2(parg);
1239 vnThreadsRunning[6]--;
1241 catch (std::exception& e) {
1242 vnThreadsRunning[6]--;
1243 PrintException(&e, "ThreadDNSAddressSeed()");
1245 vnThreadsRunning[6]--;
1246 throw; // support pthread_cancel()
1248 printf("ThreadDNSAddressSeed exiting\n");
1251 void ThreadDNSAddressSeed2(void* parg)
1253 printf("ThreadDNSAddressSeed started\n");
1258 printf("Loading addresses from DNS seeds (could take a while)\n");
1262 for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1263 vector<CAddress> vaddr;
1264 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1266 BOOST_FOREACH (CAddress& addr, vaddr)
1268 if (addr.GetByte(3) != 127)
1271 AddAddress(addr, 0, &addrDB);
1278 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1281 printf("%d addresses found from DNS seeds\n", found);
1295 unsigned int pnSeed[] =
1297 0x6884ac63, 0x3ffecead, 0x2919b953, 0x0942fe50, 0x7a1d922e, 0xcdd6734a, 0x953a5bb6, 0x2c46922e,
1298 0xe2a5f143, 0xaa39103a, 0xa06afa5c, 0x135ffd59, 0xe8e82863, 0xf61ef029, 0xf75f042e, 0x2b363532,
1299 0x29b2df42, 0x16b1f64e, 0xd46e281b, 0x5280bf58, 0x60372229, 0x1be58e4f, 0xa8496f45, 0x1fb1a057,
1300 0x756b3844, 0x3bb79445, 0x0b375518, 0xcccb0102, 0xb682bf2e, 0x46431c02, 0x3a81073a, 0xa3771f1f,
1301 0x213a121f, 0x85dc2c1b, 0x56b4323b, 0xb34e8945, 0x3c40b33d, 0xfa276418, 0x1f818d29, 0xebe1e344,
1302 0xf6160a18, 0xf4fa384a, 0x34b09558, 0xb882b543, 0xe3ce2253, 0x6abf56d8, 0xe91b1155, 0x688ee6ad,
1303 0x2efc6058, 0x4792cd47, 0x0c32f757, 0x4c813a46, 0x8c93644a, 0x37507444, 0x813ad218, 0xdac06d4a,
1304 0xe4c63e4b, 0x21a1ea3c, 0x8d88556f, 0x30e9173a, 0x041f681b, 0xdc77ba50, 0xc0072753, 0xceddd44f,
1305 0x052d1743, 0xe3c77a4a, 0x13981c3a, 0x5685d918, 0x3c0e4e70, 0x3e56fb54, 0xb676ae0c, 0xac93c859,
1306 0x22279f43, 0x975a4542, 0xe527f071, 0xea162f2e, 0x3c65a32e, 0x5be5713b, 0x961ec418, 0xb202922e,
1307 0x5ef7be50, 0xce49f53e, 0x05803b47, 0x8463b055, 0x78576153, 0x3ec2ae3a, 0x4bbd7118, 0xafcee043,
1308 0x56a3e8ba, 0x6174de4d, 0x8d01ba4b, 0xc9af564e, 0xdbc9c547, 0xa627474d, 0xdada9244, 0xd3b3083a,
1309 0x523e071f, 0xd6b96f18, 0xbd527c46, 0xdf2bbb4d, 0xd37b4a4b, 0x3a6a2158, 0xc064b055, 0x18a8e055,
1310 0xec4dae3b, 0x0540416c, 0x475b4fbe, 0x064803b2, 0x48e9f062, 0x2898524b, 0xd315ff43, 0xf786d247,
1311 0xc7ea2f3e, 0xc087f043, 0xc163354b, 0x8250284d, 0xed300029, 0xbf36e05c, 0x8eb3ae4c, 0xe7aa623e,
1312 0x7ced0274, 0xdd362c1b, 0x362b995a, 0xca26b629, 0x3fc41618, 0xb97b364e, 0xa05b8729, 0x0f5e3c43,
1313 0xdf942618, 0x6aeb9b5b, 0xbf04762e, 0xfaaeb118, 0x87579958, 0x76520044, 0xc2660c5b, 0x628b201b,
1314 0xf193932e, 0x1c0ad045, 0xff908346, 0x8da9d4da, 0xed201c1f, 0xa47a2b1b, 0x330007d4, 0x8ba1ed47,
1315 0xb2f02d44, 0x7db62c1b, 0x781c454b, 0xc0300029, 0xb7062a45, 0x88b52e3a, 0x78dd6b63, 0x1cb9b718,
1316 0x5d358e47, 0x59912c3b, 0x79607544, 0x5197f759, 0xc023be48, 0xd1013743, 0x0f354057, 0x8e3aac3b,
1317 0x4114693e, 0x22316318, 0xe27dda50, 0x878eac3b, 0x4948a21f, 0x5db7f24c, 0x8ccb6157, 0x26a5de18,
1318 0x0a11bd43, 0x27bb1e41, 0x60a7a951, 0x3e16b35e, 0x07888b53, 0x5648a853, 0x0149fe50, 0xd070a34f,
1319 0x6454c96d, 0xd6e54758, 0xa96dc152, 0x65447861, 0xf6bdf95e, 0x10400202, 0x2c29d483, 0x18174732,
1320 0x1d840618, 0x12e61818, 0x089d3f3c, 0x917e931f, 0xd1b0c90e, 0x25bd3c42, 0xeb05775b, 0x7d550c59,
1321 0x6cfacb01, 0xe4224444, 0xa41dd943, 0x0f5aa643, 0x5e33731b, 0x81036d50, 0x6f46a0d1, 0x7731be43,
1322 0x14840e18, 0xf1e8d059, 0x661d2b1f, 0x40a3201b, 0x9407b843, 0xedf0254d, 0x7bd1a5bc, 0x073dbe51,
1323 0xe864a97b, 0x2efd947b, 0xb9ca0e45, 0x4e2113ad, 0xcc305731, 0xd39ca63c, 0x733df918, 0xda172b1f,
1324 0xaa03b34d, 0x7230fd4d, 0xf1ce6e3a, 0x2e9fab43, 0xa4010750, 0xa928bd18, 0x6809be42, 0xb19de348,
1325 0xff956270, 0x0d795f51, 0xd2dec247, 0x6df5774b, 0xbac11f79, 0xdfb05c75, 0x887683d8, 0xa1e83632,
1326 0x2c0f7671, 0x28bcb65d, 0xac2a7545, 0x3eebfc60, 0x304ad7c4, 0xa215a462, 0xc86f0f58, 0xcfb92ebe,
1327 0x5e23ed82, 0xf506184b, 0xec0f19b7, 0x060c59ad, 0x86ee3174, 0x85380774, 0xa199a562, 0x02b507ae,
1328 0x33eb2163, 0xf2112b1f, 0xb702ba50, 0x131b9618, 0x90ccd04a, 0x08f3273b, 0xecb61718, 0x64b8b44d,
1329 0x182bf4dc, 0xc7b68286, 0x6e318d5f, 0xfdb03654, 0xb3272e54, 0xe014ad4b, 0x274e4a31, 0x7806375c,
1330 0xbc34a748, 0x1b5ad94a, 0x6b54d10e, 0x73e2ae6e, 0x5529d483, 0x8455a76d, 0x99c13f47, 0x1d811741,
1331 0xa9782a78, 0x0b00464d, 0x7266ea50, 0x532dab46, 0x33e1413e, 0x780d0c18, 0x0fb0854e, 0x03370155,
1332 0x2693042e, 0xfa3d824a, 0x2bb1681b, 0x37ea2a18, 0x7fb8414b, 0x32e0713b, 0xacf38d3f, 0xa282716f,
1333 0xb1a09d7b, 0xa04b764b, 0x83c94d18, 0x05ee4c6d, 0x0e795f51, 0x46984352, 0xf80fc247, 0x3fccb946,
1334 0xd7ae244b, 0x0a8e0a4c, 0x57b141bc, 0x3647bed1, 0x1431b052, 0x803a8bbb, 0xfc69056b, 0xf5991862,
1335 0x14963b2e, 0xd35d5dda, 0xc6c73574, 0xc8f1405b, 0x0ca4224d, 0xecd36071, 0xa9461754, 0xe7a0ed72,
1336 0x559e8346, 0x1c9beec1, 0xc786ea4a, 0x9561b44d, 0x9788074d, 0x1a69934f, 0x23c5614c, 0x07c79d4b,
1337 0xc7ee52db, 0xc72df351, 0xcb135e44, 0xa0988346, 0xc211fc4c, 0x87dec34b, 0x1381074d, 0x04a65cb7,
1338 0x4409083a, 0x4a407a4c, 0x92b8d37d, 0xacf50b4d, 0xa58aa5bc, 0x448f801f, 0x9c83762e, 0x6fd5734a,
1339 0xfe2d454b, 0x84144c55, 0x05190e4c, 0xb2151448, 0x63867a3e, 0x16099018, 0x9c010d3c, 0x962d8f3d,
1340 0xd51ee453, 0x9d86801f, 0x68e87b47, 0x6bf7bb73, 0x5fc7910e, 0x10d90118, 0x3db04442, 0x729d3e4b,
1341 0xc397d842, 0x57bb15ad, 0x72f31f4e, 0xc9380043, 0x2bb24e18, 0xd9b8ab50, 0xb786801f, 0xf4dc4847,
1342 0x85f4bb51, 0x4435995b, 0x5ba07e40, 0x2c57392e, 0x3628124b, 0x9839b64b, 0x6fe8b24d, 0xaddce847,
1343 0x75260e45, 0x0c572a43, 0xfea21902, 0xb9f9742e, 0x5a70d443, 0x8fc5910e, 0x868d4744, 0x56245e02,
1344 0xd7eb5f02, 0x35c12c1b, 0x4373034b, 0x8786554c, 0xa6facf18, 0x4b11a31f, 0x3570664e, 0x5a64bc42,
1345 0x0b03983f, 0x8f457e4c, 0x0fd874c3, 0xb6cf31b2, 0x2bbc2d4e, 0x146ca5b2, 0x9d00b150, 0x048a4153,
1346 0xca4dcd43, 0xc1607cca, 0x8234cf57, 0x9c7daead, 0x3dc07658, 0xea5c6e4c, 0xf1a0084e, 0x16d2ee53,
1347 0x1b849418, 0xfe913a47, 0x1e988f62, 0x208b644c, 0xc55ee980, 0xbdbce747, 0xf59a384e, 0x0f56091b,
1348 0x7417b745, 0x0c37344e, 0x2c62ab47, 0xf8533a4d, 0x8030084d, 0x76b93c4b, 0xda6ea0ad, 0x3c54f618,
1349 0x63b0de1f, 0x7370d858, 0x1a70bb4c, 0xdda63b2e, 0x60b2ba50, 0x1ba7d048, 0xbe1b2c1b, 0xabea5747,
1350 0x29ad2e4d, 0xe8cd7642, 0x66c80e18, 0x138bf34a, 0xc6145e44, 0x2586794c, 0x07bc5478, 0x0da0b14d,
1351 0x8f95354e, 0x9eb11c62, 0xa1545e46, 0x2e7a2602, 0x408c9c3d, 0x59065d55, 0xf51d1a4c, 0x3bbc6a4e,
1352 0xc71b2a2e, 0xcdaaa545, 0x17d659d0, 0x5202e7ad, 0xf1b68445, 0x93375961, 0xbd88a043, 0x066ad655,
1353 0x890f6318, 0x7b7dca47, 0x99bdd662, 0x3bb4fc53, 0x1231efdc, 0xc0a99444, 0x96bbea47, 0x61ed8748,
1354 0x27dfa73b, 0x8d4d1754, 0x3460042e, 0x551f0c4c, 0x8d0e0718, 0x162ddc53, 0x53231718, 0x1ecd65d0,
1355 0x944d28bc, 0x3b79d058, 0xaff97fbc, 0x4860006c, 0xc101c90e, 0xace41743, 0xa5975d4c, 0x5cc2703e,
1356 0xb55a4450, 0x02d18840, 0xee2765ae, 0xd6012fd5, 0x24c94d7d, 0x8c6eec47, 0x7520ba5d, 0x9e15e460,
1357 0x8510b04c, 0x75ec3847, 0x1dfa6661, 0xe172b3ad, 0x5744c90e, 0x52a0a152, 0x8d6fad18, 0x67b74b6d,
1358 0x93a089b2, 0x0f3ac5d5, 0xe5de1855, 0x43d25747, 0x4bad804a, 0x55b408d8, 0x60a36441, 0xf553e860,
1359 0xdb2fa2c8, 0x03152b32, 0xdd27a7d5, 0x3116a8b8, 0x0a1d708c, 0xeee2f13c, 0x6acf436f, 0xce6eb4ca,
1360 0x101cd3d9, 0x1c48a6b8, 0xe57d6f44, 0x93dcf562,
1365 void ThreadOpenConnections(void* parg)
1367 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1370 vnThreadsRunning[1]++;
1371 ThreadOpenConnections2(parg);
1372 vnThreadsRunning[1]--;
1374 catch (std::exception& e) {
1375 vnThreadsRunning[1]--;
1376 PrintException(&e, "ThreadOpenConnections()");
1378 vnThreadsRunning[1]--;
1379 PrintException(NULL, "ThreadOpenConnections()");
1381 printf("ThreadOpenConnections exiting\n");
1384 void ThreadOpenConnections2(void* parg)
1386 printf("ThreadOpenConnections started\n");
1388 // Connect to specific addresses
1389 if (mapArgs.count("-connect"))
1391 for (int64 nLoop = 0;; nLoop++)
1393 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1395 CAddress addr(strAddr, fAllowDNS);
1397 OpenNetworkConnection(addr);
1398 for (int i = 0; i < 10 && i < nLoop; i++)
1408 // Connect to manually added nodes first
1409 if (mapArgs.count("-addnode"))
1411 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1413 CAddress addr(strAddr, fAllowDNS);
1416 OpenNetworkConnection(addr);
1424 // Initiate network connections
1425 int64 nStart = GetTime();
1428 // Limit outbound connections
1429 vnThreadsRunning[1]--;
1434 CRITICAL_BLOCK(cs_vNodes)
1435 BOOST_FOREACH(CNode* pnode, vNodes)
1436 if (!pnode->fInbound)
1438 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1439 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1440 if (nOutbound < nMaxOutboundConnections)
1446 vnThreadsRunning[1]++;
1450 CRITICAL_BLOCK(cs_mapAddresses)
1452 // Add seed nodes if IRC isn't working
1453 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1454 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fTOR) && !fTestNet)
1456 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1458 // It'll only connect to one or two seed nodes because once it connects,
1459 // it'll get a pile of addresses with newer timestamps.
1460 // Seed nodes are given a random 'last seen time' of between one and two
1462 const int64 nOneWeek = 7*24*60*60;
1464 addr.ip = pnSeed[i];
1465 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1473 // Choose an address to connect to based on most recently seen
1475 CAddress addrConnect;
1476 int64 nBest = INT64_MIN;
1478 // Only connect to one address per a.b.?.? range.
1479 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1480 set<unsigned int> setConnected;
1481 CRITICAL_BLOCK(cs_vNodes)
1482 BOOST_FOREACH(CNode* pnode, vNodes)
1483 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1485 int64 nANow = GetAdjustedTime();
1487 CRITICAL_BLOCK(cs_mapAddresses)
1489 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1491 const CAddress& addr = item.second;
1492 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1494 int64 nSinceLastSeen = nANow - addr.nTime;
1495 int64 nSinceLastTry = nANow - addr.nLastTry;
1497 // Randomize the order in a deterministic way, putting the standard port first
1498 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1499 if (addr.port != htons(GetDefaultPort()))
1500 nRandomizer += 2 * 60 * 60;
1502 // Last seen Base retry frequency
1511 // 365 days 93 hours
1512 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1514 // Fast reconnect for one hour after last seen
1515 if (nSinceLastSeen < 60 * 60)
1518 // Limit retry frequency
1519 if (nSinceLastTry < nDelay)
1522 // If we have IRC, we'll be notified when they first come online,
1523 // and again every 24 hours by the refresh broadcast.
1524 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1527 // Only try the old stuff if we don't have enough connections
1528 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1531 // If multiple addresses are ready, prioritize by time since
1532 // last seen and time since last tried.
1533 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1542 if (addrConnect.IsValid())
1543 OpenNetworkConnection(addrConnect);
1547 bool OpenNetworkConnection(const CAddress& addrConnect)
1550 // Initiate outbound network connection
1554 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
1555 FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
1558 vnThreadsRunning[1]--;
1559 CNode* pnode = ConnectNode(addrConnect);
1560 vnThreadsRunning[1]++;
1565 pnode->fNetworkNode = true;
1577 void ThreadMessageHandler(void* parg)
1579 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1582 vnThreadsRunning[2]++;
1583 ThreadMessageHandler2(parg);
1584 vnThreadsRunning[2]--;
1586 catch (std::exception& e) {
1587 vnThreadsRunning[2]--;
1588 PrintException(&e, "ThreadMessageHandler()");
1590 vnThreadsRunning[2]--;
1591 PrintException(NULL, "ThreadMessageHandler()");
1593 printf("ThreadMessageHandler exiting\n");
1596 void ThreadMessageHandler2(void* parg)
1598 printf("ThreadMessageHandler started\n");
1599 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1602 vector<CNode*> vNodesCopy;
1603 CRITICAL_BLOCK(cs_vNodes)
1605 vNodesCopy = vNodes;
1606 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1610 // Poll the connected nodes for messages
1611 CNode* pnodeTrickle = NULL;
1612 if (!vNodesCopy.empty())
1613 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1614 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1617 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1618 ProcessMessages(pnode);
1623 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1624 SendMessages(pnode, pnode == pnodeTrickle);
1629 CRITICAL_BLOCK(cs_vNodes)
1631 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1635 // Wait and allow messages to bunch up.
1636 // Reduce vnThreadsRunning so StopNode has permission to exit while
1637 // we're sleeping, but we must always check fShutdown after doing this.
1638 vnThreadsRunning[2]--;
1640 if (fRequestShutdown)
1642 vnThreadsRunning[2]++;
1653 bool BindListenPort(string& strError)
1657 addrLocalHost.port = htons(GetListenPort());
1660 // Initialize Windows Sockets
1662 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1663 if (ret != NO_ERROR)
1665 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1666 printf("%s\n", strError.c_str());
1671 // Create socket for listening for incoming connections
1672 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1673 if (hListenSocket == INVALID_SOCKET)
1675 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1676 printf("%s\n", strError.c_str());
1681 // Different way of disabling SIGPIPE on BSD
1682 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1686 // Allow binding if the port is still in TIME_WAIT state after
1687 // the program was closed and restarted. Not an issue on windows.
1688 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1692 // Set to nonblocking, incoming connections will also inherit this
1693 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1695 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1698 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1699 printf("%s\n", strError.c_str());
1703 // The sockaddr_in structure specifies the address family,
1704 // IP address, and port for the socket that is being bound
1705 struct sockaddr_in sockaddr;
1706 memset(&sockaddr, 0, sizeof(sockaddr));
1707 sockaddr.sin_family = AF_INET;
1708 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1709 sockaddr.sin_port = htons(GetListenPort());
1710 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1712 int nErr = WSAGetLastError();
1713 if (nErr == WSAEADDRINUSE)
1714 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1716 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1717 printf("%s\n", strError.c_str());
1720 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1722 // Listen for incoming connections
1723 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1725 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1726 printf("%s\n", strError.c_str());
1733 void StartNode(void* parg)
1735 if (pnodeLocalHost == NULL)
1736 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1739 // Get local host ip
1740 char pszHostName[1000] = "";
1741 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1743 vector<CAddress> vaddr;
1744 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1745 BOOST_FOREACH (const CAddress &addr, vaddr)
1746 if (addr.GetByte(3) != 127)
1748 addrLocalHost = addr;
1753 // Get local host ip
1754 struct ifaddrs* myaddrs;
1755 if (getifaddrs(&myaddrs) == 0)
1757 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1759 if (ifa->ifa_addr == NULL) continue;
1760 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1761 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1762 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1764 if (ifa->ifa_addr->sa_family == AF_INET)
1766 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1767 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1768 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1770 // Take the first IP that isn't loopback 127.x.x.x
1771 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1772 if (addr.IsValid() && addr.GetByte(3) != 127)
1774 addrLocalHost = addr;
1778 else if (ifa->ifa_addr->sa_family == AF_INET6)
1780 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1781 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1782 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1785 freeifaddrs(myaddrs);
1788 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1790 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1792 // Proxies can't take incoming connections
1793 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1794 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1798 CreateThread(ThreadGetMyExternalIP, NULL);
1805 if (GetBoolArg("-nodnsseed"))
1806 printf("DNS seeding disabled\n");
1808 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1809 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1811 // Map ports with UPnP
1815 // Get addresses from IRC and advertise ours
1816 if (!CreateThread(ThreadIRCSeed, NULL))
1817 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1819 // Send and receive from sockets, accept connections
1820 if (!CreateThread(ThreadSocketHandler, NULL))
1821 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1823 // Initiate outbound connections
1824 if (!CreateThread(ThreadOpenConnections, NULL))
1825 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1828 if (!CreateThread(ThreadMessageHandler, NULL))
1829 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1831 // Generate coins in the background
1832 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1837 printf("StopNode()\n");
1839 nTransactionsUpdated++;
1840 int64 nStart = GetTime();
1841 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1843 || vnThreadsRunning[5] > 0
1847 if (GetTime() - nStart > 20)
1851 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1852 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1853 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1854 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1855 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1856 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1857 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1858 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1874 BOOST_FOREACH(CNode* pnode, vNodes)
1875 if (pnode->hSocket != INVALID_SOCKET)
1876 closesocket(pnode->hSocket);
1877 if (hListenSocket != INVALID_SOCKET)
1878 if (closesocket(hListenSocket) == SOCKET_ERROR)
1879 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1882 // Shutdown Windows Sockets
1887 instance_of_cnetcleanup;