#include "headers.h"
+#ifdef USE_UPNP
+#include <miniupnpc/miniwget.h>
+#include <miniupnpc/miniupnpc.h>
+#include <miniupnpc/upnpcommands.h>
+#include <miniupnpc/upnperrors.h>
+#endif
+
+static const int MAX_OUTBOUND_CONNECTIONS = 8;
+
void ThreadMessageHandler2(void* parg);
void ThreadSocketHandler2(void* parg);
void ThreadOpenConnections2(void* parg);
+#ifdef USE_UPNP
+void ThreadMapPort2(void* parg);
+#endif
bool OpenNetworkConnection(const CAddress& addrConnect);
//
bool fClient = false;
uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
-CAddress addrLocalHost(0, DEFAULT_PORT, nLocalServices);
+CAddress addrLocalHost(0, 0, nLocalServices);
CNode* pnodeLocalHost = NULL;
uint64 nLocalHostNonce = 0;
array<int, 10> vnThreadsRunning;
SOCKET hListenSocket = INVALID_SOCKET;
-int64 nThreadSocketHandlerHeartbeat = INT64_MAX;
vector<CNode*> vNodes;
CCriticalSection cs_vNodes;
SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (hSocket == INVALID_SOCKET)
return false;
-#if defined(__BSD__) || defined(__WXMAC_OSX__)
+#ifdef BSD
int set = 1;
setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
#endif
string strLine;
while (RecvLine(hSocket, strLine))
{
- if (strLine.empty())
+ if (strLine.empty()) // HTTP response is separated from headers by blank line
{
loop
{
closesocket(hSocket);
return false;
}
+ if (pszKeyword == NULL)
+ break;
if (strLine.find(pszKeyword) != -1)
{
strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
}
}
closesocket(hSocket);
- if (strLine.find("<"))
+ if (strLine.find("<") != -1)
strLine = strLine.substr(0, strLine.find("<"));
strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
return error("GetMyExternalIP() : connection closed");
}
-
+// We now get our external IP from the IRC server first and only use this as a backup
bool GetMyExternalIP(unsigned int& ipRet)
{
CAddress addrConnect;
for (int nLookup = 0; nLookup <= 1; nLookup++)
for (int nHost = 1; nHost <= 2; nHost++)
{
+ // We should be phasing out our use of sites like these. If we need
+ // replacements, we should ask for volunteers to put this simple
+ // php file on their webserver that prints the client IP:
+ // <?php echo $_SERVER["REMOTE_ADDR"]; ?>
if (nHost == 1)
{
- addrConnect = CAddress("70.86.96.218:80"); // www.ipaddressworld.com
+ addrConnect = CAddress("91.198.22.70:80"); // checkip.dyndns.org
if (nLookup == 1)
{
- struct hostent* phostent = gethostbyname("www.ipaddressworld.com");
+ struct hostent* phostent = gethostbyname("checkip.dyndns.org");
if (phostent && phostent->h_addr_list && phostent->h_addr_list[0])
addrConnect = CAddress(*(u_long*)phostent->h_addr_list[0], htons(80));
}
- pszGet = "GET /ip.php HTTP/1.1\r\n"
- "Host: www.ipaddressworld.com\r\n"
+ pszGet = "GET / HTTP/1.1\r\n"
+ "Host: checkip.dyndns.org\r\n"
"User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
"Connection: close\r\n"
"\r\n";
- pszKeyword = "IP:";
+ pszKeyword = "Address:";
}
else if (nHost == 2)
{
- addrConnect = CAddress("208.78.68.70:80"); // checkip.dyndns.org
+ addrConnect = CAddress("74.208.43.192:80"); // www.showmyip.com
if (nLookup == 1)
{
- struct hostent* phostent = gethostbyname("checkip.dyndns.org");
+ struct hostent* phostent = gethostbyname("www.showmyip.com");
if (phostent && phostent->h_addr_list && phostent->h_addr_list[0])
addrConnect = CAddress(*(u_long*)phostent->h_addr_list[0], htons(80));
}
- pszGet = "GET / HTTP/1.1\r\n"
- "Host: checkip.dyndns.org\r\n"
+ pszGet = "GET /simple/ HTTP/1.1\r\n"
+ "Host: www.showmyip.com\r\n"
"User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
"Connection: close\r\n"
"\r\n";
- pszKeyword = "Address:";
+ pszKeyword = NULL; // Returns just IP address
}
if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
return false;
}
+void ThreadGetMyExternalIP(void* parg)
+{
+ // Wait for IRC to get it first
+ if (!GetBoolArg("-noirc"))
+ {
+ for (int i = 0; i < 2 * 60; i++)
+ {
+ Sleep(1000);
+ if (fGotExternalIP || fShutdown)
+ return;
+ }
+ }
+
+ // Fallback in case IRC fails to get it
+ if (GetMyExternalIP(addrLocalHost.ip))
+ {
+ printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
+ if (addrLocalHost.IsRoutable())
+ {
+ // If we already connected to a few before we had our IP, go back and addr them.
+ // setAddrKnown automatically filters any duplicate sends.
+ CAddress addr(addrLocalHost);
+ addr.nTime = GetAdjustedTime();
+ CRITICAL_BLOCK(cs_vNodes)
+ foreach(CNode* pnode, vNodes)
+ pnode->PushAddress(addr);
+ }
+ }
+}
-bool AddAddress(CAddress addr)
+
+bool AddAddress(CAddress addr, int64 nTimePenalty)
{
if (!addr.IsRoutable())
return false;
if (addr.ip == addrLocalHost.ip)
return false;
+ addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
CRITICAL_BLOCK(cs_mapAddresses)
{
map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
FD_ZERO(&fdsetSend);
FD_ZERO(&fdsetError);
SOCKET hSocketMax = 0;
- FD_SET(hListenSocket, &fdsetRecv);
+
+ if(hListenSocket != INVALID_SOCKET)
+ FD_SET(hListenSocket, &fdsetRecv);
hSocketMax = max(hSocketMax, hListenSocket);
CRITICAL_BLOCK(cs_vNodes)
{
//
// Accept new connections
//
- if (FD_ISSET(hListenSocket, &fdsetRecv))
+ if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
{
struct sockaddr_in sockaddr;
socklen_t len = sizeof(sockaddr);
SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
CAddress addr(sockaddr);
+ int nInbound = 0;
+
+ CRITICAL_BLOCK(cs_vNodes)
+ foreach(CNode* pnode, vNodes)
+ if (pnode->fInbound)
+ nInbound++;
if (hSocket == INVALID_SOCKET)
{
if (WSAGetLastError() != WSAEWOULDBLOCK)
printf("socket error accept failed: %d\n", WSAGetLastError());
}
+ else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
+ {
+ closesocket(hSocket);
+ }
else
{
printf("accepted connection %s\n", addr.ToStringLog().c_str());
CDataStream& vRecv = pnode->vRecv;
unsigned int nPos = vRecv.size();
- // typical socket buffer is 8K-64K
- char pchBuf[0x10000];
- int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
- if (nBytes > 0)
- {
- vRecv.resize(nPos + nBytes);
- memcpy(&vRecv[nPos], pchBuf, nBytes);
- pnode->nLastRecv = GetTime();
- }
- else if (nBytes == 0)
- {
- // socket closed gracefully
+ if (nPos > 1000*GetArg("-maxreceivebuffer", 10*1000)) {
if (!pnode->fDisconnect)
- printf("socket closed\n");
+ printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
pnode->CloseSocketDisconnect();
}
- else if (nBytes < 0)
- {
- // error
- int nErr = WSAGetLastError();
- if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
+ else {
+ // typical socket buffer is 8K-64K
+ char pchBuf[0x10000];
+ int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
+ if (nBytes > 0)
+ {
+ vRecv.resize(nPos + nBytes);
+ memcpy(&vRecv[nPos], pchBuf, nBytes);
+ pnode->nLastRecv = GetTime();
+ }
+ else if (nBytes == 0)
{
+ // socket closed gracefully
if (!pnode->fDisconnect)
- printf("socket recv error %d\n", nErr);
+ printf("socket closed\n");
pnode->CloseSocketDisconnect();
}
+ else if (nBytes < 0)
+ {
+ // error
+ int nErr = WSAGetLastError();
+ if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
+ {
+ if (!pnode->fDisconnect)
+ printf("socket recv error %d\n", nErr);
+ pnode->CloseSocketDisconnect();
+ }
+ }
}
}
}
pnode->CloseSocketDisconnect();
}
}
+ if (vSend.size() > 1000*GetArg("-maxsendbuffer", 10*1000)) {
+ if (!pnode->fDisconnect)
+ printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
+ pnode->CloseSocketDisconnect();
+ }
}
}
}
pnode->Release();
}
- nThreadSocketHandlerHeartbeat = GetTime();
Sleep(10);
}
}
+#ifdef USE_UPNP
+void ThreadMapPort(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
+ try
+ {
+ vnThreadsRunning[5]++;
+ ThreadMapPort2(parg);
+ vnThreadsRunning[5]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[5]--;
+ PrintException(&e, "ThreadMapPort()");
+ } catch (...) {
+ vnThreadsRunning[5]--;
+ PrintException(NULL, "ThreadMapPort()");
+ }
+ printf("ThreadMapPort exiting\n");
+}
+
+void ThreadMapPort2(void* parg)
+{
+ printf("ThreadMapPort started\n");
+
+ char port[6];
+ sprintf(port, "%d", ntohs(GetDefaultPort()));
+
+ const char * rootdescurl = 0;
+ const char * multicastif = 0;
+ const char * minissdpdpath = 0;
+ struct UPNPDev * devlist = 0;
+ char lanaddr[64];
+
+ devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
+
+ struct UPNPUrls urls;
+ struct IGDdatas data;
+ int r;
+
+ r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
+ if (r == 1)
+ {
+ char intClient[16];
+ char intPort[6];
+
+#ifndef __WXMSW__
+ r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
+ port, port, lanaddr, 0, "TCP", 0);
+#else
+ r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
+ port, port, lanaddr, 0, "TCP", 0, "0");
+#endif
+ if(r!=UPNPCOMMAND_SUCCESS)
+ printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
+ port, port, lanaddr, r, strupnperror(r));
+ else
+ printf("UPnP Port Mapping successful.\n");
+ loop {
+ if (fShutdown || !fUseUPnP)
+ {
+ r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
+ printf("UPNP_DeletePortMapping() returned : %d\n", r);
+ freeUPNPDevlist(devlist); devlist = 0;
+ FreeUPNPUrls(&urls);
+ return;
+ }
+ Sleep(2000);
+ }
+ } else {
+ printf("No valid UPnP IGDs found\n");
+ freeUPNPDevlist(devlist); devlist = 0;
+ if (r != 0)
+ FreeUPNPUrls(&urls);
+ loop {
+ if (fShutdown || !fUseUPnP)
+ return;
+ Sleep(2000);
+ }
+ }
+}
+
+void MapPort(bool fMapPort)
+{
+ if (fUseUPnP != fMapPort)
+ {
+ fUseUPnP = fMapPort;
+ CWalletDB().WriteSetting("fUseUPnP", fUseUPnP);
+ }
+ if (fUseUPnP && vnThreadsRunning[5] < 1)
+ {
+ if (!CreateThread(ThreadMapPort, NULL))
+ printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
+ }
+}
+#endif
+
+
+
+
+
+
+
+
+
+
+static const char *strDNSSeed[] = {
+ "bitseed.xf2.org",
+ "bitseed.bitcoin.org.uk",
+};
+void DNSAddressSeed()
+{
+ int found = 0;
+
+ printf("Loading addresses from DNS seeds (could take a while)\n");
+
+ for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
+ struct hostent* phostent = gethostbyname(strDNSSeed[seed_idx]);
+ if (!phostent)
+ continue;
+
+ for (int host = 0; phostent->h_addr_list[host] != NULL; host++) {
+ CAddress addr(*(unsigned int*)phostent->h_addr_list[host],
+ GetDefaultPort(), NODE_NETWORK);
+ addr.nTime = 0;
+ if (addr.IsValid() && addr.GetByte(3) != 127) {
+ AddAddress(addr);
+ found++;
+ }
+ }
+ }
+
+ printf("%d addresses found from DNS seeds\n", found);
+}
unsigned int pnSeed[] =
{
- 0x35218252, 0x9c9c9618, 0xda6bacad, 0xb9aca862, 0x97c235c6,
- 0x146f9562, 0xb67b9e4b, 0x87cf4bc0, 0xb83945d0, 0x984333ad,
- 0xbbeec555, 0x6f0eb440, 0xe0005318, 0x7797e460, 0xddc60fcc,
- 0xb3bbd24a, 0x1ac85746, 0x641846a6, 0x85ee1155, 0xbb2e7a4c,
- 0x9cb8514b, 0xfc342648, 0x62958fae, 0xd0a8c87a, 0xa800795b,
- 0xda8c814e, 0x256a0c80, 0x3f23ec63, 0xd565df43, 0x997d9044,
- 0xaa121448, 0xbed8688e, 0x59d09a5e, 0xb2931243, 0x3730ba18,
- 0xdd3462d0, 0x4e4d1448, 0x171df645, 0x84ee1155,
- 0x248ac445, 0x0e634444, 0x0ded1b63, 0x30c01e60,
- 0xa2b9a094, 0x29e4fd43, 0x9ce61b4c, 0xdae09744,
+ 0x1ddb1032, 0x6242ce40, 0x52d6a445, 0x2dd7a445, 0x8a53cd47, 0x73263750, 0xda23c257, 0xecd4ed57,
+ 0x0a40ec59, 0x75dce160, 0x7df76791, 0x89370bad, 0xa4f214ad, 0x767700ae, 0x638b0418, 0x868a1018,
+ 0xcd9f332e, 0x0129653e, 0xcc92dc3e, 0x96671640, 0x56487e40, 0x5b66f440, 0xb1d01f41, 0xf1dc6041,
+ 0xc1d12b42, 0x86ba1243, 0x6be4df43, 0x6d4cef43, 0xd18e0644, 0x1ab0b344, 0x6584a345, 0xe7c1a445,
+ 0x58cea445, 0xc5daa445, 0x21dda445, 0x3d3b5346, 0x13e55347, 0x1080d24a, 0x8e611e4b, 0x81518e4b,
+ 0x6c839e4b, 0xe2ad0a4c, 0xfbbc0a4c, 0x7f5b6e4c, 0x7244224e, 0x1300554e, 0x20690652, 0x5a48b652,
+ 0x75c5c752, 0x4335cc54, 0x340fd154, 0x87c07455, 0x087b2b56, 0x8a133a57, 0xac23c257, 0x70374959,
+ 0xfb63d45b, 0xb9a1685c, 0x180d765c, 0x674f645d, 0x04d3495e, 0x1de44b5e, 0x4ee8a362, 0x0ded1b63,
+ 0xc1b04b6d, 0x8d921581, 0x97b7ea82, 0x1cf83a8e, 0x91490bad, 0x09dc75ae, 0x9a6d79ae, 0xa26d79ae,
+ 0x0fd08fae, 0x0f3e3fb2, 0x4f944fb2, 0xcca448b8, 0x3ecd6ab8, 0xa9d5a5bc, 0x8d0119c1, 0x045997d5,
+ 0xca019dd9, 0x0d526c4d, 0xabf1ba44, 0x66b1ab55, 0x1165f462, 0x3ed7cbad, 0xa38fae6e, 0x3bd2cbad,
+ 0xd36f0547, 0x20df7840, 0x7a337742, 0x549f8e4b, 0x9062365c, 0xd399f562, 0x2b5274a1, 0x8edfa153,
+ 0x3bffb347, 0x7074bf58, 0xb74fcbad, 0x5b5a795b, 0x02fa29ce, 0x5a6738d4, 0xe8a1d23e, 0xef98c445,
+ 0x4b0f494c, 0xa2bc1e56, 0x7694ad63, 0xa4a800c3, 0x05fda6cd, 0x9f22175e, 0x364a795b, 0x536285d5,
+ 0xac44c9d4, 0x0b06254d, 0x150c2fd4, 0x32a50dcc, 0xfd79ce48, 0xf15cfa53, 0x66c01e60, 0x6bc26661,
+ 0xc03b47ae, 0x4dda1b81, 0x3285a4c1, 0x883ca96d, 0x35d60a4c, 0xdae09744, 0x2e314d61, 0x84e247cf,
+ 0x6c814552, 0x3a1cc658, 0x98d8f382, 0xe584cb5b, 0x15e86057, 0x7b01504e, 0xd852dd48, 0x56382f56,
+ 0x0a5df454, 0xa0d18d18, 0x2e89b148, 0xa79c114c, 0xcbdcd054, 0x5523bc43, 0xa9832640, 0x8a066144,
+ 0x3894c3bc, 0xab76bf58, 0x6a018ac1, 0xfebf4f43, 0x2f26c658, 0x31102f4e, 0x85e929d5, 0x2a1c175e,
+ 0xfc6c2cd1, 0x27b04b6d, 0xdf024650, 0x161748b8, 0x28be6580, 0x57be6580, 0x1cee677a, 0xaa6bb742,
+ 0x9a53964b, 0x0a5a2d4d, 0x2434c658, 0x9a494f57, 0x1ebb0e48, 0xf610b85d, 0x077ecf44, 0x085128bc,
+ 0x5ba17a18, 0x27ca1b42, 0xf8a00b56, 0xfcd4c257, 0xcf2fc15e, 0xd897e052, 0x4cada04f, 0x2f35f6d5,
+ 0x382ce8c9, 0xe523984b, 0x3f946846, 0x60c8be43, 0x41da6257, 0xde0be142, 0xae8a544b, 0xeff0c254,
+ 0x1e0f795b, 0xaeb28890, 0xca16acd9, 0x1e47ddd8, 0x8c8c4829, 0xd27dc747, 0xd53b1663, 0x4096b163,
+ 0x9c8dd958, 0xcb12f860, 0x9e79305c, 0x40c1a445, 0x4a90c2bc, 0x2c3a464d, 0x2727f23c, 0x30b04b6d,
+ 0x59024cb8, 0xa091e6ad, 0x31b04b6d, 0xc29d46a6, 0x63934fb2, 0xd9224dbe, 0x9f5910d8, 0x7f530a6b,
+ 0x752e9c95, 0x65453548, 0xa484be46, 0xce5a1b59, 0x710e0718, 0x46a13d18, 0xdaaf5318, 0xc4a8ff53,
+ 0x87abaa52, 0xb764cf51, 0xb2025d4a, 0x6d351e41, 0xc035c33e, 0xa432c162, 0x61ef34ae, 0xd16fddbc,
+ 0x0870e8c1, 0x3070e8c1, 0x9c71e8c1, 0xa4992363, 0x85a1f663, 0x4184e559, 0x18d96ed8, 0x17b8dbd5,
+ 0x60e7cd18, 0xe5ee104c, 0xab17ac62, 0x1e786e1b, 0x5d23b762, 0xf2388fae, 0x88270360, 0x9e5b3d80,
+ 0x7da518b2, 0xb5613b45, 0x1ad41f3e, 0xd550854a, 0x8617e9a9, 0x925b229c, 0xf2e92542, 0x47af0544,
+ 0x73b5a843, 0xb9b7a0ad, 0x03a748d0, 0x0a6ff862, 0x6694df62, 0x3bfac948, 0x8e098f4f, 0x746916c3,
+ 0x02f38e4f, 0x40bb1243, 0x6a54d162, 0x6008414b, 0xa513794c, 0x514aa343, 0x63781747, 0xdbb6795b,
+ 0xed065058, 0x42d24b46, 0x1518794c, 0x9b271681, 0x73e4ffad, 0x0654784f, 0x438dc945, 0x641846a6,
+ 0x2d1b0944, 0x94b59148, 0x8d369558, 0xa5a97662, 0x8b705b42, 0xce9204ae, 0x8d584450, 0x2df61555,
+ 0xeebff943, 0x2e75fb4d, 0x3ef8fc57, 0x9921135e, 0x8e31042e, 0xb5afad43, 0x89ecedd1, 0x9cfcc047,
+ 0x8fcd0f4c, 0xbe49f5ad, 0x146a8d45, 0x98669ab8, 0x98d9175e, 0xd1a8e46d, 0x839a3ab8, 0x40a0016c,
+ 0x6d27c257, 0x977fffad, 0x7baa5d5d, 0x1213be43, 0xb167e5a9, 0x640fe8ca, 0xbc9ea655, 0x0f820a4c,
+ 0x0f097059, 0x69ac957c, 0x366d8453, 0xb1ba2844, 0x8857f081, 0x70b5be63, 0xc545454b, 0xaf36ded1,
+ 0xb5a4b052, 0x21f062d1, 0x72ab89b2, 0x74a45318, 0x8312e6bc, 0xb916965f, 0x8aa7c858, 0xfe7effad,
};
int64 nStart = GetTime();
loop
{
- // Wait
+ // Limit outbound connections
vnThreadsRunning[1]--;
Sleep(500);
- const int nMaxConnections = 8;
- while (vNodes.size() >= nMaxConnections)
+ loop
{
+ int nOutbound = 0;
+ CRITICAL_BLOCK(cs_vNodes)
+ foreach(CNode* pnode, vNodes)
+ if (!pnode->fInbound)
+ nOutbound++;
+ int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
+ nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
+ if (nOutbound < nMaxOutboundConnections)
+ break;
Sleep(2000);
if (fShutdown)
return;
// Add seed nodes if IRC isn't working
static bool fSeedUsed;
bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
- if (mapAddresses.empty() && (GetTime() - nStart > 60 || fTOR))
+ if (mapAddresses.empty() && (GetTime() - nStart > 60 || fTOR) && !fTestNet)
{
for (int i = 0; i < ARRAYLEN(pnSeed); i++)
{
{
foreach(PAIRTYPE(const vector<unsigned char>, CAddress)& item, mapAddresses)
{
- if (setSeed.count(item.second.ip))
+ if (setSeed.count(item.second.ip) && item.second.nTime != 0)
{
item.second.nTime = 0;
CAddrDB().WriteAddress(item.second);
CAddress addrConnect;
int64 nBest = INT64_MIN;
- // Do this here so we don't have to critsect vNodes inside mapAddresses critsect
+ // Only connect to one address per a.b.?.? range.
+ // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
set<unsigned int> setConnected;
CRITICAL_BLOCK(cs_vNodes)
foreach(CNode* pnode, vNodes)
- setConnected.insert(pnode->addr.ip);
+ setConnected.insert(pnode->addr.ip & 0x0000ffff);
CRITICAL_BLOCK(cs_mapAddresses)
{
foreach(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
{
const CAddress& addr = item.second;
- if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip))
+ if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
continue;
int64 nSinceLastSeen = GetAdjustedTime() - addr.nTime;
int64 nSinceLastTry = GetAdjustedTime() - addr.nLastTry;
// Randomize the order in a deterministic way, putting the standard port first
int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
- if (addr.port != DEFAULT_PORT)
+ if (addr.port != GetDefaultPort())
nRandomizer += 2 * 60 * 60;
// Last seen Base retry frequency
return false;
pnode->fNetworkNode = true;
- if (addrLocalHost.IsRoutable() && !fUseProxy)
- {
- // Advertise our address
- vector<CAddress> vAddr;
- vAddr.push_back(addrLocalHost);
- pnode->PushMessage("addr", vAddr);
- }
-
- // Get as many addresses as we can
- pnode->PushMessage("getaddr");
- pnode->fGetAddr = true; // don't relay the results of the getaddr
-
- ////// should the one on the receiving end do this too?
- // Subscribe our local subscription list
- const unsigned int nHops = 0;
- for (unsigned int nChannel = 0; nChannel < pnodeLocalHost->vfSubscribe.size(); nChannel++)
- if (pnodeLocalHost->vfSubscribe[nChannel])
- pnode->PushMessage("subscribe", nChannel, nHops);
-
return true;
}
pnode->Release();
}
- // Wait and allow messages to bunch up
+ // Wait and allow messages to bunch up.
+ // Reduce vnThreadsRunning so StopNode has permission to exit while
+ // we're sleeping, but we must always check fShutdown after doing this.
vnThreadsRunning[2]--;
Sleep(100);
+ if (fRequestShutdown)
+ Shutdown(NULL);
vnThreadsRunning[2]++;
if (fShutdown)
return;
{
strError = "";
int nOne = 1;
+ addrLocalHost.port = GetDefaultPort();
#ifdef __WXMSW__
// Initialize Windows Sockets
return false;
}
-#if defined(__BSD__) || defined(__WXMAC_OSX__)
+#ifdef BSD
// Different way of disabling SIGPIPE on BSD
setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
#endif
memset(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
- sockaddr.sin_port = DEFAULT_PORT;
+ sockaddr.sin_port = GetDefaultPort();
if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
{
int nErr = WSAGetLastError();
if (nErr == WSAEADDRINUSE)
- strError = strprintf("Unable to bind to port %d on this computer. Bitcoin is probably already running.", ntohs(sockaddr.sin_port));
+ strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
else
strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
printf("%s\n", strError.c_str());
printf("host ip %d: %s\n", i, CAddress(*(unsigned int*)phostent->h_addr_list[i]).ToStringIP().c_str());
for (int i = 0; phostent->h_addr_list[i] != NULL; i++)
{
- CAddress addr(*(unsigned int*)phostent->h_addr_list[i], DEFAULT_PORT, nLocalServices);
+ CAddress addr(*(unsigned int*)phostent->h_addr_list[i], GetDefaultPort(), nLocalServices);
if (addr.IsValid() && addr.GetByte(3) != 127)
{
addrLocalHost = addr;
printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
// Take the first IP that isn't loopback 127.x.x.x
- CAddress addr(*(unsigned int*)&s4->sin_addr, DEFAULT_PORT, nLocalServices);
+ CAddress addr(*(unsigned int*)&s4->sin_addr, GetDefaultPort(), nLocalServices);
if (addr.IsValid() && addr.GetByte(3) != 127)
{
addrLocalHost = addr;
#endif
printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
- // Get our external IP address for incoming connections
- if (fUseProxy)
+ if (fUseProxy || mapArgs.count("-connect") || fNoListen)
{
// Proxies can't take incoming connections
addrLocalHost.ip = CAddress("0.0.0.0").ip;
}
else
{
- if (addrIncoming.IsValid())
- addrLocalHost.ip = addrIncoming.ip;
-
- if (GetMyExternalIP(addrLocalHost.ip))
- {
- addrIncoming = addrLocalHost;
- CWalletDB().WriteSetting("addrIncoming", addrIncoming);
- printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
- }
+ CreateThread(ThreadGetMyExternalIP, NULL);
}
//
// Start threads
//
+ // Map ports with UPnP
+ if (fHaveUPnP)
+ MapPort(fUseUPnP);
+
// Get addresses from IRC and advertise ours
if (!CreateThread(ThreadIRCSeed, NULL))
printf("Error: CreateThread(ThreadIRCSeed) failed\n");
// Generate coins in the background
GenerateBitcoins(fGenerateBitcoins);
-
- //
- // Thread monitoring
- // Not really needed anymore, the cause of the hanging was fixed
- //
- loop
- {
- Sleep(1000);
- if (fShutdown)
- return;
- if (GetTime() - nThreadSocketHandlerHeartbeat > 15 * 60)
- {
- // First see if closing sockets will free it
- printf("*** ThreadSocketHandler is stopped ***\n");
- CRITICAL_BLOCK(cs_vNodes)
- {
- foreach(CNode* pnode, vNodes)
- {
- bool fGot = false;
- TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
- TRY_CRITICAL_BLOCK(pnode->cs_vSend)
- fGot = true;
- if (!fGot)
- {
- printf("*** closing socket\n");
- pnode->CloseSocketDisconnect();
- }
- }
- }
- Sleep(10000);
- if (fShutdown)
- return;
- if (GetTime() - nThreadSocketHandlerHeartbeat < 60)
- continue;
-
- // Hopefully it never comes to this.
- // We know it'll always be hung in the recv or send call.
- // cs_vRecv or cs_vSend may be left permanently unreleased,
- // but we always only use TRY_CRITICAL_SECTION on them.
- printf("*** Restarting ThreadSocketHandler ***\n");
- TerminateThread(hThreadSocketHandler, 0);
- #ifdef __WXMSW__
- CloseHandle(hThreadSocketHandler);
- #endif
- vnThreadsRunning[0] = 0;
-
- // Restart
- hThreadSocketHandler = CreateThread(ThreadSocketHandler, NULL, true);
- nThreadSocketHandlerHeartbeat = GetTime();
- }
- }
}
bool StopNode()
fShutdown = true;
nTransactionsUpdated++;
int64 nStart = GetTime();
- while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0)
+ while (vnThreadsRunning[0] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
+#ifdef USE_UPNP
+ || vnThreadsRunning[5] > 0
+#endif
+ )
{
if (GetTime() - nStart > 20)
break;
if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
+ if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
Sleep(20);
Sleep(50);
git://git.novaco.in / novacoin.git / blobdiff