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 void CNode::PushVersion()
732 /// when NTP implemented, change to just nTime = GetAdjustedTime()
733 int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
734 CAddress addrYou = (fUseProxy ? CAddress("0.0.0.0") : addr);
735 CAddress addrMe = (fUseProxy ? CAddress("0.0.0.0") : addrLocalHost);
736 RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
737 PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
738 nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight);
745 std::map<unsigned int, int64> CNode::setBanned;
746 CCriticalSection CNode::cs_setBanned;
748 void CNode::ClearBanned()
753 bool CNode::IsBanned(unsigned int ip)
755 bool fResult = false;
756 CRITICAL_BLOCK(cs_setBanned)
758 std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
759 if (i != setBanned.end())
761 int64 t = (*i).second;
769 bool CNode::Misbehaving(int howmuch)
773 printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
777 nMisbehavior += howmuch;
778 if (nMisbehavior >= GetArg("-banscore", 100))
780 int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
781 CRITICAL_BLOCK(cs_setBanned)
782 if (setBanned[addr.ip] < banTime)
783 setBanned[addr.ip] = banTime;
784 CloseSocketDisconnect();
785 printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
802 void ThreadSocketHandler(void* parg)
804 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
807 vnThreadsRunning[0]++;
808 ThreadSocketHandler2(parg);
809 vnThreadsRunning[0]--;
811 catch (std::exception& e) {
812 vnThreadsRunning[0]--;
813 PrintException(&e, "ThreadSocketHandler()");
815 vnThreadsRunning[0]--;
816 throw; // support pthread_cancel()
818 printf("ThreadSocketHandler exiting\n");
821 void ThreadSocketHandler2(void* parg)
823 printf("ThreadSocketHandler started\n");
824 list<CNode*> vNodesDisconnected;
825 int nPrevNodeCount = 0;
832 CRITICAL_BLOCK(cs_vNodes)
834 // Disconnect unused nodes
835 vector<CNode*> vNodesCopy = vNodes;
836 BOOST_FOREACH(CNode* pnode, vNodesCopy)
838 if (pnode->fDisconnect ||
839 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
841 // remove from vNodes
842 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
844 // close socket and cleanup
845 pnode->CloseSocketDisconnect();
848 // hold in disconnected pool until all refs are released
849 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
850 if (pnode->fNetworkNode || pnode->fInbound)
852 vNodesDisconnected.push_back(pnode);
856 // Delete disconnected nodes
857 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
858 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
860 // wait until threads are done using it
861 if (pnode->GetRefCount() <= 0)
863 bool fDelete = false;
864 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
865 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
866 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
867 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
871 vNodesDisconnected.remove(pnode);
877 if (vNodes.size() != nPrevNodeCount)
879 nPrevNodeCount = vNodes.size();
885 // Find which sockets have data to receive
887 struct timeval timeout;
889 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
896 FD_ZERO(&fdsetError);
897 SOCKET hSocketMax = 0;
899 if(hListenSocket != INVALID_SOCKET)
900 FD_SET(hListenSocket, &fdsetRecv);
901 hSocketMax = max(hSocketMax, hListenSocket);
902 CRITICAL_BLOCK(cs_vNodes)
904 BOOST_FOREACH(CNode* pnode, vNodes)
906 if (pnode->hSocket == INVALID_SOCKET)
908 FD_SET(pnode->hSocket, &fdsetRecv);
909 FD_SET(pnode->hSocket, &fdsetError);
910 hSocketMax = max(hSocketMax, pnode->hSocket);
911 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
912 if (!pnode->vSend.empty())
913 FD_SET(pnode->hSocket, &fdsetSend);
917 vnThreadsRunning[0]--;
918 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
919 vnThreadsRunning[0]++;
922 if (nSelect == SOCKET_ERROR)
924 int nErr = WSAGetLastError();
927 printf("socket select error %d\n", nErr);
928 for (int i = 0; i <= hSocketMax; i++)
929 FD_SET(i, &fdsetRecv);
932 FD_ZERO(&fdsetError);
933 Sleep(timeout.tv_usec/1000);
938 // Accept new connections
940 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
942 struct sockaddr_in sockaddr;
943 socklen_t len = sizeof(sockaddr);
944 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
945 CAddress addr(sockaddr);
948 CRITICAL_BLOCK(cs_vNodes)
949 BOOST_FOREACH(CNode* pnode, vNodes)
952 if (hSocket == INVALID_SOCKET)
954 if (WSAGetLastError() != WSAEWOULDBLOCK)
955 printf("socket error accept failed: %d\n", WSAGetLastError());
957 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
959 closesocket(hSocket);
961 else if (CNode::IsBanned(addr.ip))
963 printf("connetion from %s dropped (banned)\n", addr.ToString().c_str());
964 closesocket(hSocket);
968 printf("accepted connection %s\n", addr.ToString().c_str());
969 CNode* pnode = new CNode(hSocket, addr, true);
971 CRITICAL_BLOCK(cs_vNodes)
972 vNodes.push_back(pnode);
978 // Service each socket
980 vector<CNode*> vNodesCopy;
981 CRITICAL_BLOCK(cs_vNodes)
984 BOOST_FOREACH(CNode* pnode, vNodesCopy)
987 BOOST_FOREACH(CNode* pnode, vNodesCopy)
995 if (pnode->hSocket == INVALID_SOCKET)
997 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
999 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1001 CDataStream& vRecv = pnode->vRecv;
1002 unsigned int nPos = vRecv.size();
1004 if (nPos > ReceiveBufferSize()) {
1005 if (!pnode->fDisconnect)
1006 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
1007 pnode->CloseSocketDisconnect();
1010 // typical socket buffer is 8K-64K
1011 char pchBuf[0x10000];
1012 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1015 vRecv.resize(nPos + nBytes);
1016 memcpy(&vRecv[nPos], pchBuf, nBytes);
1017 pnode->nLastRecv = GetTime();
1019 else if (nBytes == 0)
1021 // socket closed gracefully
1022 if (!pnode->fDisconnect)
1023 printf("socket closed\n");
1024 pnode->CloseSocketDisconnect();
1026 else if (nBytes < 0)
1029 int nErr = WSAGetLastError();
1030 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1032 if (!pnode->fDisconnect)
1033 printf("socket recv error %d\n", nErr);
1034 pnode->CloseSocketDisconnect();
1044 if (pnode->hSocket == INVALID_SOCKET)
1046 if (FD_ISSET(pnode->hSocket, &fdsetSend))
1048 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1050 CDataStream& vSend = pnode->vSend;
1053 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
1056 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1057 pnode->nLastSend = GetTime();
1059 else if (nBytes < 0)
1062 int nErr = WSAGetLastError();
1063 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1065 printf("socket send error %d\n", nErr);
1066 pnode->CloseSocketDisconnect();
1069 if (vSend.size() > SendBufferSize()) {
1070 if (!pnode->fDisconnect)
1071 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1072 pnode->CloseSocketDisconnect();
1079 // Inactivity checking
1081 if (pnode->vSend.empty())
1082 pnode->nLastSendEmpty = GetTime();
1083 if (GetTime() - pnode->nTimeConnected > 60)
1085 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1087 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1088 pnode->fDisconnect = true;
1090 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1092 printf("socket not sending\n");
1093 pnode->fDisconnect = true;
1095 else if (GetTime() - pnode->nLastRecv > 90*60)
1097 printf("socket inactivity timeout\n");
1098 pnode->fDisconnect = true;
1102 CRITICAL_BLOCK(cs_vNodes)
1104 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1121 void ThreadMapPort(void* parg)
1123 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1126 vnThreadsRunning[5]++;
1127 ThreadMapPort2(parg);
1128 vnThreadsRunning[5]--;
1130 catch (std::exception& e) {
1131 vnThreadsRunning[5]--;
1132 PrintException(&e, "ThreadMapPort()");
1134 vnThreadsRunning[5]--;
1135 PrintException(NULL, "ThreadMapPort()");
1137 printf("ThreadMapPort exiting\n");
1140 void ThreadMapPort2(void* parg)
1142 printf("ThreadMapPort started\n");
1145 sprintf(port, "%d", GetListenPort());
1147 const char * rootdescurl = 0;
1148 const char * multicastif = 0;
1149 const char * minissdpdpath = 0;
1150 struct UPNPDev * devlist = 0;
1153 #ifndef UPNPDISCOVER_SUCCESS
1155 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1159 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1162 struct UPNPUrls urls;
1163 struct IGDdatas data;
1166 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1171 string strDesc = "Bitcoin " + FormatFullVersion();
1172 #ifndef UPNPDISCOVER_SUCCESS
1174 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1175 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1178 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1179 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1182 if(r!=UPNPCOMMAND_SUCCESS)
1183 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1184 port, port, lanaddr, r, strupnperror(r));
1186 printf("UPnP Port Mapping successful.\n");
1188 if (fShutdown || !fUseUPnP)
1190 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1191 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1192 freeUPNPDevlist(devlist); devlist = 0;
1193 FreeUPNPUrls(&urls);
1199 printf("No valid UPnP IGDs found\n");
1200 freeUPNPDevlist(devlist); devlist = 0;
1202 FreeUPNPUrls(&urls);
1204 if (fShutdown || !fUseUPnP)
1211 void MapPort(bool fMapPort)
1213 if (fUseUPnP != fMapPort)
1215 fUseUPnP = fMapPort;
1216 WriteSetting("fUseUPnP", fUseUPnP);
1218 if (fUseUPnP && vnThreadsRunning[5] < 1)
1220 if (!CreateThread(ThreadMapPort, NULL))
1221 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1225 void MapPort(bool /* unused fMapPort */)
1227 // Intentionally left blank.
1240 static const char *strDNSSeed[] = {
1242 "dnsseed.bluematt.me",
1245 void ThreadDNSAddressSeed(void* parg)
1247 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1250 vnThreadsRunning[6]++;
1251 ThreadDNSAddressSeed2(parg);
1252 vnThreadsRunning[6]--;
1254 catch (std::exception& e) {
1255 vnThreadsRunning[6]--;
1256 PrintException(&e, "ThreadDNSAddressSeed()");
1258 vnThreadsRunning[6]--;
1259 throw; // support pthread_cancel()
1261 printf("ThreadDNSAddressSeed exiting\n");
1264 void ThreadDNSAddressSeed2(void* parg)
1266 printf("ThreadDNSAddressSeed started\n");
1271 printf("Loading addresses from DNS seeds (could take a while)\n");
1275 for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1276 vector<CAddress> vaddr;
1277 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1279 BOOST_FOREACH (CAddress& addr, vaddr)
1281 if (addr.GetByte(3) != 127)
1284 AddAddress(addr, 0, &addrDB);
1291 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1294 printf("%d addresses found from DNS seeds\n", found);
1308 unsigned int pnSeed[] =
1310 0x6884ac63, 0x3ffecead, 0x2919b953, 0x0942fe50, 0x7a1d922e, 0xcdd6734a, 0x953a5bb6, 0x2c46922e,
1311 0xe2a5f143, 0xaa39103a, 0xa06afa5c, 0x135ffd59, 0xe8e82863, 0xf61ef029, 0xf75f042e, 0x2b363532,
1312 0x29b2df42, 0x16b1f64e, 0xd46e281b, 0x5280bf58, 0x60372229, 0x1be58e4f, 0xa8496f45, 0x1fb1a057,
1313 0x756b3844, 0x3bb79445, 0x0b375518, 0xcccb0102, 0xb682bf2e, 0x46431c02, 0x3a81073a, 0xa3771f1f,
1314 0x213a121f, 0x85dc2c1b, 0x56b4323b, 0xb34e8945, 0x3c40b33d, 0xfa276418, 0x1f818d29, 0xebe1e344,
1315 0xf6160a18, 0xf4fa384a, 0x34b09558, 0xb882b543, 0xe3ce2253, 0x6abf56d8, 0xe91b1155, 0x688ee6ad,
1316 0x2efc6058, 0x4792cd47, 0x0c32f757, 0x4c813a46, 0x8c93644a, 0x37507444, 0x813ad218, 0xdac06d4a,
1317 0xe4c63e4b, 0x21a1ea3c, 0x8d88556f, 0x30e9173a, 0x041f681b, 0xdc77ba50, 0xc0072753, 0xceddd44f,
1318 0x052d1743, 0xe3c77a4a, 0x13981c3a, 0x5685d918, 0x3c0e4e70, 0x3e56fb54, 0xb676ae0c, 0xac93c859,
1319 0x22279f43, 0x975a4542, 0xe527f071, 0xea162f2e, 0x3c65a32e, 0x5be5713b, 0x961ec418, 0xb202922e,
1320 0x5ef7be50, 0xce49f53e, 0x05803b47, 0x8463b055, 0x78576153, 0x3ec2ae3a, 0x4bbd7118, 0xafcee043,
1321 0x56a3e8ba, 0x6174de4d, 0x8d01ba4b, 0xc9af564e, 0xdbc9c547, 0xa627474d, 0xdada9244, 0xd3b3083a,
1322 0x523e071f, 0xd6b96f18, 0xbd527c46, 0xdf2bbb4d, 0xd37b4a4b, 0x3a6a2158, 0xc064b055, 0x18a8e055,
1323 0xec4dae3b, 0x0540416c, 0x475b4fbe, 0x064803b2, 0x48e9f062, 0x2898524b, 0xd315ff43, 0xf786d247,
1324 0xc7ea2f3e, 0xc087f043, 0xc163354b, 0x8250284d, 0xed300029, 0xbf36e05c, 0x8eb3ae4c, 0xe7aa623e,
1325 0x7ced0274, 0xdd362c1b, 0x362b995a, 0xca26b629, 0x3fc41618, 0xb97b364e, 0xa05b8729, 0x0f5e3c43,
1326 0xdf942618, 0x6aeb9b5b, 0xbf04762e, 0xfaaeb118, 0x87579958, 0x76520044, 0xc2660c5b, 0x628b201b,
1327 0xf193932e, 0x1c0ad045, 0xff908346, 0x8da9d4da, 0xed201c1f, 0xa47a2b1b, 0x330007d4, 0x8ba1ed47,
1328 0xb2f02d44, 0x7db62c1b, 0x781c454b, 0xc0300029, 0xb7062a45, 0x88b52e3a, 0x78dd6b63, 0x1cb9b718,
1329 0x5d358e47, 0x59912c3b, 0x79607544, 0x5197f759, 0xc023be48, 0xd1013743, 0x0f354057, 0x8e3aac3b,
1330 0x4114693e, 0x22316318, 0xe27dda50, 0x878eac3b, 0x4948a21f, 0x5db7f24c, 0x8ccb6157, 0x26a5de18,
1331 0x0a11bd43, 0x27bb1e41, 0x60a7a951, 0x3e16b35e, 0x07888b53, 0x5648a853, 0x0149fe50, 0xd070a34f,
1332 0x6454c96d, 0xd6e54758, 0xa96dc152, 0x65447861, 0xf6bdf95e, 0x10400202, 0x2c29d483, 0x18174732,
1333 0x1d840618, 0x12e61818, 0x089d3f3c, 0x917e931f, 0xd1b0c90e, 0x25bd3c42, 0xeb05775b, 0x7d550c59,
1334 0x6cfacb01, 0xe4224444, 0xa41dd943, 0x0f5aa643, 0x5e33731b, 0x81036d50, 0x6f46a0d1, 0x7731be43,
1335 0x14840e18, 0xf1e8d059, 0x661d2b1f, 0x40a3201b, 0x9407b843, 0xedf0254d, 0x7bd1a5bc, 0x073dbe51,
1336 0xe864a97b, 0x2efd947b, 0xb9ca0e45, 0x4e2113ad, 0xcc305731, 0xd39ca63c, 0x733df918, 0xda172b1f,
1337 0xaa03b34d, 0x7230fd4d, 0xf1ce6e3a, 0x2e9fab43, 0xa4010750, 0xa928bd18, 0x6809be42, 0xb19de348,
1338 0xff956270, 0x0d795f51, 0xd2dec247, 0x6df5774b, 0xbac11f79, 0xdfb05c75, 0x887683d8, 0xa1e83632,
1339 0x2c0f7671, 0x28bcb65d, 0xac2a7545, 0x3eebfc60, 0x304ad7c4, 0xa215a462, 0xc86f0f58, 0xcfb92ebe,
1340 0x5e23ed82, 0xf506184b, 0xec0f19b7, 0x060c59ad, 0x86ee3174, 0x85380774, 0xa199a562, 0x02b507ae,
1341 0x33eb2163, 0xf2112b1f, 0xb702ba50, 0x131b9618, 0x90ccd04a, 0x08f3273b, 0xecb61718, 0x64b8b44d,
1342 0x182bf4dc, 0xc7b68286, 0x6e318d5f, 0xfdb03654, 0xb3272e54, 0xe014ad4b, 0x274e4a31, 0x7806375c,
1343 0xbc34a748, 0x1b5ad94a, 0x6b54d10e, 0x73e2ae6e, 0x5529d483, 0x8455a76d, 0x99c13f47, 0x1d811741,
1344 0xa9782a78, 0x0b00464d, 0x7266ea50, 0x532dab46, 0x33e1413e, 0x780d0c18, 0x0fb0854e, 0x03370155,
1345 0x2693042e, 0xfa3d824a, 0x2bb1681b, 0x37ea2a18, 0x7fb8414b, 0x32e0713b, 0xacf38d3f, 0xa282716f,
1346 0xb1a09d7b, 0xa04b764b, 0x83c94d18, 0x05ee4c6d, 0x0e795f51, 0x46984352, 0xf80fc247, 0x3fccb946,
1347 0xd7ae244b, 0x0a8e0a4c, 0x57b141bc, 0x3647bed1, 0x1431b052, 0x803a8bbb, 0xfc69056b, 0xf5991862,
1348 0x14963b2e, 0xd35d5dda, 0xc6c73574, 0xc8f1405b, 0x0ca4224d, 0xecd36071, 0xa9461754, 0xe7a0ed72,
1349 0x559e8346, 0x1c9beec1, 0xc786ea4a, 0x9561b44d, 0x9788074d, 0x1a69934f, 0x23c5614c, 0x07c79d4b,
1350 0xc7ee52db, 0xc72df351, 0xcb135e44, 0xa0988346, 0xc211fc4c, 0x87dec34b, 0x1381074d, 0x04a65cb7,
1351 0x4409083a, 0x4a407a4c, 0x92b8d37d, 0xacf50b4d, 0xa58aa5bc, 0x448f801f, 0x9c83762e, 0x6fd5734a,
1352 0xfe2d454b, 0x84144c55, 0x05190e4c, 0xb2151448, 0x63867a3e, 0x16099018, 0x9c010d3c, 0x962d8f3d,
1353 0xd51ee453, 0x9d86801f, 0x68e87b47, 0x6bf7bb73, 0x5fc7910e, 0x10d90118, 0x3db04442, 0x729d3e4b,
1354 0xc397d842, 0x57bb15ad, 0x72f31f4e, 0xc9380043, 0x2bb24e18, 0xd9b8ab50, 0xb786801f, 0xf4dc4847,
1355 0x85f4bb51, 0x4435995b, 0x5ba07e40, 0x2c57392e, 0x3628124b, 0x9839b64b, 0x6fe8b24d, 0xaddce847,
1356 0x75260e45, 0x0c572a43, 0xfea21902, 0xb9f9742e, 0x5a70d443, 0x8fc5910e, 0x868d4744, 0x56245e02,
1357 0xd7eb5f02, 0x35c12c1b, 0x4373034b, 0x8786554c, 0xa6facf18, 0x4b11a31f, 0x3570664e, 0x5a64bc42,
1358 0x0b03983f, 0x8f457e4c, 0x0fd874c3, 0xb6cf31b2, 0x2bbc2d4e, 0x146ca5b2, 0x9d00b150, 0x048a4153,
1359 0xca4dcd43, 0xc1607cca, 0x8234cf57, 0x9c7daead, 0x3dc07658, 0xea5c6e4c, 0xf1a0084e, 0x16d2ee53,
1360 0x1b849418, 0xfe913a47, 0x1e988f62, 0x208b644c, 0xc55ee980, 0xbdbce747, 0xf59a384e, 0x0f56091b,
1361 0x7417b745, 0x0c37344e, 0x2c62ab47, 0xf8533a4d, 0x8030084d, 0x76b93c4b, 0xda6ea0ad, 0x3c54f618,
1362 0x63b0de1f, 0x7370d858, 0x1a70bb4c, 0xdda63b2e, 0x60b2ba50, 0x1ba7d048, 0xbe1b2c1b, 0xabea5747,
1363 0x29ad2e4d, 0xe8cd7642, 0x66c80e18, 0x138bf34a, 0xc6145e44, 0x2586794c, 0x07bc5478, 0x0da0b14d,
1364 0x8f95354e, 0x9eb11c62, 0xa1545e46, 0x2e7a2602, 0x408c9c3d, 0x59065d55, 0xf51d1a4c, 0x3bbc6a4e,
1365 0xc71b2a2e, 0xcdaaa545, 0x17d659d0, 0x5202e7ad, 0xf1b68445, 0x93375961, 0xbd88a043, 0x066ad655,
1366 0x890f6318, 0x7b7dca47, 0x99bdd662, 0x3bb4fc53, 0x1231efdc, 0xc0a99444, 0x96bbea47, 0x61ed8748,
1367 0x27dfa73b, 0x8d4d1754, 0x3460042e, 0x551f0c4c, 0x8d0e0718, 0x162ddc53, 0x53231718, 0x1ecd65d0,
1368 0x944d28bc, 0x3b79d058, 0xaff97fbc, 0x4860006c, 0xc101c90e, 0xace41743, 0xa5975d4c, 0x5cc2703e,
1369 0xb55a4450, 0x02d18840, 0xee2765ae, 0xd6012fd5, 0x24c94d7d, 0x8c6eec47, 0x7520ba5d, 0x9e15e460,
1370 0x8510b04c, 0x75ec3847, 0x1dfa6661, 0xe172b3ad, 0x5744c90e, 0x52a0a152, 0x8d6fad18, 0x67b74b6d,
1371 0x93a089b2, 0x0f3ac5d5, 0xe5de1855, 0x43d25747, 0x4bad804a, 0x55b408d8, 0x60a36441, 0xf553e860,
1372 0xdb2fa2c8, 0x03152b32, 0xdd27a7d5, 0x3116a8b8, 0x0a1d708c, 0xeee2f13c, 0x6acf436f, 0xce6eb4ca,
1373 0x101cd3d9, 0x1c48a6b8, 0xe57d6f44, 0x93dcf562,
1378 void ThreadOpenConnections(void* parg)
1380 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1383 vnThreadsRunning[1]++;
1384 ThreadOpenConnections2(parg);
1385 vnThreadsRunning[1]--;
1387 catch (std::exception& e) {
1388 vnThreadsRunning[1]--;
1389 PrintException(&e, "ThreadOpenConnections()");
1391 vnThreadsRunning[1]--;
1392 PrintException(NULL, "ThreadOpenConnections()");
1394 printf("ThreadOpenConnections exiting\n");
1397 void ThreadOpenConnections2(void* parg)
1399 printf("ThreadOpenConnections started\n");
1401 // Connect to specific addresses
1402 if (mapArgs.count("-connect"))
1404 for (int64 nLoop = 0;; nLoop++)
1406 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1408 CAddress addr(strAddr, fAllowDNS);
1410 OpenNetworkConnection(addr);
1411 for (int i = 0; i < 10 && i < nLoop; i++)
1421 // Connect to manually added nodes first
1422 if (mapArgs.count("-addnode"))
1424 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1426 CAddress addr(strAddr, fAllowDNS);
1429 OpenNetworkConnection(addr);
1437 // Initiate network connections
1438 int64 nStart = GetTime();
1441 // Limit outbound connections
1442 vnThreadsRunning[1]--;
1447 CRITICAL_BLOCK(cs_vNodes)
1448 BOOST_FOREACH(CNode* pnode, vNodes)
1449 if (!pnode->fInbound)
1451 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1452 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1453 if (nOutbound < nMaxOutboundConnections)
1459 vnThreadsRunning[1]++;
1463 CRITICAL_BLOCK(cs_mapAddresses)
1465 // Add seed nodes if IRC isn't working
1466 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1467 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fTOR) && !fTestNet)
1469 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1471 // It'll only connect to one or two seed nodes because once it connects,
1472 // it'll get a pile of addresses with newer timestamps.
1473 // Seed nodes are given a random 'last seen time' of between one and two
1475 const int64 nOneWeek = 7*24*60*60;
1477 addr.ip = pnSeed[i];
1478 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1486 // Choose an address to connect to based on most recently seen
1488 CAddress addrConnect;
1489 int64 nBest = INT64_MIN;
1491 // Only connect to one address per a.b.?.? range.
1492 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1493 set<unsigned int> setConnected;
1494 CRITICAL_BLOCK(cs_vNodes)
1495 BOOST_FOREACH(CNode* pnode, vNodes)
1496 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1498 int64 nANow = GetAdjustedTime();
1500 CRITICAL_BLOCK(cs_mapAddresses)
1502 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1504 const CAddress& addr = item.second;
1505 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1507 int64 nSinceLastSeen = nANow - addr.nTime;
1508 int64 nSinceLastTry = nANow - addr.nLastTry;
1510 // Randomize the order in a deterministic way, putting the standard port first
1511 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1512 if (addr.port != htons(GetDefaultPort()))
1513 nRandomizer += 2 * 60 * 60;
1515 // Last seen Base retry frequency
1524 // 365 days 93 hours
1525 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1527 // Fast reconnect for one hour after last seen
1528 if (nSinceLastSeen < 60 * 60)
1531 // Limit retry frequency
1532 if (nSinceLastTry < nDelay)
1535 // If we have IRC, we'll be notified when they first come online,
1536 // and again every 24 hours by the refresh broadcast.
1537 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1540 // Only try the old stuff if we don't have enough connections
1541 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1544 // If multiple addresses are ready, prioritize by time since
1545 // last seen and time since last tried.
1546 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1555 if (addrConnect.IsValid())
1556 OpenNetworkConnection(addrConnect);
1560 bool OpenNetworkConnection(const CAddress& addrConnect)
1563 // Initiate outbound network connection
1567 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
1568 FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
1571 vnThreadsRunning[1]--;
1572 CNode* pnode = ConnectNode(addrConnect);
1573 vnThreadsRunning[1]++;
1578 pnode->fNetworkNode = true;
1590 void ThreadMessageHandler(void* parg)
1592 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1595 vnThreadsRunning[2]++;
1596 ThreadMessageHandler2(parg);
1597 vnThreadsRunning[2]--;
1599 catch (std::exception& e) {
1600 vnThreadsRunning[2]--;
1601 PrintException(&e, "ThreadMessageHandler()");
1603 vnThreadsRunning[2]--;
1604 PrintException(NULL, "ThreadMessageHandler()");
1606 printf("ThreadMessageHandler exiting\n");
1609 void ThreadMessageHandler2(void* parg)
1611 printf("ThreadMessageHandler started\n");
1612 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1615 vector<CNode*> vNodesCopy;
1616 CRITICAL_BLOCK(cs_vNodes)
1618 vNodesCopy = vNodes;
1619 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1623 // Poll the connected nodes for messages
1624 CNode* pnodeTrickle = NULL;
1625 if (!vNodesCopy.empty())
1626 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1627 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1630 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1631 ProcessMessages(pnode);
1636 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1637 SendMessages(pnode, pnode == pnodeTrickle);
1642 CRITICAL_BLOCK(cs_vNodes)
1644 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1648 // Wait and allow messages to bunch up.
1649 // Reduce vnThreadsRunning so StopNode has permission to exit while
1650 // we're sleeping, but we must always check fShutdown after doing this.
1651 vnThreadsRunning[2]--;
1653 if (fRequestShutdown)
1655 vnThreadsRunning[2]++;
1666 bool BindListenPort(string& strError)
1670 addrLocalHost.port = htons(GetListenPort());
1673 // Initialize Windows Sockets
1675 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1676 if (ret != NO_ERROR)
1678 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1679 printf("%s\n", strError.c_str());
1684 // Create socket for listening for incoming connections
1685 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1686 if (hListenSocket == INVALID_SOCKET)
1688 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1689 printf("%s\n", strError.c_str());
1694 // Different way of disabling SIGPIPE on BSD
1695 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1699 // Allow binding if the port is still in TIME_WAIT state after
1700 // the program was closed and restarted. Not an issue on windows.
1701 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1705 // Set to nonblocking, incoming connections will also inherit this
1706 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1708 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1711 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1712 printf("%s\n", strError.c_str());
1716 // The sockaddr_in structure specifies the address family,
1717 // IP address, and port for the socket that is being bound
1718 struct sockaddr_in sockaddr;
1719 memset(&sockaddr, 0, sizeof(sockaddr));
1720 sockaddr.sin_family = AF_INET;
1721 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1722 sockaddr.sin_port = htons(GetListenPort());
1723 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1725 int nErr = WSAGetLastError();
1726 if (nErr == WSAEADDRINUSE)
1727 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1729 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1730 printf("%s\n", strError.c_str());
1733 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1735 // Listen for incoming connections
1736 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1738 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1739 printf("%s\n", strError.c_str());
1746 void StartNode(void* parg)
1748 if (pnodeLocalHost == NULL)
1749 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1752 // Get local host ip
1753 char pszHostName[1000] = "";
1754 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1756 vector<CAddress> vaddr;
1757 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1758 BOOST_FOREACH (const CAddress &addr, vaddr)
1759 if (addr.GetByte(3) != 127)
1761 addrLocalHost = addr;
1766 // Get local host ip
1767 struct ifaddrs* myaddrs;
1768 if (getifaddrs(&myaddrs) == 0)
1770 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1772 if (ifa->ifa_addr == NULL) continue;
1773 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1774 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1775 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1777 if (ifa->ifa_addr->sa_family == AF_INET)
1779 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1780 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1781 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1783 // Take the first IP that isn't loopback 127.x.x.x
1784 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1785 if (addr.IsValid() && addr.GetByte(3) != 127)
1787 addrLocalHost = addr;
1791 else if (ifa->ifa_addr->sa_family == AF_INET6)
1793 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1794 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1795 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1798 freeifaddrs(myaddrs);
1801 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1803 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1805 // Proxies can't take incoming connections
1806 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1807 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1811 CreateThread(ThreadGetMyExternalIP, NULL);
1818 if (GetBoolArg("-nodnsseed"))
1819 printf("DNS seeding disabled\n");
1821 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1822 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1824 // Map ports with UPnP
1828 // Get addresses from IRC and advertise ours
1829 if (!CreateThread(ThreadIRCSeed, NULL))
1830 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1832 // Send and receive from sockets, accept connections
1833 if (!CreateThread(ThreadSocketHandler, NULL))
1834 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1836 // Initiate outbound connections
1837 if (!CreateThread(ThreadOpenConnections, NULL))
1838 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1841 if (!CreateThread(ThreadMessageHandler, NULL))
1842 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1844 // Generate coins in the background
1845 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1850 printf("StopNode()\n");
1852 nTransactionsUpdated++;
1853 int64 nStart = GetTime();
1854 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1856 || vnThreadsRunning[5] > 0
1860 if (GetTime() - nStart > 20)
1864 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1865 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1866 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1867 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1868 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1869 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1870 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1871 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1887 BOOST_FOREACH(CNode* pnode, vNodes)
1888 if (pnode->hSocket != INVALID_SOCKET)
1889 closesocket(pnode->hSocket);
1890 if (hListenSocket != INVALID_SOCKET)
1891 if (closesocket(hListenSocket) == SOCKET_ERROR)
1892 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1895 // Shutdown Windows Sockets
1900 instance_of_cnetcleanup;