1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2012 The Bitcoin developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
18 #include <miniupnpc/miniwget.h>
19 #include <miniupnpc/miniupnpc.h>
20 #include <miniupnpc/upnpcommands.h>
21 #include <miniupnpc/upnperrors.h>
25 using namespace boost;
27 static const int MAX_OUTBOUND_CONNECTIONS = 8;
29 void ThreadMessageHandler2(void* parg);
30 void ThreadSocketHandler2(void* parg);
31 void ThreadOpenConnections2(void* parg);
33 void ThreadMapPort2(void* parg);
35 void ThreadDNSAddressSeed2(void* parg);
36 bool OpenNetworkConnection(const CAddress& addrConnect);
43 // Global state variables
46 bool fAllowDNS = false;
47 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
48 CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
49 static CNode* pnodeLocalHost = NULL;
50 uint64 nLocalHostNonce = 0;
51 array<int, 10> vnThreadsRunning;
52 static SOCKET hListenSocket = INVALID_SOCKET;
54 vector<CNode*> vNodes;
55 CCriticalSection cs_vNodes;
56 map<vector<unsigned char>, CAddress> mapAddresses;
57 CCriticalSection cs_mapAddresses;
58 map<CInv, CDataStream> mapRelay;
59 deque<pair<int64, CInv> > vRelayExpiration;
60 CCriticalSection cs_mapRelay;
61 map<CInv, int64> mapAlreadyAskedFor;
64 int fUseProxy = false;
65 int nConnectTimeout = 5000;
66 CAddress addrProxy("127.0.0.1",9050);
71 unsigned short GetListenPort()
73 return (unsigned short)(GetArg("-port", GetDefaultPort()));
76 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
78 // Filter out duplicate requests
79 if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
81 pindexLastGetBlocksBegin = pindexBegin;
82 hashLastGetBlocksEnd = hashEnd;
84 PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
91 bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
93 hSocketRet = INVALID_SOCKET;
95 SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
96 if (hSocket == INVALID_SOCKET)
100 setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
103 bool fProxy = (fUseProxy && addrConnect.IsRoutable());
104 struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
107 u_long fNonblock = 1;
108 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
110 int fFlags = fcntl(hSocket, F_GETFL, 0);
111 if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
114 closesocket(hSocket);
119 if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
121 // WSAEINVAL is here because some legacy version of winsock uses it
122 if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
124 struct timeval timeout;
125 timeout.tv_sec = nTimeout / 1000;
126 timeout.tv_usec = (nTimeout % 1000) * 1000;
130 FD_SET(hSocket, &fdset);
131 int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
134 printf("connection timeout\n");
135 closesocket(hSocket);
138 if (nRet == SOCKET_ERROR)
140 printf("select() for connection failed: %i\n",WSAGetLastError());
141 closesocket(hSocket);
144 socklen_t nRetSize = sizeof(nRet);
146 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
148 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
151 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
152 closesocket(hSocket);
157 printf("connect() failed after select(): %s\n",strerror(nRet));
158 closesocket(hSocket);
163 else if (WSAGetLastError() != WSAEISCONN)
168 printf("connect() failed: %i\n",WSAGetLastError());
169 closesocket(hSocket);
175 this isn't even strictly necessary
176 CNode::ConnectNode immediately turns the socket back to non-blocking
177 but we'll turn it back to blocking just in case
181 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
183 fFlags = fcntl(hSocket, F_GETFL, 0);
184 if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
187 closesocket(hSocket);
193 printf("proxy connecting %s\n", addrConnect.ToString().c_str());
194 char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
195 memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
196 memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
197 char* pszSocks4 = pszSocks4IP;
198 int nSize = sizeof(pszSocks4IP);
200 int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
203 closesocket(hSocket);
204 return error("Error sending to proxy");
207 if (recv(hSocket, pchRet, 8, 0) != 8)
209 closesocket(hSocket);
210 return error("Error reading proxy response");
212 if (pchRet[1] != 0x5a)
214 closesocket(hSocket);
215 if (pchRet[1] != 0x5b)
216 printf("ERROR: Proxy returned error %d\n", pchRet[1]);
219 printf("proxy connected %s\n", addrConnect.ToString().c_str());
222 hSocketRet = hSocket;
226 // portDefault is in host order
227 bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
232 int port = portDefault;
235 strlcpy(psz, pszName, sizeof(psz));
238 char* pszColon = strrchr(psz+1,':');
239 char *pszPortEnd = NULL;
240 int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
241 if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
243 if (psz[0] == '[' && pszColon[-1] == ']')
245 // Future: enable IPv6 colon-notation inside []
252 if (port < 0 || port > USHRT_MAX)
257 unsigned int addrIP = inet_addr(pszHost);
258 if (addrIP != INADDR_NONE)
260 // valid IP address passed
261 vaddr.push_back(CAddress(addrIP, port, nServices));
268 struct hostent* phostent = gethostbyname(pszHost);
272 if (phostent->h_addrtype != AF_INET)
275 char** ppAddr = phostent->h_addr_list;
276 while (*ppAddr != NULL && vaddr.size() != nMaxSolutions)
278 CAddress addr(((struct in_addr*)ppAddr[0])->s_addr, port, nServices);
280 vaddr.push_back(addr);
284 return (vaddr.size() > 0);
287 // portDefault is in host order
288 bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup, int portDefault, bool fAllowPort)
290 vector<CAddress> vaddr;
291 bool fRet = Lookup(pszName, vaddr, nServices, 1, fAllowLookup, portDefault, fAllowPort);
297 bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet)
300 if (!ConnectSocket(addrConnect, hSocket))
301 return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
303 send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
306 while (RecvLine(hSocket, strLine))
308 if (strLine.empty()) // HTTP response is separated from headers by blank line
312 if (!RecvLine(hSocket, strLine))
314 closesocket(hSocket);
317 if (pszKeyword == NULL)
319 if (strLine.find(pszKeyword) != string::npos)
321 strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
325 closesocket(hSocket);
326 if (strLine.find("<") != string::npos)
327 strLine = strLine.substr(0, strLine.find("<"));
328 strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
329 while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
330 strLine.resize(strLine.size()-1);
331 CAddress addr(strLine,0,true);
332 printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
333 if (addr.ip == 0 || addr.ip == INADDR_NONE || !addr.IsRoutable())
339 closesocket(hSocket);
340 return error("GetMyExternalIP() : connection closed");
343 // We now get our external IP from the IRC server first and only use this as a backup
344 bool GetMyExternalIP(unsigned int& ipRet)
346 CAddress addrConnect;
348 const char* pszKeyword;
353 for (int nLookup = 0; nLookup <= 1; nLookup++)
354 for (int nHost = 1; nHost <= 2; nHost++)
356 // We should be phasing out our use of sites like these. If we need
357 // replacements, we should ask for volunteers to put this simple
358 // php file on their webserver that prints the client IP:
359 // <?php echo $_SERVER["REMOTE_ADDR"]; ?>
362 addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
366 CAddress addrIP("checkip.dyndns.org", 80, true);
367 if (addrIP.IsValid())
368 addrConnect = addrIP;
371 pszGet = "GET / HTTP/1.1\r\n"
372 "Host: checkip.dyndns.org\r\n"
373 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
374 "Connection: close\r\n"
377 pszKeyword = "Address:";
381 addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
385 CAddress addrIP("www.showmyip.com", 80, true);
386 if (addrIP.IsValid())
387 addrConnect = addrIP;
390 pszGet = "GET /simple/ HTTP/1.1\r\n"
391 "Host: www.showmyip.com\r\n"
392 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
393 "Connection: close\r\n"
396 pszKeyword = NULL; // Returns just IP address
399 if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
406 void ThreadGetMyExternalIP(void* parg)
408 // Wait for IRC to get it first
409 if (!GetBoolArg("-noirc"))
411 for (int i = 0; i < 2 * 60; i++)
414 if (fGotExternalIP || fShutdown)
419 // Fallback in case IRC fails to get it
420 if (GetMyExternalIP(addrLocalHost.ip))
422 printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
423 if (addrLocalHost.IsRoutable())
425 // If we already connected to a few before we had our IP, go back and addr them.
426 // setAddrKnown automatically filters any duplicate sends.
427 CAddress addr(addrLocalHost);
428 addr.nTime = GetAdjustedTime();
429 CRITICAL_BLOCK(cs_vNodes)
430 BOOST_FOREACH(CNode* pnode, vNodes)
431 pnode->PushAddress(addr);
440 bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
442 if (!addr.IsRoutable())
444 if (addr.ip == addrLocalHost.ip)
446 addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
447 bool fUpdated = false;
449 CAddress addrFound = addr;
451 CRITICAL_BLOCK(cs_mapAddresses)
453 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
454 if (it == mapAddresses.end())
457 printf("AddAddress(%s)\n", addr.ToString().c_str());
458 mapAddresses.insert(make_pair(addr.GetKey(), addr));
464 addrFound = (*it).second;
465 if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
467 // Services have been added
468 addrFound.nServices |= addr.nServices;
471 bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
472 int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
473 if (addrFound.nTime < addr.nTime - nUpdateInterval)
475 // Periodically update most recently seen time
476 addrFound.nTime = addr.nTime;
481 // There is a nasty deadlock bug if this is done inside the cs_mapAddresses
483 // Thread 1: begin db transaction (locks inside-db-mutex)
484 // then AddAddress (locks cs_mapAddresses)
485 // Thread 2: AddAddress (locks cs_mapAddresses)
486 // ... then db operation hangs waiting for inside-db-mutex
490 pAddrDB->WriteAddress(addrFound);
492 CAddrDB().WriteAddress(addrFound);
497 void AddressCurrentlyConnected(const CAddress& addr)
499 CAddress *paddrFound = NULL;
501 CRITICAL_BLOCK(cs_mapAddresses)
503 // Only if it's been published already
504 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
505 if (it != mapAddresses.end())
506 paddrFound = &(*it).second;
511 int64 nUpdateInterval = 20 * 60;
512 if (paddrFound->nTime < GetAdjustedTime() - nUpdateInterval)
514 // Periodically update most recently seen time
515 paddrFound->nTime = GetAdjustedTime();
517 addrdb.WriteAddress(*paddrFound);
526 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
528 // If the dialog might get closed before the reply comes back,
529 // call this in the destructor so it doesn't get called after it's deleted.
530 CRITICAL_BLOCK(cs_vNodes)
532 BOOST_FOREACH(CNode* pnode, vNodes)
534 CRITICAL_BLOCK(pnode->cs_mapRequests)
536 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
538 CRequestTracker& tracker = (*mi).second;
539 if (tracker.fn == fn && tracker.param1 == param1)
540 pnode->mapRequests.erase(mi++);
556 // Subscription methods for the broadcast and subscription system.
557 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
559 // The subscription system uses a meet-in-the-middle strategy.
560 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
561 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
564 bool AnySubscribed(unsigned int nChannel)
566 if (pnodeLocalHost->IsSubscribed(nChannel))
568 CRITICAL_BLOCK(cs_vNodes)
569 BOOST_FOREACH(CNode* pnode, vNodes)
570 if (pnode->IsSubscribed(nChannel))
575 bool CNode::IsSubscribed(unsigned int nChannel)
577 if (nChannel >= vfSubscribe.size())
579 return vfSubscribe[nChannel];
582 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
584 if (nChannel >= vfSubscribe.size())
587 if (!AnySubscribed(nChannel))
590 CRITICAL_BLOCK(cs_vNodes)
591 BOOST_FOREACH(CNode* pnode, vNodes)
593 pnode->PushMessage("subscribe", nChannel, nHops);
596 vfSubscribe[nChannel] = true;
599 void CNode::CancelSubscribe(unsigned int nChannel)
601 if (nChannel >= vfSubscribe.size())
604 // Prevent from relaying cancel if wasn't subscribed
605 if (!vfSubscribe[nChannel])
607 vfSubscribe[nChannel] = false;
609 if (!AnySubscribed(nChannel))
611 // Relay subscription cancel
612 CRITICAL_BLOCK(cs_vNodes)
613 BOOST_FOREACH(CNode* pnode, vNodes)
615 pnode->PushMessage("sub-cancel", nChannel);
627 CNode* FindNode(unsigned int ip)
629 CRITICAL_BLOCK(cs_vNodes)
631 BOOST_FOREACH(CNode* pnode, vNodes)
632 if (pnode->addr.ip == ip)
638 CNode* FindNode(CAddress addr)
640 CRITICAL_BLOCK(cs_vNodes)
642 BOOST_FOREACH(CNode* pnode, vNodes)
643 if (pnode->addr == addr)
649 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
651 if (addrConnect.ip == addrLocalHost.ip)
654 // Look for an existing connection
655 CNode* pnode = FindNode(addrConnect.ip);
659 pnode->AddRef(nTimeout);
666 printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
667 addrConnect.ToString().c_str(),
668 (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
669 (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
671 CRITICAL_BLOCK(cs_mapAddresses)
672 mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
676 if (ConnectSocket(addrConnect, hSocket))
679 printf("connected %s\n", addrConnect.ToString().c_str());
681 // Set to nonblocking
684 if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
685 printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
687 if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
688 printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
692 CNode* pnode = new CNode(hSocket, addrConnect, false);
694 pnode->AddRef(nTimeout);
697 CRITICAL_BLOCK(cs_vNodes)
698 vNodes.push_back(pnode);
700 pnode->nTimeConnected = GetTime();
709 void CNode::CloseSocketDisconnect()
712 if (hSocket != INVALID_SOCKET)
715 printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
716 printf("disconnecting node %s\n", addr.ToString().c_str());
717 closesocket(hSocket);
718 hSocket = INVALID_SOCKET;
723 void CNode::Cleanup()
725 // All of a nodes broadcasts and subscriptions are automatically torn down
726 // when it goes down, so a node has to stay up to keep its broadcast going.
728 // Cancel subscriptions
729 for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
730 if (vfSubscribe[nChannel])
731 CancelSubscribe(nChannel);
735 std::map<unsigned int, int64> CNode::setBanned;
736 CCriticalSection CNode::cs_setBanned;
738 void CNode::ClearBanned()
743 bool CNode::IsBanned(unsigned int ip)
745 bool fResult = false;
746 CRITICAL_BLOCK(cs_setBanned)
748 std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
749 if (i != setBanned.end())
751 int64 t = (*i).second;
759 bool CNode::Misbehaving(int howmuch)
763 printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
767 nMisbehavior += howmuch;
768 if (nMisbehavior >= GetArg("-banscore", 100))
770 int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
771 CRITICAL_BLOCK(cs_setBanned)
772 if (setBanned[addr.ip] < banTime)
773 setBanned[addr.ip] = banTime;
774 CloseSocketDisconnect();
775 printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
792 void ThreadSocketHandler(void* parg)
794 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
797 vnThreadsRunning[0]++;
798 ThreadSocketHandler2(parg);
799 vnThreadsRunning[0]--;
801 catch (std::exception& e) {
802 vnThreadsRunning[0]--;
803 PrintException(&e, "ThreadSocketHandler()");
805 vnThreadsRunning[0]--;
806 throw; // support pthread_cancel()
808 printf("ThreadSocketHandler exiting\n");
811 void ThreadSocketHandler2(void* parg)
813 printf("ThreadSocketHandler started\n");
814 list<CNode*> vNodesDisconnected;
815 int nPrevNodeCount = 0;
822 CRITICAL_BLOCK(cs_vNodes)
824 // Disconnect unused nodes
825 vector<CNode*> vNodesCopy = vNodes;
826 BOOST_FOREACH(CNode* pnode, vNodesCopy)
828 if (pnode->fDisconnect ||
829 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
831 // remove from vNodes
832 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
834 // close socket and cleanup
835 pnode->CloseSocketDisconnect();
838 // hold in disconnected pool until all refs are released
839 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
840 if (pnode->fNetworkNode || pnode->fInbound)
842 vNodesDisconnected.push_back(pnode);
846 // Delete disconnected nodes
847 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
848 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
850 // wait until threads are done using it
851 if (pnode->GetRefCount() <= 0)
853 bool fDelete = false;
854 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
855 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
856 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
857 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
861 vNodesDisconnected.remove(pnode);
867 if (vNodes.size() != nPrevNodeCount)
869 nPrevNodeCount = vNodes.size();
875 // Find which sockets have data to receive
877 struct timeval timeout;
879 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
886 FD_ZERO(&fdsetError);
887 SOCKET hSocketMax = 0;
889 if(hListenSocket != INVALID_SOCKET)
890 FD_SET(hListenSocket, &fdsetRecv);
891 hSocketMax = max(hSocketMax, hListenSocket);
892 CRITICAL_BLOCK(cs_vNodes)
894 BOOST_FOREACH(CNode* pnode, vNodes)
896 if (pnode->hSocket == INVALID_SOCKET)
898 FD_SET(pnode->hSocket, &fdsetRecv);
899 FD_SET(pnode->hSocket, &fdsetError);
900 hSocketMax = max(hSocketMax, pnode->hSocket);
901 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
902 if (!pnode->vSend.empty())
903 FD_SET(pnode->hSocket, &fdsetSend);
907 vnThreadsRunning[0]--;
908 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
909 vnThreadsRunning[0]++;
912 if (nSelect == SOCKET_ERROR)
914 int nErr = WSAGetLastError();
917 printf("socket select error %d\n", nErr);
918 for (unsigned int i = 0; i <= hSocketMax; i++)
919 FD_SET(i, &fdsetRecv);
922 FD_ZERO(&fdsetError);
923 Sleep(timeout.tv_usec/1000);
928 // Accept new connections
930 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
932 struct sockaddr_in sockaddr;
933 socklen_t len = sizeof(sockaddr);
934 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
938 if (hSocket != INVALID_SOCKET)
939 addr = CAddress(sockaddr);
941 CRITICAL_BLOCK(cs_vNodes)
942 BOOST_FOREACH(CNode* pnode, vNodes)
946 if (hSocket == INVALID_SOCKET)
948 if (WSAGetLastError() != WSAEWOULDBLOCK)
949 printf("socket error accept failed: %d\n", WSAGetLastError());
951 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
953 closesocket(hSocket);
955 else if (CNode::IsBanned(addr.ip))
957 printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
958 closesocket(hSocket);
962 printf("accepted connection %s\n", addr.ToString().c_str());
963 CNode* pnode = new CNode(hSocket, addr, true);
965 CRITICAL_BLOCK(cs_vNodes)
966 vNodes.push_back(pnode);
972 // Service each socket
974 vector<CNode*> vNodesCopy;
975 CRITICAL_BLOCK(cs_vNodes)
978 BOOST_FOREACH(CNode* pnode, vNodesCopy)
981 BOOST_FOREACH(CNode* pnode, vNodesCopy)
989 if (pnode->hSocket == INVALID_SOCKET)
991 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
993 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
995 CDataStream& vRecv = pnode->vRecv;
996 unsigned int nPos = vRecv.size();
998 if (nPos > ReceiveBufferSize()) {
999 if (!pnode->fDisconnect)
1000 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
1001 pnode->CloseSocketDisconnect();
1004 // typical socket buffer is 8K-64K
1005 char pchBuf[0x10000];
1006 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1009 vRecv.resize(nPos + nBytes);
1010 memcpy(&vRecv[nPos], pchBuf, nBytes);
1011 pnode->nLastRecv = GetTime();
1013 else if (nBytes == 0)
1015 // socket closed gracefully
1016 if (!pnode->fDisconnect)
1017 printf("socket closed\n");
1018 pnode->CloseSocketDisconnect();
1020 else if (nBytes < 0)
1023 int nErr = WSAGetLastError();
1024 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1026 if (!pnode->fDisconnect)
1027 printf("socket recv error %d\n", nErr);
1028 pnode->CloseSocketDisconnect();
1038 if (pnode->hSocket == INVALID_SOCKET)
1040 if (FD_ISSET(pnode->hSocket, &fdsetSend))
1042 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1044 CDataStream& vSend = pnode->vSend;
1047 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
1050 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1051 pnode->nLastSend = GetTime();
1053 else if (nBytes < 0)
1056 int nErr = WSAGetLastError();
1057 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1059 printf("socket send error %d\n", nErr);
1060 pnode->CloseSocketDisconnect();
1063 if (vSend.size() > SendBufferSize()) {
1064 if (!pnode->fDisconnect)
1065 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1066 pnode->CloseSocketDisconnect();
1073 // Inactivity checking
1075 if (pnode->vSend.empty())
1076 pnode->nLastSendEmpty = GetTime();
1077 if (GetTime() - pnode->nTimeConnected > 60)
1079 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1081 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1082 pnode->fDisconnect = true;
1084 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1086 printf("socket not sending\n");
1087 pnode->fDisconnect = true;
1089 else if (GetTime() - pnode->nLastRecv > 90*60)
1091 printf("socket inactivity timeout\n");
1092 pnode->fDisconnect = true;
1096 CRITICAL_BLOCK(cs_vNodes)
1098 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1115 void ThreadMapPort(void* parg)
1117 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1120 vnThreadsRunning[5]++;
1121 ThreadMapPort2(parg);
1122 vnThreadsRunning[5]--;
1124 catch (std::exception& e) {
1125 vnThreadsRunning[5]--;
1126 PrintException(&e, "ThreadMapPort()");
1128 vnThreadsRunning[5]--;
1129 PrintException(NULL, "ThreadMapPort()");
1131 printf("ThreadMapPort exiting\n");
1134 void ThreadMapPort2(void* parg)
1136 printf("ThreadMapPort started\n");
1139 sprintf(port, "%d", GetListenPort());
1141 const char * multicastif = 0;
1142 const char * minissdpdpath = 0;
1143 struct UPNPDev * devlist = 0;
1146 #ifndef UPNPDISCOVER_SUCCESS
1148 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1152 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1155 struct UPNPUrls urls;
1156 struct IGDdatas data;
1159 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1162 if (!addrLocalHost.IsRoutable())
1164 char externalIPAddress[40];
1165 r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1166 if(r != UPNPCOMMAND_SUCCESS)
1167 printf("UPnP: GetExternalIPAddress() returned %d\n", r);
1170 if(externalIPAddress[0])
1172 printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1173 CAddress addrExternalFromUPnP(externalIPAddress, 0, false, nLocalServices);
1174 if (addrExternalFromUPnP.IsRoutable())
1175 addrLocalHost = addrExternalFromUPnP;
1178 printf("UPnP: GetExternalIPAddress failed.\n");
1182 string strDesc = "Bitcoin " + FormatFullVersion();
1183 #ifndef UPNPDISCOVER_SUCCESS
1185 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1186 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1189 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1190 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1193 if(r!=UPNPCOMMAND_SUCCESS)
1194 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1195 port, port, lanaddr, r, strupnperror(r));
1197 printf("UPnP Port Mapping successful.\n");
1200 if (fShutdown || !fUseUPnP)
1202 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1203 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1204 freeUPNPDevlist(devlist); devlist = 0;
1205 FreeUPNPUrls(&urls);
1208 if (i % 600 == 0) // Refresh every 20 minutes
1210 #ifndef UPNPDISCOVER_SUCCESS
1212 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1213 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1216 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1217 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1220 if(r!=UPNPCOMMAND_SUCCESS)
1221 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1222 port, port, lanaddr, r, strupnperror(r));
1224 printf("UPnP Port Mapping successful.\n");;
1230 printf("No valid UPnP IGDs found\n");
1231 freeUPNPDevlist(devlist); devlist = 0;
1233 FreeUPNPUrls(&urls);
1235 if (fShutdown || !fUseUPnP)
1242 void MapPort(bool fMapPort)
1244 if (fUseUPnP != fMapPort)
1246 fUseUPnP = fMapPort;
1247 WriteSetting("fUseUPnP", fUseUPnP);
1249 if (fUseUPnP && vnThreadsRunning[5] < 1)
1251 if (!CreateThread(ThreadMapPort, NULL))
1252 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1256 void MapPort(bool /* unused fMapPort */)
1258 // Intentionally left blank.
1271 static const char *strDNSSeed[] = {
1273 "dnsseed.bluematt.me",
1274 "seed.bitcoin.sipa.be",
1275 "dnsseed.bitcoin.dashjr.org",
1278 void ThreadDNSAddressSeed(void* parg)
1280 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1283 vnThreadsRunning[6]++;
1284 ThreadDNSAddressSeed2(parg);
1285 vnThreadsRunning[6]--;
1287 catch (std::exception& e) {
1288 vnThreadsRunning[6]--;
1289 PrintException(&e, "ThreadDNSAddressSeed()");
1291 vnThreadsRunning[6]--;
1292 throw; // support pthread_cancel()
1294 printf("ThreadDNSAddressSeed exiting\n");
1297 void ThreadDNSAddressSeed2(void* parg)
1299 printf("ThreadDNSAddressSeed started\n");
1304 printf("Loading addresses from DNS seeds (could take a while)\n");
1306 for (unsigned int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1307 vector<CAddress> vaddr;
1308 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1312 BOOST_FOREACH (CAddress& addr, vaddr)
1314 if (addr.GetByte(3) != 127)
1317 AddAddress(addr, 0, &addrDB);
1321 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1326 printf("%d addresses found from DNS seeds\n", found);
1340 unsigned int pnSeed[] =
1342 0x959bd347, 0xf8de42b2, 0x73bc0518, 0xea6edc50, 0x21b00a4d, 0xc725b43d, 0xd665464d, 0x1a2a770e,
1343 0x27c93946, 0x65b2fa46, 0xb80ae255, 0x66b3b446, 0xb1877a3e, 0x6ee89e3e, 0xc3175b40, 0x2a01a83c,
1344 0x95b1363a, 0xa079ad3d, 0xe6ca801f, 0x027f4f4a, 0x34f7f03a, 0xf790f04a, 0x16ca801f, 0x2f4d5e40,
1345 0x3a4d5e40, 0xc43a322e, 0xc8159753, 0x14d4724c, 0x7919a118, 0xe0bdb34e, 0x68a16b2e, 0xff64b44d,
1346 0x6099115b, 0x9b57b05b, 0x7bd1b4ad, 0xdf95944f, 0x29d2b73d, 0xafa8db79, 0xe247ba41, 0x24078348,
1347 0xf722f03c, 0x33567ebc, 0xace64ed4, 0x984d3932, 0xb5f34e55, 0x27b7024d, 0x94579247, 0x8894042e,
1348 0x9357d34c, 0x1063c24b, 0xcaa228b1, 0xa3c5a8b2, 0x5dc64857, 0xa2c23643, 0xa8369a54, 0x31203077,
1349 0x00707c5c, 0x09fc0b3a, 0x272e9e2e, 0xf80f043e, 0x9449ca3e, 0x5512c33e, 0xd106b555, 0xe8024157,
1350 0xe288ec29, 0xc79c5461, 0xafb63932, 0xdb02ab4b, 0x0e512777, 0x8a145a4c, 0xb201ff4f, 0x5e09314b,
1351 0xcd9bfbcd, 0x1c023765, 0x4394e75c, 0xa728bd4d, 0x65331552, 0xa98420b1, 0x89ecf559, 0x6e80801f,
1352 0xf404f118, 0xefd62b51, 0x05918346, 0x9b186d5f, 0xacabab46, 0xf912e255, 0xc188ea62, 0xcc55734e,
1353 0xc668064d, 0xd77a4558, 0x46201c55, 0xf17dfc80, 0xf7142f2e, 0x87bfb718, 0x8aa54fb2, 0xc451d518,
1354 0xc4ae8831, 0x8dd44d55, 0x5bbd206c, 0x64536b5d, 0x5c667e60, 0x3b064242, 0xfe963a42, 0xa28e6dc8,
1355 0xe8a9604a, 0xc989464e, 0xd124a659, 0x50065140, 0xa44dfe5e, 0x1079e655, 0x3fb986d5, 0x47895b18,
1356 0x7d3ce4ad, 0x4561ba50, 0x296eec62, 0x255b41ad, 0xaed35ec9, 0x55556f12, 0xc7d3154d, 0x3297b65d,
1357 0x8930121f, 0xabf42e4e, 0x4a29e044, 0x1212685d, 0x676c1e40, 0xce009744, 0x383a8948, 0xa2dbd0ad,
1358 0xecc2564d, 0x07dbc252, 0x887ee24b, 0x5171644c, 0x6bb798c1, 0x847f495d, 0x4cbb7145, 0x3bb81c32,
1359 0x45eb262e, 0xc8015a4e, 0x250a361b, 0xf694f946, 0xd64a183e, 0xd4f1dd59, 0x8f20ffd4, 0x51d9e55c,
1360 0x09521763, 0x5e02002e, 0x32c8074d, 0xe685762e, 0x8290b0bc, 0x762a922e, 0xfc5ee754, 0x83a24829,
1361 0x775b224d, 0x6295bb4d, 0x38ec0555, 0xbffbba50, 0xe5560260, 0x86b16a7c, 0xd372234e, 0x49a3c24b,
1362 0x2f6a171f, 0x4d75ed60, 0xae94115b, 0xcb543744, 0x63080c59, 0x3f9c724c, 0xc977ce18, 0x532efb18,
1363 0x69dc3b2e, 0x5f94d929, 0x1732bb4d, 0x9c814b4d, 0xe6b3762e, 0xc024f662, 0x8face35b, 0x6b5b044d,
1364 0x798c7b57, 0x79a6b44c, 0x067d3057, 0xf9e94e5f, 0x91cbe15b, 0x71405eb2, 0x2662234e, 0xcbcc4a6d,
1365 0xbf69d54b, 0xa79b4e55, 0xec6d3e51, 0x7c0b3c02, 0x60f83653, 0x24c1e15c, 0x1110b62e, 0x10350f59,
1366 0xa56f1d55, 0x3509e7a9, 0xeb128354, 0x14268e2e, 0x934e28bc, 0x8e32692e, 0x8331a21f, 0x3e633932,
1367 0xc812b12e, 0xc684bf2e, 0x80112d2e, 0xe0ddc96c, 0xc630ca4a, 0x5c09b3b2, 0x0b580518, 0xc8e9d54b,
1368 0xd169aa43, 0x17d0d655, 0x1d029963, 0x7ff87559, 0xcb701f1f, 0x6fa3e85d, 0xe45e9a54, 0xf05d1802,
1369 0x44d03b2e, 0x837b692e, 0xccd4354e, 0x3d6da13c, 0x3423084d, 0xf707c34a, 0x55f6db3a, 0xad26e442,
1370 0x6233a21f, 0x09e80e59, 0x8caeb54d, 0xbe870941, 0xb407d20e, 0x20b51018, 0x56fb152e, 0x460d2a4e,
1371 0xbb9a2946, 0x560eb12e, 0xed83dd29, 0xd6724f53, 0xa50aafb8, 0x451346d9, 0x88348e2e, 0x7312fead,
1372 0x8ecaf96f, 0x1bda4e5f, 0xf1671e40, 0x3c8c3e3b, 0x4716324d, 0xdde24ede, 0xf98cd17d, 0xa91d4644,
1373 0x28124eb2, 0x147d5129, 0xd022042e, 0x61733d3b, 0xad0d5e02, 0x8ce2932e, 0xe5c18502, 0x549c1e32,
1374 0x9685801f, 0x86e217ad, 0xd948214b, 0x4110f462, 0x3a2e894e, 0xbd35492e, 0x87e0d558, 0x64b8ef7d,
1375 0x7c3eb962, 0x72a84b3e, 0x7cd667c9, 0x28370a2e, 0x4bc60e7b, 0x6fc1ec60, 0x14a6983f, 0x86739a4b,
1376 0x46954e5f, 0x32e2e15c, 0x2e9326cf, 0xe5801c5e, 0x379607b2, 0x32151145, 0xf0e39744, 0xacb54c55,
1377 0xa37dfb60, 0x83b55cc9, 0x388f7ca5, 0x15034f5f, 0x3e94965b, 0x68e0ffad, 0x35280f59, 0x8fe190cf,
1378 0x7c6ba5b2, 0xa5e9db43, 0x4ee1fc60, 0xd9d94e5f, 0x04040677, 0x0ea9b35e, 0x5961f14f, 0x67fda063,
1379 0xa48a5a31, 0xc6524e55, 0x283d325e, 0x3f37515f, 0x96b94b3e, 0xacce620e, 0x6481cc5b, 0xa4a06d4b,
1380 0x9e95d2d9, 0xe40c03d5, 0xc2f4514b, 0xb79aad44, 0xf64be843, 0xb2064070, 0xfca00455, 0x429dfa4e,
1381 0x2323f173, 0xeda4185e, 0xabd5227d, 0x9efd4d58, 0xb1104758, 0x4811e955, 0xbd9ab355, 0xe921f44b,
1382 0x9f166dce, 0x09e279b2, 0xe0c9ac7b, 0x7901a5ad, 0xa145d4b0, 0x79104671, 0xec31e35a, 0x4fe0b555,
1383 0xc7d9cbad, 0xad057f55, 0xe94cc759, 0x7fe0b043, 0xe4529f2e, 0x0d4dd4b2, 0x9f11a54d, 0x031e2e4e,
1384 0xe6014f5f, 0x11d1ca6c, 0x26bd7f61, 0xeb86854f, 0x4d347b57, 0x116bbe2e, 0xdba7234e, 0x7bcbfd2e,
1385 0x174dd4b2, 0x6686762e, 0xb089ba50, 0xc6258246, 0x087e767b, 0xc4a8cb4a, 0x595dba50, 0x7f0ae502,
1386 0x7b1dbd5a, 0xa0603492, 0x57d1af4b, 0x9e21ffd4, 0x6393064d, 0x7407376e, 0xe484762e, 0x122a4e53,
1387 0x4a37aa43, 0x3888a6be, 0xee77864e, 0x039c8dd5, 0x688d89af, 0x0e988f62, 0x08218246, 0xfc2f8246,
1388 0xd1d97040, 0xd64cd4b2, 0x5ae4a6b8, 0x7d0de9bc, 0x8d304d61, 0x06c5c672, 0xa4c8bd4d, 0xe0fd373b,
1389 0x575ebe4d, 0x72d26277, 0x55570f55, 0x77b154d9, 0xe214293a, 0xfc740f4b, 0xfe3f6a57, 0xa9c55f02,
1390 0xae4054db, 0x2394d918, 0xb511b24a, 0xb8741ab2, 0x0758e65e, 0xc7b5795b, 0xb0a30a4c, 0xaf7f170c,
1391 0xf3b4762e, 0x8179576d, 0x738a1581, 0x4b95b64c, 0x9829b618, 0x1bea932e, 0x7bdeaa4b, 0xcb5e0281,
1392 0x65618f54, 0x0658474b, 0x27066acf, 0x40556d65, 0x7d204d53, 0xf28bc244, 0xdce23455, 0xadc0ff54,
1393 0x3863c948, 0xcee34e5f, 0xdeb85e02, 0x2ed17a61, 0x6a7b094d, 0x7f0cfc40, 0x59603f54, 0x3220afbc,
1394 0xb5dfd962, 0x125d21c0, 0x13f8d243, 0xacfefb4e, 0x86c2c147, 0x3d8bbd59, 0xbd02a21f, 0x2593042e,
1395 0xc6a17a7c, 0x28925861, 0xb487ed44, 0xb5f4fd6d, 0x90c28a45, 0x5a14f74d, 0x43d71b4c, 0x728ebb5d,
1396 0x885bf950, 0x08134dd0, 0x38ec046e, 0xc575684b, 0x50082d2e, 0xa2f47757, 0x270f86ae, 0xf3ff6462,
1397 0x10ed3f4e, 0x4b58d462, 0xe01ce23e, 0x8c5b092e, 0x63e52f4e, 0x22c1e85d, 0xa908f54e, 0x8591624f,
1398 0x2c0fb94e, 0xa280ba3c, 0xb6f41b4c, 0x24f9aa47, 0x27201647, 0x3a3ea6dc, 0xa14fc3be, 0x3c34bdd5,
1399 0x5b8d4f5b, 0xaadeaf4b, 0xc71cab50, 0x15697a4c, 0x9a1a734c, 0x2a037d81, 0x2590bd59, 0x48ec2741,
1400 0x53489c5b, 0x7f00314b, 0x2170d362, 0xf2e92542, 0x42c10b44, 0x98f0f118, 0x883a3456, 0x099a932e,
1401 0xea38f7bc, 0x644e9247, 0xbb61b62e, 0x30e0863d, 0x5f51be54, 0x207215c7, 0x5f306c45, 0xaa7f3932,
1402 0x98da7d45, 0x4e339b59, 0x2e411581, 0xa808f618, 0xad2c0c59, 0x54476741, 0x09e99fd1, 0x5db8f752,
1403 0xc16df8bd, 0x1dd4b44f, 0x106edf2e, 0x9e15c180, 0x2ad6b56f, 0x633a5332, 0xff33787c, 0x077cb545,
1404 0x6610be6d, 0x75aad2c4, 0x72fb4d5b, 0xe81e0f59, 0x576f6332, 0x47333373, 0x351ed783, 0x2d90fb50,
1405 0x8d5e0f6c, 0x5b27a552, 0xdb293ebb, 0xe55ef950, 0x4b133ad8, 0x75df975a, 0x7b6a8740, 0xa899464b,
1406 0xfab15161, 0x10f8b64d, 0xd055ea4d, 0xee8e146b, 0x4b14afb8, 0x4bc1c44a, 0x9b961dcc, 0xd111ff43,
1407 0xfca0b745, 0xc800e412, 0x0afad9d1, 0xf751c350, 0xf9f0cccf, 0xa290a545, 0x8ef13763, 0x7ec70d59,
1408 0x2b066acf, 0x65496c45, 0xade02c1b, 0xae6eb077, 0x92c1e65b, 0xc064e6a9, 0xc649e56d, 0x5287a243,
1409 0x36de4f5b, 0x5b1df6ad, 0x65c39a59, 0xdba805b2, 0x20067aa8, 0x6457e56d, 0x3cee26cf, 0xfd3ff26d,
1410 0x04f86d4a, 0x06b8e048, 0xa93bcd5c, 0x91135852, 0xbe90a643, 0x8fa0094d, 0x06d8215f, 0x2677094d,
1411 0xd735685c, 0x164a00c9, 0x5209ac5f, 0xa9564c5c, 0x3b504f5f, 0xcc826bd0, 0x4615042e, 0x5fe13b4a,
1412 0x8c81b86d, 0x879ab68c, 0x1de564b8, 0x434487d8, 0x2dcb1b63, 0x82ab524a, 0xb0676abb, 0xa13d9c62,
1413 0xdbb5b86d, 0x5b7f4b59, 0xaddfb44d, 0xad773532, 0x3997054c, 0x72cebd89, 0xb194544c, 0xc5b8046e,
1414 0x6e1adeb2, 0xaa5abb51, 0xefb54b44, 0x15efc54f, 0xe9f1bc4d, 0x5f401b6c, 0x97f018ad, 0xc82f9252,
1415 0x2cdc762e, 0x8e52e56d, 0x1827175e, 0x9b7d7d80, 0xb2ad6845, 0x51065140, 0x71180a18, 0x5b27006c,
1416 0x0621e255, 0x721cbe58, 0x670c0cb8, 0xf8bd715d, 0xe0bdc5d9, 0xed843501, 0x4b84554d, 0x7f1a18bc,
1417 0x53bcaf47, 0x5729d35f, 0xf0dda246, 0x22382bd0, 0x4d641fb0, 0x316afcde, 0x50a22f1f, 0x73608046,
1418 0xc461d84a, 0xb2dbe247,
1423 void ThreadOpenConnections(void* parg)
1425 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1428 vnThreadsRunning[1]++;
1429 ThreadOpenConnections2(parg);
1430 vnThreadsRunning[1]--;
1432 catch (std::exception& e) {
1433 vnThreadsRunning[1]--;
1434 PrintException(&e, "ThreadOpenConnections()");
1436 vnThreadsRunning[1]--;
1437 PrintException(NULL, "ThreadOpenConnections()");
1439 printf("ThreadOpenConnections exiting\n");
1442 void ThreadOpenConnections2(void* parg)
1444 printf("ThreadOpenConnections started\n");
1446 // Connect to specific addresses
1447 if (mapArgs.count("-connect"))
1449 for (int64 nLoop = 0;; nLoop++)
1451 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1453 CAddress addr(strAddr, fAllowDNS);
1455 OpenNetworkConnection(addr);
1456 for (int i = 0; i < 10 && i < nLoop; i++)
1466 // Connect to manually added nodes first
1467 if (mapArgs.count("-addnode"))
1469 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1471 CAddress addr(strAddr, fAllowDNS);
1474 OpenNetworkConnection(addr);
1482 // Initiate network connections
1483 int64 nStart = GetTime();
1486 vnThreadsRunning[1]--;
1488 vnThreadsRunning[1]++;
1492 // Limit outbound connections
1496 CRITICAL_BLOCK(cs_vNodes)
1497 BOOST_FOREACH(CNode* pnode, vNodes)
1498 if (!pnode->fInbound)
1500 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1501 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1502 if (nOutbound < nMaxOutboundConnections)
1504 vnThreadsRunning[1]--;
1506 vnThreadsRunning[1]++;
1511 bool fAddSeeds = false;
1513 CRITICAL_BLOCK(cs_mapAddresses)
1515 // Add seed nodes if IRC isn't working
1516 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1517 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
1523 for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
1525 // It'll only connect to one or two seed nodes because once it connects,
1526 // it'll get a pile of addresses with newer timestamps.
1527 // Seed nodes are given a random 'last seen time' of between one and two
1529 const int64 nOneWeek = 7*24*60*60;
1531 addr.ip = pnSeed[i];
1532 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1538 // Choose an address to connect to based on most recently seen
1540 CAddress addrConnect;
1541 int64 nBest = INT64_MIN;
1543 // Only connect to one address per a.b.?.? range.
1544 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1545 set<unsigned int> setConnected;
1546 CRITICAL_BLOCK(cs_vNodes)
1547 BOOST_FOREACH(CNode* pnode, vNodes)
1548 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1550 int64 nANow = GetAdjustedTime();
1552 CRITICAL_BLOCK(cs_mapAddresses)
1554 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1556 const CAddress& addr = item.second;
1557 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1559 int64 nSinceLastSeen = nANow - addr.nTime;
1560 int64 nSinceLastTry = nANow - addr.nLastTry;
1562 // Randomize the order in a deterministic way, putting the standard port first
1563 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1564 if (addr.port != htons(GetDefaultPort()))
1565 nRandomizer += 2 * 60 * 60;
1567 // Last seen Base retry frequency
1576 // 365 days 93 hours
1577 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1579 // Fast reconnect for one hour after last seen
1580 if (nSinceLastSeen < 60 * 60)
1583 // Limit retry frequency
1584 if (nSinceLastTry < nDelay)
1587 // If we have IRC, we'll be notified when they first come online,
1588 // and again every 24 hours by the refresh broadcast.
1589 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1592 // Only try the old stuff if we don't have enough connections
1593 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1596 // If multiple addresses are ready, prioritize by time since
1597 // last seen and time since last tried.
1598 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1607 if (addrConnect.IsValid())
1608 OpenNetworkConnection(addrConnect);
1612 bool OpenNetworkConnection(const CAddress& addrConnect)
1615 // Initiate outbound network connection
1619 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
1620 FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
1623 vnThreadsRunning[1]--;
1624 CNode* pnode = ConnectNode(addrConnect);
1625 vnThreadsRunning[1]++;
1630 pnode->fNetworkNode = true;
1642 void ThreadMessageHandler(void* parg)
1644 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1647 vnThreadsRunning[2]++;
1648 ThreadMessageHandler2(parg);
1649 vnThreadsRunning[2]--;
1651 catch (std::exception& e) {
1652 vnThreadsRunning[2]--;
1653 PrintException(&e, "ThreadMessageHandler()");
1655 vnThreadsRunning[2]--;
1656 PrintException(NULL, "ThreadMessageHandler()");
1658 printf("ThreadMessageHandler exiting\n");
1661 void ThreadMessageHandler2(void* parg)
1663 printf("ThreadMessageHandler started\n");
1664 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1667 vector<CNode*> vNodesCopy;
1668 CRITICAL_BLOCK(cs_vNodes)
1670 vNodesCopy = vNodes;
1671 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1675 // Poll the connected nodes for messages
1676 CNode* pnodeTrickle = NULL;
1677 if (!vNodesCopy.empty())
1678 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1679 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1682 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1683 ProcessMessages(pnode);
1688 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1689 SendMessages(pnode, pnode == pnodeTrickle);
1694 CRITICAL_BLOCK(cs_vNodes)
1696 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1700 // Wait and allow messages to bunch up.
1701 // Reduce vnThreadsRunning so StopNode has permission to exit while
1702 // we're sleeping, but we must always check fShutdown after doing this.
1703 vnThreadsRunning[2]--;
1705 if (fRequestShutdown)
1707 vnThreadsRunning[2]++;
1718 bool BindListenPort(string& strError)
1722 addrLocalHost.port = htons(GetListenPort());
1725 // Initialize Windows Sockets
1727 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1728 if (ret != NO_ERROR)
1730 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1731 printf("%s\n", strError.c_str());
1736 // Create socket for listening for incoming connections
1737 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1738 if (hListenSocket == INVALID_SOCKET)
1740 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1741 printf("%s\n", strError.c_str());
1746 // Different way of disabling SIGPIPE on BSD
1747 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1751 // Allow binding if the port is still in TIME_WAIT state after
1752 // the program was closed and restarted. Not an issue on windows.
1753 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1757 // Set to nonblocking, incoming connections will also inherit this
1758 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1760 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1763 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1764 printf("%s\n", strError.c_str());
1768 // The sockaddr_in structure specifies the address family,
1769 // IP address, and port for the socket that is being bound
1770 struct sockaddr_in sockaddr;
1771 memset(&sockaddr, 0, sizeof(sockaddr));
1772 sockaddr.sin_family = AF_INET;
1773 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1774 sockaddr.sin_port = htons(GetListenPort());
1775 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1777 int nErr = WSAGetLastError();
1778 if (nErr == WSAEADDRINUSE)
1779 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1781 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1782 printf("%s\n", strError.c_str());
1785 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1787 // Listen for incoming connections
1788 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1790 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1791 printf("%s\n", strError.c_str());
1798 void StartNode(void* parg)
1800 if (pnodeLocalHost == NULL)
1801 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1804 // Get local host ip
1805 char pszHostName[1000] = "";
1806 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1808 vector<CAddress> vaddr;
1809 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1810 BOOST_FOREACH (const CAddress &addr, vaddr)
1811 if (addr.GetByte(3) != 127)
1813 addrLocalHost = addr;
1818 // Get local host ip
1819 struct ifaddrs* myaddrs;
1820 if (getifaddrs(&myaddrs) == 0)
1822 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1824 if (ifa->ifa_addr == NULL) continue;
1825 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1826 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1827 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1829 if (ifa->ifa_addr->sa_family == AF_INET)
1831 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1832 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1833 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1835 // Take the first IP that isn't loopback 127.x.x.x
1836 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1837 if (addr.IsValid() && addr.GetByte(3) != 127)
1839 addrLocalHost = addr;
1843 else if (ifa->ifa_addr->sa_family == AF_INET6)
1845 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1846 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1847 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1850 freeifaddrs(myaddrs);
1853 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1855 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1857 // Proxies can't take incoming connections
1858 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1859 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1863 CreateThread(ThreadGetMyExternalIP, NULL);
1870 if (GetBoolArg("-nodnsseed"))
1871 printf("DNS seeding disabled\n");
1873 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1874 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1876 // Map ports with UPnP
1880 // Get addresses from IRC and advertise ours
1881 if (!CreateThread(ThreadIRCSeed, NULL))
1882 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1884 // Send and receive from sockets, accept connections
1885 if (!CreateThread(ThreadSocketHandler, NULL))
1886 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1888 // Initiate outbound connections
1889 if (!CreateThread(ThreadOpenConnections, NULL))
1890 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1893 if (!CreateThread(ThreadMessageHandler, NULL))
1894 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1896 // Generate coins in the background
1897 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1902 printf("StopNode()\n");
1904 nTransactionsUpdated++;
1905 int64 nStart = GetTime();
1906 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1908 || vnThreadsRunning[5] > 0
1912 if (GetTime() - nStart > 20)
1916 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1917 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1918 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1919 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1920 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1921 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1922 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1923 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1939 BOOST_FOREACH(CNode* pnode, vNodes)
1940 if (pnode->hSocket != INVALID_SOCKET)
1941 closesocket(pnode->hSocket);
1942 if (hListenSocket != INVALID_SOCKET)
1943 if (closesocket(hListenSocket) == SOCKET_ERROR)
1944 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1947 // Shutdown Windows Sockets
1952 instance_of_cnetcleanup;