1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2012 The Bitcoin developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
18 #include <miniupnpc/miniwget.h>
19 #include <miniupnpc/miniupnpc.h>
20 #include <miniupnpc/upnpcommands.h>
21 #include <miniupnpc/upnperrors.h>
25 using namespace boost;
27 static const int MAX_OUTBOUND_CONNECTIONS = 8;
29 void ThreadMessageHandler2(void* parg);
30 void ThreadSocketHandler2(void* parg);
31 void ThreadOpenConnections2(void* parg);
33 void ThreadMapPort2(void* parg);
35 void ThreadDNSAddressSeed2(void* parg);
36 bool OpenNetworkConnection(const CAddress& addrConnect);
43 // Global state variables
46 bool fAllowDNS = false;
47 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
48 CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
49 static CNode* pnodeLocalHost = NULL;
50 uint64 nLocalHostNonce = 0;
51 array<int, 10> vnThreadsRunning;
52 static SOCKET hListenSocket = INVALID_SOCKET;
54 vector<CNode*> vNodes;
55 CCriticalSection cs_vNodes;
56 map<vector<unsigned char>, CAddress> mapAddresses;
57 CCriticalSection cs_mapAddresses;
58 map<CInv, CDataStream> mapRelay;
59 deque<pair<int64, CInv> > vRelayExpiration;
60 CCriticalSection cs_mapRelay;
61 map<CInv, int64> mapAlreadyAskedFor;
64 int fUseProxy = false;
65 int nConnectTimeout = 5000;
66 CAddress addrProxy("127.0.0.1",9050);
71 unsigned short GetListenPort()
73 return (unsigned short)(GetArg("-port", GetDefaultPort()));
76 void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
78 // Filter out duplicate requests
79 if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
81 pindexLastGetBlocksBegin = pindexBegin;
82 hashLastGetBlocksEnd = hashEnd;
84 PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
91 bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
93 hSocketRet = INVALID_SOCKET;
95 SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
96 if (hSocket == INVALID_SOCKET)
100 setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
103 bool fProxy = (fUseProxy && addrConnect.IsRoutable());
104 struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
107 u_long fNonblock = 1;
108 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
110 int fFlags = fcntl(hSocket, F_GETFL, 0);
111 if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
114 closesocket(hSocket);
119 if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
121 // WSAEINVAL is here because some legacy version of winsock uses it
122 if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
124 struct timeval timeout;
125 timeout.tv_sec = nTimeout / 1000;
126 timeout.tv_usec = (nTimeout % 1000) * 1000;
130 FD_SET(hSocket, &fdset);
131 int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
134 printf("connection timeout\n");
135 closesocket(hSocket);
138 if (nRet == SOCKET_ERROR)
140 printf("select() for connection failed: %i\n",WSAGetLastError());
141 closesocket(hSocket);
144 socklen_t nRetSize = sizeof(nRet);
146 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
148 if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
151 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
152 closesocket(hSocket);
157 printf("connect() failed after select(): %s\n",strerror(nRet));
158 closesocket(hSocket);
163 else if (WSAGetLastError() != WSAEISCONN)
168 printf("connect() failed: %i\n",WSAGetLastError());
169 closesocket(hSocket);
175 this isn't even strictly necessary
176 CNode::ConnectNode immediately turns the socket back to non-blocking
177 but we'll turn it back to blocking just in case
181 if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
183 fFlags = fcntl(hSocket, F_GETFL, 0);
184 if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
187 closesocket(hSocket);
193 printf("proxy connecting %s\n", addrConnect.ToString().c_str());
194 char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
195 memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
196 memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
197 char* pszSocks4 = pszSocks4IP;
198 int nSize = sizeof(pszSocks4IP);
200 int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
203 closesocket(hSocket);
204 return error("Error sending to proxy");
207 if (recv(hSocket, pchRet, 8, 0) != 8)
209 closesocket(hSocket);
210 return error("Error reading proxy response");
212 if (pchRet[1] != 0x5a)
214 closesocket(hSocket);
215 if (pchRet[1] != 0x5b)
216 printf("ERROR: Proxy returned error %d\n", pchRet[1]);
219 printf("proxy connected %s\n", addrConnect.ToString().c_str());
222 hSocketRet = hSocket;
226 // portDefault is in host order
227 bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
232 int port = portDefault;
235 strlcpy(psz, pszName, sizeof(psz));
238 char* pszColon = strrchr(psz+1,':');
239 char *pszPortEnd = NULL;
240 int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
241 if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
243 if (psz[0] == '[' && pszColon[-1] == ']')
245 // Future: enable IPv6 colon-notation inside []
252 if (port < 0 || port > USHRT_MAX)
257 unsigned int addrIP = inet_addr(pszHost);
258 if (addrIP != INADDR_NONE)
260 // valid IP address passed
261 vaddr.push_back(CAddress(addrIP, port, nServices));
268 struct hostent* phostent = gethostbyname(pszHost);
272 if (phostent->h_addrtype != AF_INET)
275 char** ppAddr = phostent->h_addr_list;
276 while (*ppAddr != NULL && vaddr.size() != nMaxSolutions)
278 CAddress addr(((struct in_addr*)ppAddr[0])->s_addr, port, nServices);
280 vaddr.push_back(addr);
284 return (vaddr.size() > 0);
287 // portDefault is in host order
288 bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup, int portDefault, bool fAllowPort)
290 vector<CAddress> vaddr;
291 bool fRet = Lookup(pszName, vaddr, nServices, 1, fAllowLookup, portDefault, fAllowPort);
297 bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet)
300 if (!ConnectSocket(addrConnect, hSocket))
301 return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
303 send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
306 while (RecvLine(hSocket, strLine))
308 if (strLine.empty()) // HTTP response is separated from headers by blank line
312 if (!RecvLine(hSocket, strLine))
314 closesocket(hSocket);
317 if (pszKeyword == NULL)
319 if (strLine.find(pszKeyword) != -1)
321 strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
325 closesocket(hSocket);
326 if (strLine.find("<") != -1)
327 strLine = strLine.substr(0, strLine.find("<"));
328 strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
329 while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
330 strLine.resize(strLine.size()-1);
331 CAddress addr(strLine,0,true);
332 printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
333 if (addr.ip == 0 || addr.ip == INADDR_NONE || !addr.IsRoutable())
339 closesocket(hSocket);
340 return error("GetMyExternalIP() : connection closed");
343 // We now get our external IP from the IRC server first and only use this as a backup
344 bool GetMyExternalIP(unsigned int& ipRet)
346 CAddress addrConnect;
348 const char* pszKeyword;
353 for (int nLookup = 0; nLookup <= 1; nLookup++)
354 for (int nHost = 1; nHost <= 2; nHost++)
356 // We should be phasing out our use of sites like these. If we need
357 // replacements, we should ask for volunteers to put this simple
358 // php file on their webserver that prints the client IP:
359 // <?php echo $_SERVER["REMOTE_ADDR"]; ?>
362 addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
366 CAddress addrIP("checkip.dyndns.org", 80, true);
367 if (addrIP.IsValid())
368 addrConnect = addrIP;
371 pszGet = "GET / HTTP/1.1\r\n"
372 "Host: checkip.dyndns.org\r\n"
373 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
374 "Connection: close\r\n"
377 pszKeyword = "Address:";
381 addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
385 CAddress addrIP("www.showmyip.com", 80, true);
386 if (addrIP.IsValid())
387 addrConnect = addrIP;
390 pszGet = "GET /simple/ HTTP/1.1\r\n"
391 "Host: www.showmyip.com\r\n"
392 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
393 "Connection: close\r\n"
396 pszKeyword = NULL; // Returns just IP address
399 if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
406 void ThreadGetMyExternalIP(void* parg)
408 // Wait for IRC to get it first
409 if (!GetBoolArg("-noirc"))
411 for (int i = 0; i < 2 * 60; i++)
414 if (fGotExternalIP || fShutdown)
419 // Fallback in case IRC fails to get it
420 if (GetMyExternalIP(addrLocalHost.ip))
422 printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
423 if (addrLocalHost.IsRoutable())
425 // If we already connected to a few before we had our IP, go back and addr them.
426 // setAddrKnown automatically filters any duplicate sends.
427 CAddress addr(addrLocalHost);
428 addr.nTime = GetAdjustedTime();
429 CRITICAL_BLOCK(cs_vNodes)
430 BOOST_FOREACH(CNode* pnode, vNodes)
431 pnode->PushAddress(addr);
440 bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
442 if (!addr.IsRoutable())
444 if (addr.ip == addrLocalHost.ip)
446 addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
447 bool fUpdated = false;
449 CAddress addrFound = addr;
451 CRITICAL_BLOCK(cs_mapAddresses)
453 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
454 if (it == mapAddresses.end())
457 printf("AddAddress(%s)\n", addr.ToString().c_str());
458 mapAddresses.insert(make_pair(addr.GetKey(), addr));
464 addrFound = (*it).second;
465 if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
467 // Services have been added
468 addrFound.nServices |= addr.nServices;
471 bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
472 int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
473 if (addrFound.nTime < addr.nTime - nUpdateInterval)
475 // Periodically update most recently seen time
476 addrFound.nTime = addr.nTime;
481 // There is a nasty deadlock bug if this is done inside the cs_mapAddresses
483 // Thread 1: begin db transaction (locks inside-db-mutex)
484 // then AddAddress (locks cs_mapAddresses)
485 // Thread 2: AddAddress (locks cs_mapAddresses)
486 // ... then db operation hangs waiting for inside-db-mutex
490 pAddrDB->WriteAddress(addrFound);
492 CAddrDB().WriteAddress(addrFound);
497 void AddressCurrentlyConnected(const CAddress& addr)
499 CAddress *paddrFound = NULL;
501 CRITICAL_BLOCK(cs_mapAddresses)
503 // Only if it's been published already
504 map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
505 if (it != mapAddresses.end())
506 paddrFound = &(*it).second;
511 int64 nUpdateInterval = 20 * 60;
512 if (paddrFound->nTime < GetAdjustedTime() - nUpdateInterval)
514 // Periodically update most recently seen time
515 paddrFound->nTime = GetAdjustedTime();
517 addrdb.WriteAddress(*paddrFound);
526 void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
528 // If the dialog might get closed before the reply comes back,
529 // call this in the destructor so it doesn't get called after it's deleted.
530 CRITICAL_BLOCK(cs_vNodes)
532 BOOST_FOREACH(CNode* pnode, vNodes)
534 CRITICAL_BLOCK(pnode->cs_mapRequests)
536 for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
538 CRequestTracker& tracker = (*mi).second;
539 if (tracker.fn == fn && tracker.param1 == param1)
540 pnode->mapRequests.erase(mi++);
556 // Subscription methods for the broadcast and subscription system.
557 // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
559 // The subscription system uses a meet-in-the-middle strategy.
560 // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
561 // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
564 bool AnySubscribed(unsigned int nChannel)
566 if (pnodeLocalHost->IsSubscribed(nChannel))
568 CRITICAL_BLOCK(cs_vNodes)
569 BOOST_FOREACH(CNode* pnode, vNodes)
570 if (pnode->IsSubscribed(nChannel))
575 bool CNode::IsSubscribed(unsigned int nChannel)
577 if (nChannel >= vfSubscribe.size())
579 return vfSubscribe[nChannel];
582 void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
584 if (nChannel >= vfSubscribe.size())
587 if (!AnySubscribed(nChannel))
590 CRITICAL_BLOCK(cs_vNodes)
591 BOOST_FOREACH(CNode* pnode, vNodes)
593 pnode->PushMessage("subscribe", nChannel, nHops);
596 vfSubscribe[nChannel] = true;
599 void CNode::CancelSubscribe(unsigned int nChannel)
601 if (nChannel >= vfSubscribe.size())
604 // Prevent from relaying cancel if wasn't subscribed
605 if (!vfSubscribe[nChannel])
607 vfSubscribe[nChannel] = false;
609 if (!AnySubscribed(nChannel))
611 // Relay subscription cancel
612 CRITICAL_BLOCK(cs_vNodes)
613 BOOST_FOREACH(CNode* pnode, vNodes)
615 pnode->PushMessage("sub-cancel", nChannel);
627 CNode* FindNode(unsigned int ip)
629 CRITICAL_BLOCK(cs_vNodes)
631 BOOST_FOREACH(CNode* pnode, vNodes)
632 if (pnode->addr.ip == ip)
638 CNode* FindNode(CAddress addr)
640 CRITICAL_BLOCK(cs_vNodes)
642 BOOST_FOREACH(CNode* pnode, vNodes)
643 if (pnode->addr == addr)
649 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
651 if (addrConnect.ip == addrLocalHost.ip)
654 // Look for an existing connection
655 CNode* pnode = FindNode(addrConnect.ip);
659 pnode->AddRef(nTimeout);
666 printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
667 addrConnect.ToString().c_str(),
668 (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
669 (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
671 CRITICAL_BLOCK(cs_mapAddresses)
672 mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
676 if (ConnectSocket(addrConnect, hSocket))
679 printf("connected %s\n", addrConnect.ToString().c_str());
681 // Set to nonblocking
684 if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
685 printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
687 if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
688 printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
692 CNode* pnode = new CNode(hSocket, addrConnect, false);
694 pnode->AddRef(nTimeout);
697 CRITICAL_BLOCK(cs_vNodes)
698 vNodes.push_back(pnode);
700 pnode->nTimeConnected = GetTime();
709 void CNode::CloseSocketDisconnect()
712 if (hSocket != INVALID_SOCKET)
715 printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
716 printf("disconnecting node %s\n", addr.ToString().c_str());
717 closesocket(hSocket);
718 hSocket = INVALID_SOCKET;
722 void CNode::Cleanup()
724 // All of a nodes broadcasts and subscriptions are automatically torn down
725 // when it goes down, so a node has to stay up to keep its broadcast going.
727 // Cancel subscriptions
728 for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
729 if (vfSubscribe[nChannel])
730 CancelSubscribe(nChannel);
734 std::map<unsigned int, int64> CNode::setBanned;
735 CCriticalSection CNode::cs_setBanned;
737 void CNode::ClearBanned()
742 bool CNode::IsBanned(unsigned int ip)
744 bool fResult = false;
745 CRITICAL_BLOCK(cs_setBanned)
747 std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
748 if (i != setBanned.end())
750 int64 t = (*i).second;
758 bool CNode::Misbehaving(int howmuch)
762 printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
766 nMisbehavior += howmuch;
767 if (nMisbehavior >= GetArg("-banscore", 100))
769 int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
770 CRITICAL_BLOCK(cs_setBanned)
771 if (setBanned[addr.ip] < banTime)
772 setBanned[addr.ip] = banTime;
773 CloseSocketDisconnect();
774 printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
791 void ThreadSocketHandler(void* parg)
793 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
796 vnThreadsRunning[0]++;
797 ThreadSocketHandler2(parg);
798 vnThreadsRunning[0]--;
800 catch (std::exception& e) {
801 vnThreadsRunning[0]--;
802 PrintException(&e, "ThreadSocketHandler()");
804 vnThreadsRunning[0]--;
805 throw; // support pthread_cancel()
807 printf("ThreadSocketHandler exiting\n");
810 void ThreadSocketHandler2(void* parg)
812 printf("ThreadSocketHandler started\n");
813 list<CNode*> vNodesDisconnected;
814 int nPrevNodeCount = 0;
821 CRITICAL_BLOCK(cs_vNodes)
823 // Disconnect unused nodes
824 vector<CNode*> vNodesCopy = vNodes;
825 BOOST_FOREACH(CNode* pnode, vNodesCopy)
827 if (pnode->fDisconnect ||
828 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
830 // remove from vNodes
831 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
833 // close socket and cleanup
834 pnode->CloseSocketDisconnect();
837 // hold in disconnected pool until all refs are released
838 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
839 if (pnode->fNetworkNode || pnode->fInbound)
841 vNodesDisconnected.push_back(pnode);
845 // Delete disconnected nodes
846 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
847 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
849 // wait until threads are done using it
850 if (pnode->GetRefCount() <= 0)
852 bool fDelete = false;
853 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
854 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
855 TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
856 TRY_CRITICAL_BLOCK(pnode->cs_inventory)
860 vNodesDisconnected.remove(pnode);
866 if (vNodes.size() != nPrevNodeCount)
868 nPrevNodeCount = vNodes.size();
874 // Find which sockets have data to receive
876 struct timeval timeout;
878 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
885 FD_ZERO(&fdsetError);
886 SOCKET hSocketMax = 0;
888 if(hListenSocket != INVALID_SOCKET)
889 FD_SET(hListenSocket, &fdsetRecv);
890 hSocketMax = max(hSocketMax, hListenSocket);
891 CRITICAL_BLOCK(cs_vNodes)
893 BOOST_FOREACH(CNode* pnode, vNodes)
895 if (pnode->hSocket == INVALID_SOCKET)
897 FD_SET(pnode->hSocket, &fdsetRecv);
898 FD_SET(pnode->hSocket, &fdsetError);
899 hSocketMax = max(hSocketMax, pnode->hSocket);
900 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
901 if (!pnode->vSend.empty())
902 FD_SET(pnode->hSocket, &fdsetSend);
906 vnThreadsRunning[0]--;
907 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
908 vnThreadsRunning[0]++;
911 if (nSelect == SOCKET_ERROR)
913 int nErr = WSAGetLastError();
916 printf("socket select error %d\n", nErr);
917 for (int i = 0; i <= hSocketMax; i++)
918 FD_SET(i, &fdsetRecv);
921 FD_ZERO(&fdsetError);
922 Sleep(timeout.tv_usec/1000);
927 // Accept new connections
929 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
931 struct sockaddr_in sockaddr;
932 socklen_t len = sizeof(sockaddr);
933 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
937 if (hSocket != INVALID_SOCKET)
938 addr = CAddress(sockaddr);
940 CRITICAL_BLOCK(cs_vNodes)
941 BOOST_FOREACH(CNode* pnode, vNodes)
945 if (hSocket == INVALID_SOCKET)
947 if (WSAGetLastError() != WSAEWOULDBLOCK)
948 printf("socket error accept failed: %d\n", WSAGetLastError());
950 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
952 closesocket(hSocket);
954 else if (CNode::IsBanned(addr.ip))
956 printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
957 closesocket(hSocket);
961 printf("accepted connection %s\n", addr.ToString().c_str());
962 CNode* pnode = new CNode(hSocket, addr, true);
964 CRITICAL_BLOCK(cs_vNodes)
965 vNodes.push_back(pnode);
971 // Service each socket
973 vector<CNode*> vNodesCopy;
974 CRITICAL_BLOCK(cs_vNodes)
977 BOOST_FOREACH(CNode* pnode, vNodesCopy)
980 BOOST_FOREACH(CNode* pnode, vNodesCopy)
988 if (pnode->hSocket == INVALID_SOCKET)
990 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
992 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
994 CDataStream& vRecv = pnode->vRecv;
995 unsigned int nPos = vRecv.size();
997 if (nPos > ReceiveBufferSize()) {
998 if (!pnode->fDisconnect)
999 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
1000 pnode->CloseSocketDisconnect();
1003 // typical socket buffer is 8K-64K
1004 char pchBuf[0x10000];
1005 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1008 vRecv.resize(nPos + nBytes);
1009 memcpy(&vRecv[nPos], pchBuf, nBytes);
1010 pnode->nLastRecv = GetTime();
1012 else if (nBytes == 0)
1014 // socket closed gracefully
1015 if (!pnode->fDisconnect)
1016 printf("socket closed\n");
1017 pnode->CloseSocketDisconnect();
1019 else if (nBytes < 0)
1022 int nErr = WSAGetLastError();
1023 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1025 if (!pnode->fDisconnect)
1026 printf("socket recv error %d\n", nErr);
1027 pnode->CloseSocketDisconnect();
1037 if (pnode->hSocket == INVALID_SOCKET)
1039 if (FD_ISSET(pnode->hSocket, &fdsetSend))
1041 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1043 CDataStream& vSend = pnode->vSend;
1046 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
1049 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
1050 pnode->nLastSend = GetTime();
1052 else if (nBytes < 0)
1055 int nErr = WSAGetLastError();
1056 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1058 printf("socket send error %d\n", nErr);
1059 pnode->CloseSocketDisconnect();
1062 if (vSend.size() > SendBufferSize()) {
1063 if (!pnode->fDisconnect)
1064 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
1065 pnode->CloseSocketDisconnect();
1072 // Inactivity checking
1074 if (pnode->vSend.empty())
1075 pnode->nLastSendEmpty = GetTime();
1076 if (GetTime() - pnode->nTimeConnected > 60)
1078 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1080 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
1081 pnode->fDisconnect = true;
1083 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
1085 printf("socket not sending\n");
1086 pnode->fDisconnect = true;
1088 else if (GetTime() - pnode->nLastRecv > 90*60)
1090 printf("socket inactivity timeout\n");
1091 pnode->fDisconnect = true;
1095 CRITICAL_BLOCK(cs_vNodes)
1097 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1114 void ThreadMapPort(void* parg)
1116 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
1119 vnThreadsRunning[5]++;
1120 ThreadMapPort2(parg);
1121 vnThreadsRunning[5]--;
1123 catch (std::exception& e) {
1124 vnThreadsRunning[5]--;
1125 PrintException(&e, "ThreadMapPort()");
1127 vnThreadsRunning[5]--;
1128 PrintException(NULL, "ThreadMapPort()");
1130 printf("ThreadMapPort exiting\n");
1133 void ThreadMapPort2(void* parg)
1135 printf("ThreadMapPort started\n");
1138 sprintf(port, "%d", GetListenPort());
1140 const char * multicastif = 0;
1141 const char * minissdpdpath = 0;
1142 struct UPNPDev * devlist = 0;
1145 #ifndef UPNPDISCOVER_SUCCESS
1147 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1151 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1154 struct UPNPUrls urls;
1155 struct IGDdatas data;
1158 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1161 if (!addrLocalHost.IsRoutable())
1163 char externalIPAddress[40];
1164 r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1165 if(r != UPNPCOMMAND_SUCCESS)
1166 printf("UPnP: GetExternalIPAddress() returned %d\n", r);
1169 if(externalIPAddress[0])
1171 printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1172 CAddress addrExternalFromUPnP(externalIPAddress, 0, false, nLocalServices);
1173 if (addrExternalFromUPnP.IsRoutable())
1174 addrLocalHost = addrExternalFromUPnP;
1177 printf("UPnP: GetExternalIPAddress failed.\n");
1181 string strDesc = "Bitcoin " + FormatFullVersion();
1182 #ifndef UPNPDISCOVER_SUCCESS
1184 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1185 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1188 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1189 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1192 if(r!=UPNPCOMMAND_SUCCESS)
1193 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1194 port, port, lanaddr, r, strupnperror(r));
1196 printf("UPnP Port Mapping successful.\n");
1199 if (fShutdown || !fUseUPnP)
1201 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
1202 printf("UPNP_DeletePortMapping() returned : %d\n", r);
1203 freeUPNPDevlist(devlist); devlist = 0;
1204 FreeUPNPUrls(&urls);
1207 if (i % 600 == 0) // Refresh every 20 minutes
1209 #ifndef UPNPDISCOVER_SUCCESS
1211 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1212 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
1215 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1216 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
1219 if(r!=UPNPCOMMAND_SUCCESS)
1220 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1221 port, port, lanaddr, r, strupnperror(r));
1223 printf("UPnP Port Mapping successful.\n");;
1229 printf("No valid UPnP IGDs found\n");
1230 freeUPNPDevlist(devlist); devlist = 0;
1232 FreeUPNPUrls(&urls);
1234 if (fShutdown || !fUseUPnP)
1241 void MapPort(bool fMapPort)
1243 if (fUseUPnP != fMapPort)
1245 fUseUPnP = fMapPort;
1246 WriteSetting("fUseUPnP", fUseUPnP);
1248 if (fUseUPnP && vnThreadsRunning[5] < 1)
1250 if (!CreateThread(ThreadMapPort, NULL))
1251 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
1255 void MapPort(bool /* unused fMapPort */)
1257 // Intentionally left blank.
1270 static const char *strDNSSeed[] = {
1272 "dnsseed.bluematt.me",
1273 "seed.bitcoin.sipa.be",
1274 "dnsseed.bitcoin.dashjr.org",
1277 void ThreadDNSAddressSeed(void* parg)
1279 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
1282 vnThreadsRunning[6]++;
1283 ThreadDNSAddressSeed2(parg);
1284 vnThreadsRunning[6]--;
1286 catch (std::exception& e) {
1287 vnThreadsRunning[6]--;
1288 PrintException(&e, "ThreadDNSAddressSeed()");
1290 vnThreadsRunning[6]--;
1291 throw; // support pthread_cancel()
1293 printf("ThreadDNSAddressSeed exiting\n");
1296 void ThreadDNSAddressSeed2(void* parg)
1298 printf("ThreadDNSAddressSeed started\n");
1303 printf("Loading addresses from DNS seeds (could take a while)\n");
1305 for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1306 vector<CAddress> vaddr;
1307 if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
1311 BOOST_FOREACH (CAddress& addr, vaddr)
1313 if (addr.GetByte(3) != 127)
1316 AddAddress(addr, 0, &addrDB);
1320 addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
1325 printf("%d addresses found from DNS seeds\n", found);
1339 unsigned int pnSeed[] =
1341 0x959bd347, 0xf8de42b2, 0x73bc0518, 0xea6edc50, 0x21b00a4d, 0xc725b43d, 0xd665464d, 0x1a2a770e,
1342 0x27c93946, 0x65b2fa46, 0xb80ae255, 0x66b3b446, 0xb1877a3e, 0x6ee89e3e, 0xc3175b40, 0x2a01a83c,
1343 0x95b1363a, 0xa079ad3d, 0xe6ca801f, 0x027f4f4a, 0x34f7f03a, 0xf790f04a, 0x16ca801f, 0x2f4d5e40,
1344 0x3a4d5e40, 0xc43a322e, 0xc8159753, 0x14d4724c, 0x7919a118, 0xe0bdb34e, 0x68a16b2e, 0xff64b44d,
1345 0x6099115b, 0x9b57b05b, 0x7bd1b4ad, 0xdf95944f, 0x29d2b73d, 0xafa8db79, 0xe247ba41, 0x24078348,
1346 0xf722f03c, 0x33567ebc, 0xace64ed4, 0x984d3932, 0xb5f34e55, 0x27b7024d, 0x94579247, 0x8894042e,
1347 0x9357d34c, 0x1063c24b, 0xcaa228b1, 0xa3c5a8b2, 0x5dc64857, 0xa2c23643, 0xa8369a54, 0x31203077,
1348 0x00707c5c, 0x09fc0b3a, 0x272e9e2e, 0xf80f043e, 0x9449ca3e, 0x5512c33e, 0xd106b555, 0xe8024157,
1349 0xe288ec29, 0xc79c5461, 0xafb63932, 0xdb02ab4b, 0x0e512777, 0x8a145a4c, 0xb201ff4f, 0x5e09314b,
1350 0xcd9bfbcd, 0x1c023765, 0x4394e75c, 0xa728bd4d, 0x65331552, 0xa98420b1, 0x89ecf559, 0x6e80801f,
1351 0xf404f118, 0xefd62b51, 0x05918346, 0x9b186d5f, 0xacabab46, 0xf912e255, 0xc188ea62, 0xcc55734e,
1352 0xc668064d, 0xd77a4558, 0x46201c55, 0xf17dfc80, 0xf7142f2e, 0x87bfb718, 0x8aa54fb2, 0xc451d518,
1353 0xc4ae8831, 0x8dd44d55, 0x5bbd206c, 0x64536b5d, 0x5c667e60, 0x3b064242, 0xfe963a42, 0xa28e6dc8,
1354 0xe8a9604a, 0xc989464e, 0xd124a659, 0x50065140, 0xa44dfe5e, 0x1079e655, 0x3fb986d5, 0x47895b18,
1355 0x7d3ce4ad, 0x4561ba50, 0x296eec62, 0x255b41ad, 0xaed35ec9, 0x55556f12, 0xc7d3154d, 0x3297b65d,
1356 0x8930121f, 0xabf42e4e, 0x4a29e044, 0x1212685d, 0x676c1e40, 0xce009744, 0x383a8948, 0xa2dbd0ad,
1357 0xecc2564d, 0x07dbc252, 0x887ee24b, 0x5171644c, 0x6bb798c1, 0x847f495d, 0x4cbb7145, 0x3bb81c32,
1358 0x45eb262e, 0xc8015a4e, 0x250a361b, 0xf694f946, 0xd64a183e, 0xd4f1dd59, 0x8f20ffd4, 0x51d9e55c,
1359 0x09521763, 0x5e02002e, 0x32c8074d, 0xe685762e, 0x8290b0bc, 0x762a922e, 0xfc5ee754, 0x83a24829,
1360 0x775b224d, 0x6295bb4d, 0x38ec0555, 0xbffbba50, 0xe5560260, 0x86b16a7c, 0xd372234e, 0x49a3c24b,
1361 0x2f6a171f, 0x4d75ed60, 0xae94115b, 0xcb543744, 0x63080c59, 0x3f9c724c, 0xc977ce18, 0x532efb18,
1362 0x69dc3b2e, 0x5f94d929, 0x1732bb4d, 0x9c814b4d, 0xe6b3762e, 0xc024f662, 0x8face35b, 0x6b5b044d,
1363 0x798c7b57, 0x79a6b44c, 0x067d3057, 0xf9e94e5f, 0x91cbe15b, 0x71405eb2, 0x2662234e, 0xcbcc4a6d,
1364 0xbf69d54b, 0xa79b4e55, 0xec6d3e51, 0x7c0b3c02, 0x60f83653, 0x24c1e15c, 0x1110b62e, 0x10350f59,
1365 0xa56f1d55, 0x3509e7a9, 0xeb128354, 0x14268e2e, 0x934e28bc, 0x8e32692e, 0x8331a21f, 0x3e633932,
1366 0xc812b12e, 0xc684bf2e, 0x80112d2e, 0xe0ddc96c, 0xc630ca4a, 0x5c09b3b2, 0x0b580518, 0xc8e9d54b,
1367 0xd169aa43, 0x17d0d655, 0x1d029963, 0x7ff87559, 0xcb701f1f, 0x6fa3e85d, 0xe45e9a54, 0xf05d1802,
1368 0x44d03b2e, 0x837b692e, 0xccd4354e, 0x3d6da13c, 0x3423084d, 0xf707c34a, 0x55f6db3a, 0xad26e442,
1369 0x6233a21f, 0x09e80e59, 0x8caeb54d, 0xbe870941, 0xb407d20e, 0x20b51018, 0x56fb152e, 0x460d2a4e,
1370 0xbb9a2946, 0x560eb12e, 0xed83dd29, 0xd6724f53, 0xa50aafb8, 0x451346d9, 0x88348e2e, 0x7312fead,
1371 0x8ecaf96f, 0x1bda4e5f, 0xf1671e40, 0x3c8c3e3b, 0x4716324d, 0xdde24ede, 0xf98cd17d, 0xa91d4644,
1372 0x28124eb2, 0x147d5129, 0xd022042e, 0x61733d3b, 0xad0d5e02, 0x8ce2932e, 0xe5c18502, 0x549c1e32,
1373 0x9685801f, 0x86e217ad, 0xd948214b, 0x4110f462, 0x3a2e894e, 0xbd35492e, 0x87e0d558, 0x64b8ef7d,
1374 0x7c3eb962, 0x72a84b3e, 0x7cd667c9, 0x28370a2e, 0x4bc60e7b, 0x6fc1ec60, 0x14a6983f, 0x86739a4b,
1375 0x46954e5f, 0x32e2e15c, 0x2e9326cf, 0xe5801c5e, 0x379607b2, 0x32151145, 0xf0e39744, 0xacb54c55,
1376 0xa37dfb60, 0x83b55cc9, 0x388f7ca5, 0x15034f5f, 0x3e94965b, 0x68e0ffad, 0x35280f59, 0x8fe190cf,
1377 0x7c6ba5b2, 0xa5e9db43, 0x4ee1fc60, 0xd9d94e5f, 0x04040677, 0x0ea9b35e, 0x5961f14f, 0x67fda063,
1378 0xa48a5a31, 0xc6524e55, 0x283d325e, 0x3f37515f, 0x96b94b3e, 0xacce620e, 0x6481cc5b, 0xa4a06d4b,
1379 0x9e95d2d9, 0xe40c03d5, 0xc2f4514b, 0xb79aad44, 0xf64be843, 0xb2064070, 0xfca00455, 0x429dfa4e,
1380 0x2323f173, 0xeda4185e, 0xabd5227d, 0x9efd4d58, 0xb1104758, 0x4811e955, 0xbd9ab355, 0xe921f44b,
1381 0x9f166dce, 0x09e279b2, 0xe0c9ac7b, 0x7901a5ad, 0xa145d4b0, 0x79104671, 0xec31e35a, 0x4fe0b555,
1382 0xc7d9cbad, 0xad057f55, 0xe94cc759, 0x7fe0b043, 0xe4529f2e, 0x0d4dd4b2, 0x9f11a54d, 0x031e2e4e,
1383 0xe6014f5f, 0x11d1ca6c, 0x26bd7f61, 0xeb86854f, 0x4d347b57, 0x116bbe2e, 0xdba7234e, 0x7bcbfd2e,
1384 0x174dd4b2, 0x6686762e, 0xb089ba50, 0xc6258246, 0x087e767b, 0xc4a8cb4a, 0x595dba50, 0x7f0ae502,
1385 0x7b1dbd5a, 0xa0603492, 0x57d1af4b, 0x9e21ffd4, 0x6393064d, 0x7407376e, 0xe484762e, 0x122a4e53,
1386 0x4a37aa43, 0x3888a6be, 0xee77864e, 0x039c8dd5, 0x688d89af, 0x0e988f62, 0x08218246, 0xfc2f8246,
1387 0xd1d97040, 0xd64cd4b2, 0x5ae4a6b8, 0x7d0de9bc, 0x8d304d61, 0x06c5c672, 0xa4c8bd4d, 0xe0fd373b,
1388 0x575ebe4d, 0x72d26277, 0x55570f55, 0x77b154d9, 0xe214293a, 0xfc740f4b, 0xfe3f6a57, 0xa9c55f02,
1389 0xae4054db, 0x2394d918, 0xb511b24a, 0xb8741ab2, 0x0758e65e, 0xc7b5795b, 0xb0a30a4c, 0xaf7f170c,
1390 0xf3b4762e, 0x8179576d, 0x738a1581, 0x4b95b64c, 0x9829b618, 0x1bea932e, 0x7bdeaa4b, 0xcb5e0281,
1391 0x65618f54, 0x0658474b, 0x27066acf, 0x40556d65, 0x7d204d53, 0xf28bc244, 0xdce23455, 0xadc0ff54,
1392 0x3863c948, 0xcee34e5f, 0xdeb85e02, 0x2ed17a61, 0x6a7b094d, 0x7f0cfc40, 0x59603f54, 0x3220afbc,
1393 0xb5dfd962, 0x125d21c0, 0x13f8d243, 0xacfefb4e, 0x86c2c147, 0x3d8bbd59, 0xbd02a21f, 0x2593042e,
1394 0xc6a17a7c, 0x28925861, 0xb487ed44, 0xb5f4fd6d, 0x90c28a45, 0x5a14f74d, 0x43d71b4c, 0x728ebb5d,
1395 0x885bf950, 0x08134dd0, 0x38ec046e, 0xc575684b, 0x50082d2e, 0xa2f47757, 0x270f86ae, 0xf3ff6462,
1396 0x10ed3f4e, 0x4b58d462, 0xe01ce23e, 0x8c5b092e, 0x63e52f4e, 0x22c1e85d, 0xa908f54e, 0x8591624f,
1397 0x2c0fb94e, 0xa280ba3c, 0xb6f41b4c, 0x24f9aa47, 0x27201647, 0x3a3ea6dc, 0xa14fc3be, 0x3c34bdd5,
1398 0x5b8d4f5b, 0xaadeaf4b, 0xc71cab50, 0x15697a4c, 0x9a1a734c, 0x2a037d81, 0x2590bd59, 0x48ec2741,
1399 0x53489c5b, 0x7f00314b, 0x2170d362, 0xf2e92542, 0x42c10b44, 0x98f0f118, 0x883a3456, 0x099a932e,
1400 0xea38f7bc, 0x644e9247, 0xbb61b62e, 0x30e0863d, 0x5f51be54, 0x207215c7, 0x5f306c45, 0xaa7f3932,
1401 0x98da7d45, 0x4e339b59, 0x2e411581, 0xa808f618, 0xad2c0c59, 0x54476741, 0x09e99fd1, 0x5db8f752,
1402 0xc16df8bd, 0x1dd4b44f, 0x106edf2e, 0x9e15c180, 0x2ad6b56f, 0x633a5332, 0xff33787c, 0x077cb545,
1403 0x6610be6d, 0x75aad2c4, 0x72fb4d5b, 0xe81e0f59, 0x576f6332, 0x47333373, 0x351ed783, 0x2d90fb50,
1404 0x8d5e0f6c, 0x5b27a552, 0xdb293ebb, 0xe55ef950, 0x4b133ad8, 0x75df975a, 0x7b6a8740, 0xa899464b,
1405 0xfab15161, 0x10f8b64d, 0xd055ea4d, 0xee8e146b, 0x4b14afb8, 0x4bc1c44a, 0x9b961dcc, 0xd111ff43,
1406 0xfca0b745, 0xc800e412, 0x0afad9d1, 0xf751c350, 0xf9f0cccf, 0xa290a545, 0x8ef13763, 0x7ec70d59,
1407 0x2b066acf, 0x65496c45, 0xade02c1b, 0xae6eb077, 0x92c1e65b, 0xc064e6a9, 0xc649e56d, 0x5287a243,
1408 0x36de4f5b, 0x5b1df6ad, 0x65c39a59, 0xdba805b2, 0x20067aa8, 0x6457e56d, 0x3cee26cf, 0xfd3ff26d,
1409 0x04f86d4a, 0x06b8e048, 0xa93bcd5c, 0x91135852, 0xbe90a643, 0x8fa0094d, 0x06d8215f, 0x2677094d,
1410 0xd735685c, 0x164a00c9, 0x5209ac5f, 0xa9564c5c, 0x3b504f5f, 0xcc826bd0, 0x4615042e, 0x5fe13b4a,
1411 0x8c81b86d, 0x879ab68c, 0x1de564b8, 0x434487d8, 0x2dcb1b63, 0x82ab524a, 0xb0676abb, 0xa13d9c62,
1412 0xdbb5b86d, 0x5b7f4b59, 0xaddfb44d, 0xad773532, 0x3997054c, 0x72cebd89, 0xb194544c, 0xc5b8046e,
1413 0x6e1adeb2, 0xaa5abb51, 0xefb54b44, 0x15efc54f, 0xe9f1bc4d, 0x5f401b6c, 0x97f018ad, 0xc82f9252,
1414 0x2cdc762e, 0x8e52e56d, 0x1827175e, 0x9b7d7d80, 0xb2ad6845, 0x51065140, 0x71180a18, 0x5b27006c,
1415 0x0621e255, 0x721cbe58, 0x670c0cb8, 0xf8bd715d, 0xe0bdc5d9, 0xed843501, 0x4b84554d, 0x7f1a18bc,
1416 0x53bcaf47, 0x5729d35f, 0xf0dda246, 0x22382bd0, 0x4d641fb0, 0x316afcde, 0x50a22f1f, 0x73608046,
1417 0xc461d84a, 0xb2dbe247,
1422 void ThreadOpenConnections(void* parg)
1424 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1427 vnThreadsRunning[1]++;
1428 ThreadOpenConnections2(parg);
1429 vnThreadsRunning[1]--;
1431 catch (std::exception& e) {
1432 vnThreadsRunning[1]--;
1433 PrintException(&e, "ThreadOpenConnections()");
1435 vnThreadsRunning[1]--;
1436 PrintException(NULL, "ThreadOpenConnections()");
1438 printf("ThreadOpenConnections exiting\n");
1441 void ThreadOpenConnections2(void* parg)
1443 printf("ThreadOpenConnections started\n");
1445 // Connect to specific addresses
1446 if (mapArgs.count("-connect"))
1448 for (int64 nLoop = 0;; nLoop++)
1450 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1452 CAddress addr(strAddr, fAllowDNS);
1454 OpenNetworkConnection(addr);
1455 for (int i = 0; i < 10 && i < nLoop; i++)
1465 // Connect to manually added nodes first
1466 if (mapArgs.count("-addnode"))
1468 BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
1470 CAddress addr(strAddr, fAllowDNS);
1473 OpenNetworkConnection(addr);
1481 // Initiate network connections
1482 int64 nStart = GetTime();
1485 vnThreadsRunning[1]--;
1487 vnThreadsRunning[1]++;
1491 // Limit outbound connections
1495 CRITICAL_BLOCK(cs_vNodes)
1496 BOOST_FOREACH(CNode* pnode, vNodes)
1497 if (!pnode->fInbound)
1499 int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
1500 nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
1501 if (nOutbound < nMaxOutboundConnections)
1503 vnThreadsRunning[1]--;
1505 vnThreadsRunning[1]++;
1510 bool fAddSeeds = false;
1512 CRITICAL_BLOCK(cs_mapAddresses)
1514 // Add seed nodes if IRC isn't working
1515 bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
1516 if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
1522 for (int i = 0; i < ARRAYLEN(pnSeed); i++)
1524 // It'll only connect to one or two seed nodes because once it connects,
1525 // it'll get a pile of addresses with newer timestamps.
1526 // Seed nodes are given a random 'last seen time' of between one and two
1528 const int64 nOneWeek = 7*24*60*60;
1530 addr.ip = pnSeed[i];
1531 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1537 // Choose an address to connect to based on most recently seen
1539 CAddress addrConnect;
1540 int64 nBest = INT64_MIN;
1542 // Only connect to one address per a.b.?.? range.
1543 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1544 set<unsigned int> setConnected;
1545 CRITICAL_BLOCK(cs_vNodes)
1546 BOOST_FOREACH(CNode* pnode, vNodes)
1547 setConnected.insert(pnode->addr.ip & 0x0000ffff);
1549 int64 nANow = GetAdjustedTime();
1551 CRITICAL_BLOCK(cs_mapAddresses)
1553 BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
1555 const CAddress& addr = item.second;
1556 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
1558 int64 nSinceLastSeen = nANow - addr.nTime;
1559 int64 nSinceLastTry = nANow - addr.nLastTry;
1561 // Randomize the order in a deterministic way, putting the standard port first
1562 int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
1563 if (addr.port != htons(GetDefaultPort()))
1564 nRandomizer += 2 * 60 * 60;
1566 // Last seen Base retry frequency
1575 // 365 days 93 hours
1576 int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
1578 // Fast reconnect for one hour after last seen
1579 if (nSinceLastSeen < 60 * 60)
1582 // Limit retry frequency
1583 if (nSinceLastTry < nDelay)
1586 // If we have IRC, we'll be notified when they first come online,
1587 // and again every 24 hours by the refresh broadcast.
1588 if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
1591 // Only try the old stuff if we don't have enough connections
1592 if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
1595 // If multiple addresses are ready, prioritize by time since
1596 // last seen and time since last tried.
1597 int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
1606 if (addrConnect.IsValid())
1607 OpenNetworkConnection(addrConnect);
1611 bool OpenNetworkConnection(const CAddress& addrConnect)
1614 // Initiate outbound network connection
1618 if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
1619 FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
1622 vnThreadsRunning[1]--;
1623 CNode* pnode = ConnectNode(addrConnect);
1624 vnThreadsRunning[1]++;
1629 pnode->fNetworkNode = true;
1641 void ThreadMessageHandler(void* parg)
1643 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1646 vnThreadsRunning[2]++;
1647 ThreadMessageHandler2(parg);
1648 vnThreadsRunning[2]--;
1650 catch (std::exception& e) {
1651 vnThreadsRunning[2]--;
1652 PrintException(&e, "ThreadMessageHandler()");
1654 vnThreadsRunning[2]--;
1655 PrintException(NULL, "ThreadMessageHandler()");
1657 printf("ThreadMessageHandler exiting\n");
1660 void ThreadMessageHandler2(void* parg)
1662 printf("ThreadMessageHandler started\n");
1663 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1666 vector<CNode*> vNodesCopy;
1667 CRITICAL_BLOCK(cs_vNodes)
1669 vNodesCopy = vNodes;
1670 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1674 // Poll the connected nodes for messages
1675 CNode* pnodeTrickle = NULL;
1676 if (!vNodesCopy.empty())
1677 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1678 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1681 TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
1682 ProcessMessages(pnode);
1687 TRY_CRITICAL_BLOCK(pnode->cs_vSend)
1688 SendMessages(pnode, pnode == pnodeTrickle);
1693 CRITICAL_BLOCK(cs_vNodes)
1695 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1699 // Wait and allow messages to bunch up.
1700 // Reduce vnThreadsRunning so StopNode has permission to exit while
1701 // we're sleeping, but we must always check fShutdown after doing this.
1702 vnThreadsRunning[2]--;
1704 if (fRequestShutdown)
1706 vnThreadsRunning[2]++;
1717 bool BindListenPort(string& strError)
1721 addrLocalHost.port = htons(GetListenPort());
1724 // Initialize Windows Sockets
1726 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1727 if (ret != NO_ERROR)
1729 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1730 printf("%s\n", strError.c_str());
1735 // Create socket for listening for incoming connections
1736 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1737 if (hListenSocket == INVALID_SOCKET)
1739 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1740 printf("%s\n", strError.c_str());
1745 // Different way of disabling SIGPIPE on BSD
1746 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1750 // Allow binding if the port is still in TIME_WAIT state after
1751 // the program was closed and restarted. Not an issue on windows.
1752 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1756 // Set to nonblocking, incoming connections will also inherit this
1757 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1759 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1762 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1763 printf("%s\n", strError.c_str());
1767 // The sockaddr_in structure specifies the address family,
1768 // IP address, and port for the socket that is being bound
1769 struct sockaddr_in sockaddr;
1770 memset(&sockaddr, 0, sizeof(sockaddr));
1771 sockaddr.sin_family = AF_INET;
1772 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1773 sockaddr.sin_port = htons(GetListenPort());
1774 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1776 int nErr = WSAGetLastError();
1777 if (nErr == WSAEADDRINUSE)
1778 strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
1780 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1781 printf("%s\n", strError.c_str());
1784 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1786 // Listen for incoming connections
1787 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1789 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1790 printf("%s\n", strError.c_str());
1797 void StartNode(void* parg)
1799 if (pnodeLocalHost == NULL)
1800 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
1803 // Get local host ip
1804 char pszHostName[1000] = "";
1805 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1807 vector<CAddress> vaddr;
1808 if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
1809 BOOST_FOREACH (const CAddress &addr, vaddr)
1810 if (addr.GetByte(3) != 127)
1812 addrLocalHost = addr;
1817 // Get local host ip
1818 struct ifaddrs* myaddrs;
1819 if (getifaddrs(&myaddrs) == 0)
1821 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1823 if (ifa->ifa_addr == NULL) continue;
1824 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1825 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1826 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1828 if (ifa->ifa_addr->sa_family == AF_INET)
1830 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1831 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1832 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1834 // Take the first IP that isn't loopback 127.x.x.x
1835 CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
1836 if (addr.IsValid() && addr.GetByte(3) != 127)
1838 addrLocalHost = addr;
1842 else if (ifa->ifa_addr->sa_family == AF_INET6)
1844 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1845 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1846 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1849 freeifaddrs(myaddrs);
1852 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1854 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1856 // Proxies can't take incoming connections
1857 addrLocalHost.ip = CAddress("0.0.0.0").ip;
1858 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1862 CreateThread(ThreadGetMyExternalIP, NULL);
1869 if (GetBoolArg("-nodnsseed"))
1870 printf("DNS seeding disabled\n");
1872 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1873 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1875 // Map ports with UPnP
1879 // Get addresses from IRC and advertise ours
1880 if (!CreateThread(ThreadIRCSeed, NULL))
1881 printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1883 // Send and receive from sockets, accept connections
1884 if (!CreateThread(ThreadSocketHandler, NULL))
1885 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1887 // Initiate outbound connections
1888 if (!CreateThread(ThreadOpenConnections, NULL))
1889 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1892 if (!CreateThread(ThreadMessageHandler, NULL))
1893 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1895 // Generate coins in the background
1896 GenerateBitcoins(fGenerateBitcoins, pwalletMain);
1901 printf("StopNode()\n");
1903 nTransactionsUpdated++;
1904 int64 nStart = GetTime();
1905 while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
1907 || vnThreadsRunning[5] > 0
1911 if (GetTime() - nStart > 20)
1915 if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
1916 if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
1917 if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
1918 if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
1919 if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
1920 if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
1921 if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
1922 while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
1938 BOOST_FOREACH(CNode* pnode, vNodes)
1939 if (pnode->hSocket != INVALID_SOCKET)
1940 closesocket(pnode->hSocket);
1941 if (hListenSocket != INVALID_SOCKET)
1942 if (closesocket(hListenSocket) == SOCKET_ERROR)
1943 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1946 // Shutdown Windows Sockets
1951 instance_of_cnetcleanup;