1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2012 The Bitcoin developers
3 // Copyright (c) 2011-2012 The PPCoin developers
4 // Distributed under the MIT/X11 software license, see the accompanying
5 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
13 #include "ui_interface.h"
20 #include <miniupnpc/miniwget.h>
21 #include <miniupnpc/miniupnpc.h>
22 #include <miniupnpc/upnpcommands.h>
23 #include <miniupnpc/upnperrors.h>
27 using namespace boost;
29 static const int MAX_OUTBOUND_CONNECTIONS = 8;
31 void ThreadMessageHandler2(void* parg);
32 void ThreadSocketHandler2(void* parg);
33 void ThreadOpenConnections2(void* parg);
34 void ThreadOpenAddedConnections2(void* parg);
36 void ThreadMapPort2(void* parg);
38 void ThreadDNSAddressSeed2(void* parg);
39 bool OpenNetworkConnection(const CAddress& addrConnect, bool fUseGrant = true);
44 // Global state variables
47 bool fAllowDNS = false;
48 static bool fUseUPnP = false;
49 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
50 CAddress addrLocalHost(CService("0.0.0.0", 0), nLocalServices);
51 CAddress addrSeenByPeer(CService("0.0.0.0", 0), nLocalServices);
52 static CNode* pnodeLocalHost = NULL;
53 uint64 nLocalHostNonce = 0;
54 array<int, THREAD_MAX> vnThreadsRunning;
55 static SOCKET hListenSocket = INVALID_SOCKET;
58 vector<CNode*> vNodes;
59 CCriticalSection cs_vNodes;
60 map<CInv, CDataStream> mapRelay;
61 deque<pair<int64, CInv> > vRelayExpiration;
62 CCriticalSection cs_mapRelay;
63 map<CInv, int64> mapAlreadyAskedFor;
66 set<CNetAddr> setservAddNodeAddresses;
67 CCriticalSection cs_setservAddNodeAddresses;
69 static CSemaphore *semOutbound = NULL;
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);
89 bool RecvLine(SOCKET hSocket, string& strLine)
95 int nBytes = recv(hSocket, &c, 1, 0);
103 if (strLine.size() >= 9000)
106 else if (nBytes <= 0)
112 int nErr = WSAGetLastError();
113 if (nErr == WSAEMSGSIZE)
115 if (nErr == WSAEWOULDBLOCK || nErr == WSAEINTR || nErr == WSAEINPROGRESS)
121 if (!strLine.empty())
126 printf("socket closed\n");
132 int nErr = WSAGetLastError();
133 printf("recv failed: %d\n", nErr);
142 bool GetMyExternalIP2(const CService& addrConnect, const char* pszGet, const char* pszKeyword, CNetAddr& ipRet)
145 if (!ConnectSocket(addrConnect, hSocket))
146 return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
148 send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
151 while (RecvLine(hSocket, strLine))
153 if (strLine.empty()) // HTTP response is separated from headers by blank line
157 if (!RecvLine(hSocket, strLine))
159 closesocket(hSocket);
162 if (pszKeyword == NULL)
164 if (strLine.find(pszKeyword) != string::npos)
166 strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
170 closesocket(hSocket);
171 if (strLine.find("<") != string::npos)
172 strLine = strLine.substr(0, strLine.find("<"));
173 strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
174 while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
175 strLine.resize(strLine.size()-1);
176 CService addr(strLine,0,true);
177 printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
178 if (!addr.IsValid() || !addr.IsRoutable())
184 closesocket(hSocket);
185 return error("GetMyExternalIP() : connection closed");
188 // We now get our external IP from the IRC server first and only use this as a backup
189 bool GetMyExternalIP(CNetAddr& ipRet)
191 CService addrConnect;
193 const char* pszKeyword;
195 if (fNoListen||fUseProxy)
198 for (int nLookup = 0; nLookup <= 1; nLookup++)
199 for (int nHost = 1; nHost <= 2; nHost++)
201 // We should be phasing out our use of sites like these. If we need
202 // replacements, we should ask for volunteers to put this simple
203 // php file on their webserver that prints the client IP:
204 // <?php echo $_SERVER["REMOTE_ADDR"]; ?>
207 addrConnect = CService("91.198.22.70",80); // checkip.dyndns.org
211 CService addrIP("checkip.dyndns.org", 80, true);
212 if (addrIP.IsValid())
213 addrConnect = addrIP;
216 pszGet = "GET / HTTP/1.1\r\n"
217 "Host: checkip.dyndns.org\r\n"
218 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
219 "Connection: close\r\n"
222 pszKeyword = "Address:";
226 addrConnect = CService("74.208.43.192", 80); // www.showmyip.com
230 CService addrIP("www.showmyip.com", 80, true);
231 if (addrIP.IsValid())
232 addrConnect = addrIP;
235 pszGet = "GET /simple/ HTTP/1.1\r\n"
236 "Host: www.showmyip.com\r\n"
237 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
238 "Connection: close\r\n"
241 pszKeyword = NULL; // Returns just IP address
244 if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
251 void ThreadGetMyExternalIP(void* parg)
253 // Wait for IRC to get it first - disabled with ppcoin
254 if (false && GetBoolArg("-irc", false))
256 for (int i = 0; i < 2 * 60; i++)
259 if (fGotExternalIP || fShutdown)
264 // Fallback in case IRC fails to get it
265 if (GetMyExternalIP(addrLocalHost))
267 printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
268 if (addrLocalHost.IsRoutable())
270 // If we already connected to a few before we had our IP, go back and addr them.
271 // setAddrKnown automatically filters any duplicate sends.
272 CAddress addr(addrLocalHost);
273 addr.nTime = GetAdjustedTime();
276 BOOST_FOREACH(CNode* pnode, vNodes)
277 pnode->PushAddress(addr);
287 void AddressCurrentlyConnected(const CService& addr)
289 addrman.Connected(addr);
298 CNode* FindNode(const CNetAddr& ip)
302 BOOST_FOREACH(CNode* pnode, vNodes)
303 if ((CNetAddr)pnode->addr == ip)
309 CNode* FindNode(const CService& addr)
313 BOOST_FOREACH(CNode* pnode, vNodes)
314 if ((CService)pnode->addr == addr)
320 CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
322 if ((CNetAddr)addrConnect == (CNetAddr)addrLocalHost)
325 // Look for an existing connection
326 CNode* pnode = FindNode((CService)addrConnect);
330 pnode->AddRef(nTimeout);
337 printf("trying connection %s lastseen=%.1fhrs\n",
338 addrConnect.ToString().c_str(),
339 (double)(addrConnect.nTime - GetAdjustedTime())/3600.0);
341 addrman.Attempt(addrConnect);
345 if (ConnectSocket(addrConnect, hSocket))
348 printf("connected %s\n", addrConnect.ToString().c_str());
350 // Set to nonblocking
353 if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
354 printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
356 if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
357 printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
361 CNode* pnode = new CNode(hSocket, addrConnect, false);
363 pnode->AddRef(nTimeout);
368 vNodes.push_back(pnode);
371 pnode->nTimeConnected = GetTime();
380 void CNode::CloseSocketDisconnect()
383 if (hSocket != INVALID_SOCKET)
386 printf("%s ", DateTimeStrFormat(GetTime()).c_str());
387 printf("disconnecting node %s\n", addr.ToString().c_str());
388 closesocket(hSocket);
389 hSocket = INVALID_SOCKET;
394 void CNode::Cleanup()
399 void CNode::PushVersion()
401 /// when NTP implemented, change to just nTime = GetAdjustedTime()
402 int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
403 CAddress addrYou = (fUseProxy ? CAddress(CService("0.0.0.0",0)) : addr);
404 CAddress addrMe = (fUseProxy || !addrLocalHost.IsRoutable() ? CAddress(CService("0.0.0.0",0)) : addrLocalHost);
405 RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
406 PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
407 nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight);
414 std::map<CNetAddr, int64> CNode::setBanned;
415 CCriticalSection CNode::cs_setBanned;
417 void CNode::ClearBanned()
422 bool CNode::IsBanned(CNetAddr ip)
424 bool fResult = false;
427 std::map<CNetAddr, int64>::iterator i = setBanned.find(ip);
428 if (i != setBanned.end())
430 int64 t = (*i).second;
438 bool CNode::Misbehaving(int howmuch)
442 printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
446 nMisbehavior += howmuch;
447 if (nMisbehavior >= GetArg("-banscore", 100))
449 int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
452 if (setBanned[addr] < banTime)
453 setBanned[addr] = banTime;
455 CloseSocketDisconnect();
456 printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
473 void ThreadSocketHandler(void* parg)
475 IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
478 vnThreadsRunning[THREAD_SOCKETHANDLER]++;
479 ThreadSocketHandler2(parg);
480 vnThreadsRunning[THREAD_SOCKETHANDLER]--;
482 catch (std::exception& e) {
483 vnThreadsRunning[THREAD_SOCKETHANDLER]--;
484 PrintException(&e, "ThreadSocketHandler()");
486 vnThreadsRunning[THREAD_SOCKETHANDLER]--;
487 throw; // support pthread_cancel()
489 printf("ThreadSocketHandler exiting\n");
492 void ThreadSocketHandler2(void* parg)
494 printf("ThreadSocketHandler started\n");
495 list<CNode*> vNodesDisconnected;
496 unsigned int nPrevNodeCount = 0;
505 // Disconnect unused nodes
506 vector<CNode*> vNodesCopy = vNodes;
507 BOOST_FOREACH(CNode* pnode, vNodesCopy)
509 if (pnode->fDisconnect ||
510 (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
512 // remove from vNodes
513 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
515 if (pnode->fHasGrant)
517 pnode->fHasGrant = false;
519 // close socket and cleanup
520 pnode->CloseSocketDisconnect();
523 // hold in disconnected pool until all refs are released
524 pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
525 if (pnode->fNetworkNode || pnode->fInbound)
527 vNodesDisconnected.push_back(pnode);
531 // Delete disconnected nodes
532 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
533 BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
535 // wait until threads are done using it
536 if (pnode->GetRefCount() <= 0)
538 bool fDelete = false;
540 TRY_LOCK(pnode->cs_vSend, lockSend);
543 TRY_LOCK(pnode->cs_vRecv, lockRecv);
546 TRY_LOCK(pnode->cs_mapRequests, lockReq);
549 TRY_LOCK(pnode->cs_inventory, lockInv);
558 vNodesDisconnected.remove(pnode);
564 if (vNodes.size() != nPrevNodeCount)
566 nPrevNodeCount = vNodes.size();
572 // Find which sockets have data to receive
574 struct timeval timeout;
576 timeout.tv_usec = 50000; // frequency to poll pnode->vSend
583 FD_ZERO(&fdsetError);
584 SOCKET hSocketMax = 0;
586 if(hListenSocket != INVALID_SOCKET)
587 FD_SET(hListenSocket, &fdsetRecv);
588 hSocketMax = max(hSocketMax, hListenSocket);
591 BOOST_FOREACH(CNode* pnode, vNodes)
593 if (pnode->hSocket == INVALID_SOCKET)
595 FD_SET(pnode->hSocket, &fdsetRecv);
596 FD_SET(pnode->hSocket, &fdsetError);
597 hSocketMax = max(hSocketMax, pnode->hSocket);
599 TRY_LOCK(pnode->cs_vSend, lockSend);
600 if (lockSend && !pnode->vSend.empty())
601 FD_SET(pnode->hSocket, &fdsetSend);
606 vnThreadsRunning[THREAD_SOCKETHANDLER]--;
607 int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
608 vnThreadsRunning[THREAD_SOCKETHANDLER]++;
611 if (nSelect == SOCKET_ERROR)
613 int nErr = WSAGetLastError();
614 if (hSocketMax != INVALID_SOCKET)
616 printf("socket select error %d\n", nErr);
617 for (unsigned int i = 0; i <= hSocketMax; i++)
618 FD_SET(i, &fdsetRecv);
621 FD_ZERO(&fdsetError);
622 Sleep(timeout.tv_usec/1000);
627 // Accept new connections
629 if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
631 struct sockaddr_in sockaddr;
632 socklen_t len = sizeof(sockaddr);
633 SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
637 if (hSocket != INVALID_SOCKET)
638 addr = CAddress(sockaddr);
642 BOOST_FOREACH(CNode* pnode, vNodes)
647 if (hSocket == INVALID_SOCKET)
649 if (WSAGetLastError() != WSAEWOULDBLOCK)
650 printf("socket error accept failed: %d\n", WSAGetLastError());
652 else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
655 LOCK(cs_setservAddNodeAddresses);
656 if (!setservAddNodeAddresses.count(addr))
657 closesocket(hSocket);
660 else if (CNode::IsBanned(addr))
662 printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
663 closesocket(hSocket);
667 printf("accepted connection %s\n", addr.ToString().c_str());
668 CNode* pnode = new CNode(hSocket, addr, true);
672 vNodes.push_back(pnode);
679 // Service each socket
681 vector<CNode*> vNodesCopy;
685 BOOST_FOREACH(CNode* pnode, vNodesCopy)
688 BOOST_FOREACH(CNode* pnode, vNodesCopy)
696 if (pnode->hSocket == INVALID_SOCKET)
698 if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
700 TRY_LOCK(pnode->cs_vRecv, lockRecv);
703 CDataStream& vRecv = pnode->vRecv;
704 unsigned int nPos = vRecv.size();
706 if (nPos > ReceiveBufferSize()) {
707 if (!pnode->fDisconnect)
708 printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
709 pnode->CloseSocketDisconnect();
712 // typical socket buffer is 8K-64K
713 char pchBuf[0x10000];
714 int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
717 vRecv.resize(nPos + nBytes);
718 memcpy(&vRecv[nPos], pchBuf, nBytes);
719 pnode->nLastRecv = GetTime();
721 else if (nBytes == 0)
723 // socket closed gracefully
724 if (!pnode->fDisconnect)
725 printf("socket closed\n");
726 pnode->CloseSocketDisconnect();
731 int nErr = WSAGetLastError();
732 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
734 if (!pnode->fDisconnect)
735 printf("socket recv error %d\n", nErr);
736 pnode->CloseSocketDisconnect();
746 if (pnode->hSocket == INVALID_SOCKET)
748 if (FD_ISSET(pnode->hSocket, &fdsetSend))
750 TRY_LOCK(pnode->cs_vSend, lockSend);
753 CDataStream& vSend = pnode->vSend;
756 int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
759 vSend.erase(vSend.begin(), vSend.begin() + nBytes);
760 pnode->nLastSend = GetTime();
765 int nErr = WSAGetLastError();
766 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
768 printf("socket send error %d\n", nErr);
769 pnode->CloseSocketDisconnect();
772 if (vSend.size() > SendBufferSize()) {
773 if (!pnode->fDisconnect)
774 printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
775 pnode->CloseSocketDisconnect();
782 // Inactivity checking
784 if (pnode->vSend.empty())
785 pnode->nLastSendEmpty = GetTime();
786 if (GetTime() - pnode->nTimeConnected > 60)
788 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
790 printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
791 pnode->fDisconnect = true;
793 else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
795 printf("socket not sending\n");
796 pnode->fDisconnect = true;
798 else if (GetTime() - pnode->nLastRecv > 90*60)
800 printf("socket inactivity timeout\n");
801 pnode->fDisconnect = true;
807 BOOST_FOREACH(CNode* pnode, vNodesCopy)
824 void ThreadMapPort(void* parg)
826 IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
829 vnThreadsRunning[THREAD_UPNP]++;
830 ThreadMapPort2(parg);
831 vnThreadsRunning[THREAD_UPNP]--;
833 catch (std::exception& e) {
834 vnThreadsRunning[THREAD_UPNP]--;
835 PrintException(&e, "ThreadMapPort()");
837 vnThreadsRunning[THREAD_UPNP]--;
838 PrintException(NULL, "ThreadMapPort()");
840 printf("ThreadMapPort exiting\n");
843 void ThreadMapPort2(void* parg)
845 printf("ThreadMapPort started\n");
848 sprintf(port, "%d", GetListenPort());
850 const char * multicastif = 0;
851 const char * minissdpdpath = 0;
852 struct UPNPDev * devlist = 0;
855 #ifndef UPNPDISCOVER_SUCCESS
857 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
861 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
864 struct UPNPUrls urls;
865 struct IGDdatas data;
868 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
871 if (!addrLocalHost.IsRoutable())
873 char externalIPAddress[40];
874 r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
875 if(r != UPNPCOMMAND_SUCCESS)
876 printf("UPnP: GetExternalIPAddress() returned %d\n", r);
879 if(externalIPAddress[0])
881 printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
882 CAddress addrExternalFromUPnP(CService(externalIPAddress, 0), nLocalServices);
883 if (addrExternalFromUPnP.IsRoutable())
884 addrLocalHost = addrExternalFromUPnP;
887 printf("UPnP: GetExternalIPAddress failed.\n");
891 string strDesc = "PPCoin " + FormatFullVersion();
892 #ifndef UPNPDISCOVER_SUCCESS
894 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
895 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
898 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
899 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
902 if(r!=UPNPCOMMAND_SUCCESS)
903 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
904 port, port, lanaddr, r, strupnperror(r));
906 printf("UPnP Port Mapping successful.\n");
909 if (fShutdown || !fUseUPnP)
911 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
912 printf("UPNP_DeletePortMapping() returned : %d\n", r);
913 freeUPNPDevlist(devlist); devlist = 0;
917 if (i % 600 == 0) // Refresh every 20 minutes
919 #ifndef UPNPDISCOVER_SUCCESS
921 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
922 port, port, lanaddr, strDesc.c_str(), "TCP", 0);
925 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
926 port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
929 if(r!=UPNPCOMMAND_SUCCESS)
930 printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
931 port, port, lanaddr, r, strupnperror(r));
933 printf("UPnP Port Mapping successful.\n");;
939 printf("No valid UPnP IGDs found\n");
940 freeUPNPDevlist(devlist); devlist = 0;
944 if (fShutdown || !fUseUPnP)
951 void MapPort(bool fMapPort)
953 if (fUseUPnP != fMapPort)
957 if (fUseUPnP && vnThreadsRunning[THREAD_UPNP] < 1)
959 if (!CreateThread(ThreadMapPort, NULL))
960 printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
964 void MapPort(bool /* unused fMapPort */)
966 // Intentionally left blank.
979 // Each pair gives a source name and a seed name.
980 // The first name is used as information source for addrman.
981 // The second name should resolve to a list of seed addresses.
982 // testnet dns seed begins with 't', all else are ppcoin dns seeds.
983 static const char *strDNSSeed[][2] = {
984 {"seed", "seed.ppcoin.net"},
985 {"tnseed", "tnseed.ppcoin.net"},
988 void ThreadDNSAddressSeed(void* parg)
990 IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
993 vnThreadsRunning[THREAD_DNSSEED]++;
994 ThreadDNSAddressSeed2(parg);
995 vnThreadsRunning[THREAD_DNSSEED]--;
997 catch (std::exception& e) {
998 vnThreadsRunning[THREAD_DNSSEED]--;
999 PrintException(&e, "ThreadDNSAddressSeed()");
1001 vnThreadsRunning[THREAD_DNSSEED]--;
1002 throw; // support pthread_cancel()
1004 printf("ThreadDNSAddressSeed exiting\n");
1007 void ThreadDNSAddressSeed2(void* parg)
1009 printf("ThreadDNSAddressSeed started\n");
1012 if (true /*!fTestNet*/) // ppcoin enables dns seeding with testnet too
1014 printf("Loading addresses from DNS seeds (could take a while)\n");
1016 for (unsigned int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
1017 if (fTestNet && strDNSSeed[seed_idx][1][0] != 't') continue;
1018 if ((!fTestNet) && strDNSSeed[seed_idx][1][0] == 't') continue;
1020 vector<CNetAddr> vaddr;
1021 vector<CAddress> vAdd;
1022 if (LookupHost(strDNSSeed[seed_idx][1], vaddr))
1024 BOOST_FOREACH(CNetAddr& ip, vaddr)
1026 int nOneDay = 24*3600;
1027 CAddress addr = CAddress(CService(ip, GetDefaultPort()));
1028 addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
1029 vAdd.push_back(addr);
1033 addrman.Add(vAdd, CNetAddr(strDNSSeed[seed_idx][0], true));
1037 printf("%d addresses found from DNS seeds\n", found);
1051 unsigned int pnSeed[] =
1053 0xd749a5bc, 0xf649a5bc,
1056 void DumpAddresses()
1059 adb.WriteAddrman(addrman);
1062 void ThreadDumpAddress2(void* parg)
1064 vnThreadsRunning[THREAD_DUMPADDRESS]++;
1068 vnThreadsRunning[THREAD_DUMPADDRESS]--;
1070 vnThreadsRunning[THREAD_DUMPADDRESS]++;
1072 vnThreadsRunning[THREAD_DUMPADDRESS]--;
1075 void ThreadDumpAddress(void* parg)
1077 IMPLEMENT_RANDOMIZE_STACK(ThreadDumpAddress(parg));
1080 ThreadDumpAddress2(parg);
1082 catch (std::exception& e) {
1083 PrintException(&e, "ThreadDumpAddress()");
1085 printf("ThreadDumpAddress exiting\n");
1088 void ThreadOpenConnections(void* parg)
1090 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
1093 vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
1094 ThreadOpenConnections2(parg);
1095 vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
1097 catch (std::exception& e) {
1098 vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
1099 PrintException(&e, "ThreadOpenConnections()");
1101 vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
1102 PrintException(NULL, "ThreadOpenConnections()");
1104 printf("ThreadOpenConnections exiting\n");
1107 void ThreadOpenConnections2(void* parg)
1109 printf("ThreadOpenConnections started\n");
1111 // Connect to specific addresses
1112 if (mapArgs.count("-connect"))
1114 for (int64 nLoop = 0;; nLoop++)
1116 BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
1118 CAddress addr(CService(strAddr, GetDefaultPort(), fAllowDNS));
1120 OpenNetworkConnection(addr, false);
1121 for (int i = 0; i < 10 && i < nLoop; i++)
1131 // Initiate network connections
1132 int64 nStart = GetTime();
1135 vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
1137 vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
1142 vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
1143 semOutbound->wait();
1144 vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
1148 // Add seed nodes if IRC isn't working
1149 bool fTOR = (fUseProxy && addrProxy.GetPort() == 9050);
1150 if (addrman.size()==0 && (GetTime() - nStart > 60 || fTOR) && !fTestNet)
1152 std::vector<CAddress> vAdd;
1153 for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
1155 // It'll only connect to one or two seed nodes because once it connects,
1156 // it'll get a pile of addresses with newer timestamps.
1157 // Seed nodes are given a random 'last seen time' of between one and two
1159 const int64 nOneWeek = 7*24*60*60;
1161 memcpy(&ip, &pnSeed[i], sizeof(ip));
1162 CAddress addr(CService(ip, GetDefaultPort()));
1163 addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
1164 vAdd.push_back(addr);
1166 addrman.Add(vAdd, CNetAddr("127.0.0.1"));
1170 // Choose an address to connect to based on most recently seen
1172 CAddress addrConnect;
1174 // Only connect to one address per a.b.?.? range.
1175 // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1177 set<vector<unsigned char> > setConnected;
1180 BOOST_FOREACH(CNode* pnode, vNodes) {
1181 setConnected.insert(pnode->addr.GetGroup());
1182 if (!pnode->fInbound)
1187 int64 nANow = GetAdjustedTime();
1192 // use an nUnkBias between 10 (no outgoing connections) and 90 (8 outgoing connections)
1193 CAddress addr = addrman.Select(10 + min(nOutbound,8)*10);
1195 // if we selected an invalid address, restart
1196 if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.GetGroup()) || addr == addrLocalHost)
1201 // only consider very recently tried nodes after 30 failed attempts
1202 if (nANow - addr.nLastTry < 600 && nTries < 30)
1205 // do not allow non-default ports, unless after 50 invalid addresses selected already
1206 if (addr.GetPort() != GetDefaultPort() && nTries < 50)
1213 if (addrConnect.IsValid())
1214 OpenNetworkConnection(addrConnect);
1216 semOutbound->post();
1220 void ThreadOpenAddedConnections(void* parg)
1222 IMPLEMENT_RANDOMIZE_STACK(ThreadOpenAddedConnections(parg));
1225 vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
1226 ThreadOpenAddedConnections2(parg);
1227 vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
1229 catch (std::exception& e) {
1230 vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
1231 PrintException(&e, "ThreadOpenAddedConnections()");
1233 vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
1234 PrintException(NULL, "ThreadOpenAddedConnections()");
1236 printf("ThreadOpenAddedConnections exiting\n");
1239 void ThreadOpenAddedConnections2(void* parg)
1241 printf("ThreadOpenAddedConnections started\n");
1243 if (mapArgs.count("-addnode") == 0)
1246 vector<vector<CService> > vservAddressesToAdd(0);
1247 BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"])
1249 vector<CService> vservNode(0);
1250 if(Lookup(strAddNode.c_str(), vservNode, GetDefaultPort(), fAllowDNS, 0))
1252 vservAddressesToAdd.push_back(vservNode);
1254 LOCK(cs_setservAddNodeAddresses);
1255 BOOST_FOREACH(CService& serv, vservNode)
1256 setservAddNodeAddresses.insert(serv);
1262 vector<vector<CService> > vservConnectAddresses = vservAddressesToAdd;
1263 // Attempt to connect to each IP for each addnode entry until at least one is successful per addnode entry
1264 // (keeping in mind that addnode entries can have many IPs if fAllowDNS)
1267 BOOST_FOREACH(CNode* pnode, vNodes)
1268 for (vector<vector<CService> >::iterator it = vservConnectAddresses.begin(); it != vservConnectAddresses.end(); it++)
1269 BOOST_FOREACH(CService& addrNode, *(it))
1270 if (pnode->addr == addrNode)
1272 it = vservConnectAddresses.erase(it);
1277 BOOST_FOREACH(vector<CService>& vserv, vservConnectAddresses)
1279 semOutbound->wait();
1280 OpenNetworkConnection(CAddress(*(vserv.begin())));
1287 vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
1288 Sleep(120000); // Retry every 2 minutes
1289 vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
1295 bool static ReleaseGrant(bool fUseGrant) {
1297 semOutbound->post();
1301 // only call this function when semOutbound has been waited for
1302 bool OpenNetworkConnection(const CAddress& addrConnect, bool fUseGrant)
1305 // Initiate outbound network connection
1309 if ((CNetAddr)addrConnect == (CNetAddr)addrLocalHost || !addrConnect.IsIPv4() ||
1310 FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect))
1311 return ReleaseGrant(fUseGrant);
1313 vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
1314 CNode* pnode = ConnectNode(addrConnect);
1315 vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
1319 return ReleaseGrant(fUseGrant);
1320 if (pnode->fHasGrant) {
1321 // node already has connection grant, release the one that was passed to us
1322 ReleaseGrant(fUseGrant);
1324 pnode->fHasGrant = fUseGrant;
1326 pnode->fNetworkNode = true;
1338 void ThreadMessageHandler(void* parg)
1340 IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
1343 vnThreadsRunning[THREAD_MESSAGEHANDLER]++;
1344 ThreadMessageHandler2(parg);
1345 vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
1347 catch (std::exception& e) {
1348 vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
1349 PrintException(&e, "ThreadMessageHandler()");
1351 vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
1352 PrintException(NULL, "ThreadMessageHandler()");
1354 printf("ThreadMessageHandler exiting\n");
1357 void ThreadMessageHandler2(void* parg)
1359 printf("ThreadMessageHandler started\n");
1360 SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1363 vector<CNode*> vNodesCopy;
1366 vNodesCopy = vNodes;
1367 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1371 // Poll the connected nodes for messages
1372 CNode* pnodeTrickle = NULL;
1373 if (!vNodesCopy.empty())
1374 pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1375 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1379 TRY_LOCK(pnode->cs_vRecv, lockRecv);
1381 ProcessMessages(pnode);
1388 TRY_LOCK(pnode->cs_vSend, lockSend);
1390 SendMessages(pnode, pnode == pnodeTrickle);
1398 BOOST_FOREACH(CNode* pnode, vNodesCopy)
1402 // Wait and allow messages to bunch up.
1403 // Reduce vnThreadsRunning so StopNode has permission to exit while
1404 // we're sleeping, but we must always check fShutdown after doing this.
1405 vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
1407 if (fRequestShutdown)
1409 vnThreadsRunning[THREAD_MESSAGEHANDLER]++;
1415 // ppcoin: stake minter thread
1416 void static ThreadStakeMinter(void* parg)
1418 printf("ThreadStakeMinter started\n");
1419 CWallet* pwallet = (CWallet*)parg;
1422 vnThreadsRunning[THREAD_MINTER]++;
1423 BitcoinMiner(pwallet, true);
1424 vnThreadsRunning[THREAD_MINTER]--;
1426 catch (std::exception& e) {
1427 vnThreadsRunning[THREAD_MINTER]--;
1428 PrintException(&e, "ThreadStakeMinter()");
1430 vnThreadsRunning[THREAD_MINTER]--;
1431 PrintException(NULL, "ThreadStakeMinter()");
1433 printf("ThreadStakeMinter exiting, %d threads remaining\n", vnThreadsRunning[THREAD_MINTER]);
1441 bool BindListenPort(string& strError)
1445 addrLocalHost.SetPort(GetListenPort());
1448 // Initialize Windows Sockets
1450 int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
1451 if (ret != NO_ERROR)
1453 strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
1454 printf("%s\n", strError.c_str());
1459 // Create socket for listening for incoming connections
1460 hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1461 if (hListenSocket == INVALID_SOCKET)
1463 strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
1464 printf("%s\n", strError.c_str());
1469 // Different way of disabling SIGPIPE on BSD
1470 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1474 // Allow binding if the port is still in TIME_WAIT state after
1475 // the program was closed and restarted. Not an issue on windows.
1476 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1480 // Set to nonblocking, incoming connections will also inherit this
1481 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
1483 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
1486 strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
1487 printf("%s\n", strError.c_str());
1491 // The sockaddr_in structure specifies the address family,
1492 // IP address, and port for the socket that is being bound
1493 struct sockaddr_in sockaddr;
1494 memset(&sockaddr, 0, sizeof(sockaddr));
1495 sockaddr.sin_family = AF_INET;
1496 sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
1497 sockaddr.sin_port = htons(GetListenPort());
1498 if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
1500 int nErr = WSAGetLastError();
1501 if (nErr == WSAEADDRINUSE)
1502 strError = strprintf(_("Unable to bind to port %d on this computer. PPCoin is probably already running."), ntohs(sockaddr.sin_port));
1504 strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
1505 printf("%s\n", strError.c_str());
1508 printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
1510 // Listen for incoming connections
1511 if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1513 strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
1514 printf("%s\n", strError.c_str());
1521 void StartNode(void* parg)
1523 if (semOutbound == NULL) {
1524 // initialize semaphore
1525 int nMaxOutbound = min(MAX_OUTBOUND_CONNECTIONS, (int)GetArg("-maxconnections", 125));
1526 semOutbound = new CSemaphore(nMaxOutbound);
1531 fUseUPnP = GetBoolArg("-upnp", true);
1533 fUseUPnP = GetBoolArg("-upnp", false);
1537 if (pnodeLocalHost == NULL)
1538 pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress(CService("127.0.0.1", 0), nLocalServices));
1541 // Get local host ip
1542 char pszHostName[1000] = "";
1543 if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1545 vector<CNetAddr> vaddr;
1546 if (LookupHost(pszHostName, vaddr))
1548 BOOST_FOREACH (const CNetAddr &addr, vaddr)
1550 if (!addr.IsLocal())
1552 addrLocalHost.SetIP(addr);
1559 // Get local host ip
1560 struct ifaddrs* myaddrs;
1561 if (getifaddrs(&myaddrs) == 0)
1563 for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1565 if (ifa->ifa_addr == NULL) continue;
1566 if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1567 if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1568 if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1570 if (ifa->ifa_addr->sa_family == AF_INET)
1572 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1573 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
1574 printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
1576 // Take the first IP that isn't loopback 127.x.x.x
1577 CAddress addr(CService(s4->sin_addr, GetListenPort()), nLocalServices);
1578 if (addr.IsValid() && !addr.IsLocal())
1580 addrLocalHost = addr;
1584 else if (ifa->ifa_addr->sa_family == AF_INET6)
1586 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1587 if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
1588 printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
1591 freeifaddrs(myaddrs);
1594 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1596 if (fUseProxy || mapArgs.count("-connect") || fNoListen)
1598 // Proxies can't take incoming connections
1599 addrLocalHost.SetIP(CNetAddr("0.0.0.0"));
1600 printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
1604 CreateThread(ThreadGetMyExternalIP, NULL);
1611 if (!GetBoolArg("-dnsseed", true))
1612 printf("DNS seeding disabled\n");
1614 if (!CreateThread(ThreadDNSAddressSeed, NULL))
1615 printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
1617 // Map ports with UPnP
1621 // Get addresses from IRC and advertise ours
1622 // if (!CreateThread(ThreadIRCSeed, NULL))
1623 // printf("Error: CreateThread(ThreadIRCSeed) failed\n");
1624 // IRC disabled with ppcoin
1625 printf("IRC seeding/communication disabled\n");
1627 // Send and receive from sockets, accept connections
1628 if (!CreateThread(ThreadSocketHandler, NULL))
1629 printf("Error: CreateThread(ThreadSocketHandler) failed\n");
1631 // Initiate outbound connections from -addnode
1632 if (!CreateThread(ThreadOpenAddedConnections, NULL))
1633 printf("Error: CreateThread(ThreadOpenAddedConnections) failed\n");
1635 // Initiate outbound connections
1636 if (!CreateThread(ThreadOpenConnections, NULL))
1637 printf("Error: CreateThread(ThreadOpenConnections) failed\n");
1640 if (!CreateThread(ThreadMessageHandler, NULL))
1641 printf("Error: CreateThread(ThreadMessageHandler) failed\n");
1643 // Dump network addresses
1644 if (!CreateThread(ThreadDumpAddress, NULL))
1645 printf("Error; CreateThread(ThreadDumpAddress) failed\n");
1647 // Generate coins in the background
1648 GenerateBitcoins(GetBoolArg("-gen", false), pwalletMain);
1650 // ppcoin: mint proof-of-stake blocks in the background
1651 if (!CreateThread(ThreadStakeMinter, pwalletMain))
1652 printf("Error: CreateThread(ThreadStakeMinter) failed\n");
1657 printf("StopNode()\n");
1659 nTransactionsUpdated++;
1660 int64 nStart = GetTime();
1662 for (int i=0; i<MAX_OUTBOUND_CONNECTIONS; i++)
1663 semOutbound->post();
1666 int nThreadsRunning = 0;
1667 for (int n = 0; n < THREAD_MAX; n++)
1668 nThreadsRunning += vnThreadsRunning[n];
1669 if (nThreadsRunning == 0)
1671 if (GetTime() - nStart > 20)
1675 if (vnThreadsRunning[THREAD_SOCKETHANDLER] > 0) printf("ThreadSocketHandler still running\n");
1676 if (vnThreadsRunning[THREAD_OPENCONNECTIONS] > 0) printf("ThreadOpenConnections still running\n");
1677 if (vnThreadsRunning[THREAD_MESSAGEHANDLER] > 0) printf("ThreadMessageHandler still running\n");
1678 if (vnThreadsRunning[THREAD_MINER] > 0) printf("ThreadBitcoinMiner still running\n");
1679 if (vnThreadsRunning[THREAD_RPCSERVER] > 0) printf("ThreadRPCServer still running\n");
1680 if (fHaveUPnP && vnThreadsRunning[THREAD_UPNP] > 0) printf("ThreadMapPort still running\n");
1681 if (vnThreadsRunning[THREAD_DNSSEED] > 0) printf("ThreadDNSAddressSeed still running\n");
1682 if (vnThreadsRunning[THREAD_ADDEDCONNECTIONS] > 0) printf("ThreadOpenAddedConnections still running\n");
1683 if (vnThreadsRunning[THREAD_DUMPADDRESS] > 0) printf("ThreadDumpAddresses still running\n");
1684 if (vnThreadsRunning[THREAD_MINTER] > 0) printf("ThreadStakeMinter still running\n");
1685 while (vnThreadsRunning[THREAD_MESSAGEHANDLER] > 0 || vnThreadsRunning[THREAD_RPCSERVER] > 0)
1701 BOOST_FOREACH(CNode* pnode, vNodes)
1702 if (pnode->hSocket != INVALID_SOCKET)
1703 closesocket(pnode->hSocket);
1704 if (hListenSocket != INVALID_SOCKET)
1705 if (closesocket(hListenSocket) == SOCKET_ERROR)
1706 printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
1709 // Shutdown Windows Sockets
1714 instance_of_cnetcleanup;