#include "db.h"
#include "net.h"
#include "init.h"
-#include "strlcpy.h"
#include "addrman.h"
#include "ui_interface.h"
void ThreadMapPort2(void* parg);
#endif
void ThreadDNSAddressSeed2(void* parg);
-bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false);
-
struct LocalServiceInfo {
int nScore;
bool fClient = false;
bool fDiscover = true;
bool fUseUPnP = false;
-uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
+uint64_t nLocalServices = (fClient ? 0 : NODE_NETWORK);
static CCriticalSection cs_mapLocalHost;
static map<CNetAddr, LocalServiceInfo> mapLocalHost;
static bool vfReachable[NET_MAX] = {};
static CNode* pnodeLocalHost = NULL;
static CNode* pnodeSync = NULL;
CAddress addrSeenByPeer(CService("0.0.0.0", 0), nLocalServices);
-uint64 nLocalHostNonce = 0;
+uint64_t nLocalHostNonce = 0;
boost::array<int, THREAD_MAX> vnThreadsRunning;
static std::vector<SOCKET> vhListenSocket;
CAddrMan addrman;
vector<CNode*> vNodes;
CCriticalSection cs_vNodes;
map<CInv, CDataStream> mapRelay;
-deque<pair<int64, CInv> > vRelayExpiration;
+deque<pair<int64_t, CInv> > vRelayExpiration;
CCriticalSection cs_mapRelay;
-map<CInv, int64> mapAlreadyAskedFor;
+map<CInv, int64_t> mapAlreadyAskedFor;
static deque<string> vOneShots;
CCriticalSection cs_vOneShots;
set<CNetAddr> setservAddNodeAddresses;
CCriticalSection cs_setservAddNodeAddresses;
+vector<std::string> vAddedNodes;
+CCriticalSection cs_vAddedNodes;
+
static CSemaphore *semOutbound = NULL;
void AddOneShot(string strDest)
bool GetMyExternalIP(CNetAddr& ipRet)
{
struct sockaddr_in mapped;
- uint64 rnd = GetRand(~0LL);
+ uint64_t rnd = UINT64_MAX;
const char *srv;
int rc = GetExternalIPbySTUN(rnd, &mapped, &srv);
if(rc >= 0) {
ipRet = CNetAddr(mapped.sin_addr);
- printf("GetExternalIPbySTUN(%"PRI64u") returned %s in attempt %d; Server=%s\n", rnd, ipRet.ToStringIP().c_str(), rc, srv);
+ printf("GetExternalIPbySTUN(%" PRIu64 ") returned %s in attempt %d; Server=%s\n", rnd, ipRet.ToStringIP().c_str(), rc, srv);
return true;
}
return false;
return NULL;
}
-CNode* ConnectNode(CAddress addrConnect, const char *pszDest, int64 nTimeout)
+CNode* ConnectNode(CAddress addrConnect, const char *pszDest, int64_t nTimeout)
{
if (pszDest == NULL) {
if (IsLocal(addrConnect))
void CNode::PushVersion()
{
/// when NTP implemented, change to just nTime = GetAdjustedTime()
- int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
- CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService("0.0.0.0",0)));
- CAddress addrMe = GetLocalAddress(&addr);
+ int64_t nTime = (fInbound ? GetAdjustedTime() : GetTime());
+ CAddress addrYou, addrMe;
+
+ bool fHidden = false;
+ if (addr.IsTor()) {
+ if (mapArgs.count("-torname")) {
+ // Our hidden service address
+ CService addrTorName(mapArgs["-torname"], GetListenPort());
+
+ if (addrTorName.IsValid()) {
+ addrYou = addr;
+ addrMe = CAddress(addrTorName);
+ fHidden = true;
+ }
+ }
+ }
+
+ if (!fHidden) {
+ addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService("0.0.0.0",0)));
+ addrMe = GetLocalAddress(&addr);
+ }
+
RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
printf("send version message: version %d, blocks=%d, us=%s, them=%s, peer=%s\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString().c_str(), addrYou.ToString().c_str(), addr.ToString().c_str());
PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
-std::map<CNetAddr, int64> CNode::setBanned;
+std::map<CNetAddr, int64_t> CNode::setBanned;
CCriticalSection CNode::cs_setBanned;
void CNode::ClearBanned()
bool fResult = false;
{
LOCK(cs_setBanned);
- std::map<CNetAddr, int64>::iterator i = setBanned.find(ip);
+ std::map<CNetAddr, int64_t>::iterator i = setBanned.find(ip);
if (i != setBanned.end())
{
- int64 t = (*i).second;
+ int64_t t = (*i).second;
if (GetTime() < t)
fResult = true;
}
nMisbehavior += howmuch;
if (nMisbehavior >= GetArg("-banscore", 100))
{
- int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
+ int64_t banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
printf("Misbehaving: %s (%d -> %d) DISCONNECTING\n", addr.ToString().c_str(), nMisbehavior-howmuch, nMisbehavior);
{
LOCK(cs_setBanned);
printf("ThreadSocketHandler exited\n");
}
+static list<CNode*> vNodesDisconnected;
+
void ThreadSocketHandler2(void* parg)
{
printf("ThreadSocketHandler started\n");
- list<CNode*> vNodesDisconnected;
unsigned int nPrevNodeCount = 0;
-
while (true)
{
//
if (lockRecv)
{
CDataStream& vRecv = pnode->vRecv;
- unsigned int nPos = vRecv.size();
+ uint64_t nPos = vRecv.size();
if (nPos > ReceiveBufferSize()) {
if (!pnode->fDisconnect)
- printf("socket recv flood control disconnect (%"PRIszu" bytes)\n", vRecv.size());
+ printf("socket recv flood control disconnect (%" PRIszu " bytes)\n", vRecv.size());
pnode->CloseSocketDisconnect();
}
else {
// The second name should resolve to a list of seed addresses.
static const char *strDNSSeed[][2] = {
{"novacoin.karelia.pro", "dnsseed.novacoin.karelia.pro"},
- {"novacoin.su", "dnsseed.novacoin.su"},
{"novacoin.ru", "dnsseed.novacoin.ru"},
+ {"novacoin.ru", "testseed.novacoin.ru"},
{"novaco.in", "dnsseed.novaco.in"},
};
-unsigned int pnSeed[] =
+uint32_t pnSeed[] =
+{
+ 0xa52bf0da, 0x30aa43d8, 0x614488d5, 0x517b6fd5, 0xd4bf62d4, 0xb7d638d4, 0xbc12bcd1, 0xa2501bc6,
+ 0xfde617c6, 0x3337b1c6, 0x1dcd71c3, 0x2c1544c1, 0xe05f6ac1, 0x852f63c0, 0x3e2363c0, 0x15f563c0,
+ 0x430d63c0, 0x50d6a9c0, 0xf0a679c0, 0xefdeedbf, 0x7aaee8bc, 0x3a3dbbbc, 0xef218abc, 0x0bef78bc,
+ 0x8baa3eb2, 0x2bf913b2, 0x24ed9fb2, 0xb42289b2, 0x718a09b0, 0xe9433eb0, 0x559425b0, 0xc97e1fb0,
+ 0x18e1d4b0, 0x8f6cc1b0, 0xac3838ae, 0x86c0ffad, 0x6b0272a7, 0xa463f8a2, 0x6f17f3a2, 0xb3d6f3a2,
+ 0x9cd8f997, 0xd513fb94, 0x39e64880, 0x3859dd6f, 0x0b08fe6d, 0xe601fe6d, 0xeb44a26d, 0xfe53186c,
+ 0x203c2e68, 0x1c542868, 0x0caa8368, 0xb8748368, 0xccca4762, 0xc637555f, 0x638a545f, 0x59b2205f,
+ 0x52568c5f, 0xba568c5f, 0x8a568c5f, 0x31b0f45e, 0x54a0f45e, 0x37d6f15e, 0xc520175e, 0x7620175e,
+ 0xc310175e, 0x8e33b45e, 0x7abb5f5d, 0xd3014c5d, 0xa1e1485d, 0x9947645d, 0xfab8ff5c, 0xa979e65b,
+ 0xa879e65b, 0x9f79e65b, 0x9fa3d25b, 0x112a925b, 0x7b92905b, 0x60647a5b, 0x1e389d5a, 0x851afa59,
+ 0x0185ef59, 0x26549b59, 0x1c9efe57, 0xc54c1256, 0x1ad51955, 0x19d21955, 0x73c41955, 0x3f74ee55,
+ 0x633eea55, 0x6883d655, 0xfb72c655, 0x5360a653, 0x17c1ea52, 0xc661c852, 0x1ecdc852, 0x006a9752,
+ 0xf72d9252, 0x82650551, 0x36f1c851, 0x33f1c851, 0xd5c1864f, 0xb6bf1b4e, 0x96da184e, 0x40d0234d,
+ 0x9a96ab4c, 0x8fc2a84c, 0xb5dbd048, 0xf4644447, 0x2d51af47, 0xa9625445, 0x83f05243, 0x89672941,
+ 0x3a8bad3e, 0xf0a05436, 0x6ab7c936, 0x49971d32, 0xadd4482e, 0xcffd212e, 0x6730bc2e, 0x839aa12e,
+ 0x68d9692e, 0xc7183b25, 0x6c47bb25, 0x2490bb25, 0xad651c1f, 0x048a861f, 0x6937811f, 0x064b2d05,
+ 0x4d226805,
+};
+
+const char* pchTorSeed[] =
{
- 0x90EF78BC, 0x33F1C851, 0x36F1C851, 0xC6F5C851,
+ "seedp4knqnoei57u.onion",
+ "seedr3hhlepyi7fd.onion",
+ "seed3uuomkclbiz4.onion",
+ "seedeh7qck3ouff5.onion",
+ "5rg3vq4jagckeckf.onion",
+ "seedt3sraf53ajiy.onion",
+ "seedg4qyccsg42oq.onion",
+ "novaqrtoywpg7jly.onion",
+ "seed3d5wolqbgrcb.onion",
+ "seed24u5dwph3qw4.onion",
+ "mj26ulzbs2oskgym.onion",
+ "eqon4usunavt76m7.onion",
};
void DumpAddresses()
{
- int64 nStart = GetTimeMillis();
+ int64_t nStart = GetTimeMillis();
CAddrDB adb;
adb.Write(addrman);
- printf("Flushed %d addresses to peers.dat %"PRI64d"ms\n",
+ printf("Flushed %d addresses to peers.dat %" PRId64 "ms\n",
addrman.size(), GetTimeMillis() - nStart);
}
void ThreadDumpAddress2(void* parg)
{
+ printf("ThreadDumpAddress started\n");
+
vnThreadsRunning[THREAD_DUMPADDRESS]++;
while (!fShutdown)
{
// Connect to specific addresses
if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0)
{
- for (int64 nLoop = 0;; nLoop++)
+ for (int64_t nLoop = 0;; nLoop++)
{
ProcessOneShot();
BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
}
// Initiate network connections
- int64 nStart = GetTime();
+ int64_t nStart = GetTime();
while (true)
{
ProcessOneShot();
return;
// Add seed nodes if IRC isn't working
- if (addrman.size()==0 && (GetTime() - nStart > 60) && !fTestNet)
+ if (!IsLimited(NET_IPV4) && addrman.size()==0 && (GetTime() - nStart > 60) && !fTestNet)
{
std::vector<CAddress> vAdd;
for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
// it'll get a pile of addresses with newer timestamps.
// Seed nodes are given a random 'last seen time' of between one and two
// weeks ago.
- const int64 nOneWeek = 7*24*60*60;
+ const int64_t nOneWeek = 7*24*60*60;
struct in_addr ip;
memcpy(&ip, &pnSeed[i], sizeof(ip));
CAddress addr(CService(ip, GetDefaultPort()));
addrman.Add(vAdd, CNetAddr("127.0.0.1"));
}
+ // Add Tor nodes if we have connection with onion router
+ if (mapArgs.count("-tor"))
+ {
+ std::vector<CAddress> vAdd;
+ for (unsigned int i = 0; i < ARRAYLEN(pchTorSeed); i++)
+ {
+ const int64_t nOneWeek = 7*24*60*60;
+ CAddress addr(CService(pchTorSeed[i], GetDefaultPort()));
+ addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
+ vAdd.push_back(addr);
+ }
+ addrman.Add(vAdd, CNetAddr("dummyaddress.onion"));
+ }
+
//
// Choose an address to connect to based on most recently seen
//
}
}
- int64 nANow = GetAdjustedTime();
+ int64_t nANow = GetAdjustedTime();
int nTries = 0;
while (true)
{
printf("ThreadOpenAddedConnections started\n");
- if (mapArgs.count("-addnode") == 0)
- return;
+ {
+ LOCK(cs_vAddedNodes);
+ vAddedNodes = mapMultiArgs["-addnode"];
+ }
if (HaveNameProxy()) {
while(!fShutdown) {
- BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"]) {
+ list<string> lAddresses(0);
+ {
+ LOCK(cs_vAddedNodes);
+ BOOST_FOREACH(string& strAddNode, vAddedNodes)
+ lAddresses.push_back(strAddNode);
+ }
+ BOOST_FOREACH(string& strAddNode, lAddresses) {
CAddress addr;
CSemaphoreGrant grant(*semOutbound);
OpenNetworkConnection(addr, &grant, strAddNode.c_str());
return;
}
- vector<vector<CService> > vservAddressesToAdd(0);
- BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"])
+ for (uint32_t i = 0; true; i++)
{
- vector<CService> vservNode(0);
- if(Lookup(strAddNode.c_str(), vservNode, GetDefaultPort(), fNameLookup, 0))
+ list<string> lAddresses(0);
{
- vservAddressesToAdd.push_back(vservNode);
+ LOCK(cs_vAddedNodes);
+ BOOST_FOREACH(string& strAddNode, vAddedNodes)
+ lAddresses.push_back(strAddNode);
+ }
+
+ list<vector<CService> > lservAddressesToAdd(0);
+ BOOST_FOREACH(string& strAddNode, lAddresses)
+ {
+ vector<CService> vservNode(0);
+ if (Lookup(strAddNode.c_str(), vservNode, GetDefaultPort(), fNameLookup, 0))
{
- LOCK(cs_setservAddNodeAddresses);
- BOOST_FOREACH(CService& serv, vservNode)
- setservAddNodeAddresses.insert(serv);
+ lservAddressesToAdd.push_back(vservNode);
+ {
+ LOCK(cs_setservAddNodeAddresses);
+ BOOST_FOREACH(CService& serv, vservNode)
+ setservAddNodeAddresses.insert(serv);
+ }
}
}
- }
- while (true)
- {
- vector<vector<CService> > vservConnectAddresses = vservAddressesToAdd;
// Attempt to connect to each IP for each addnode entry until at least one is successful per addnode entry
// (keeping in mind that addnode entries can have many IPs if fNameLookup)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
- for (vector<vector<CService> >::iterator it = vservConnectAddresses.begin(); it != vservConnectAddresses.end(); it++)
+ for (list<vector<CService> >::iterator it = lservAddressesToAdd.begin(); it != lservAddressesToAdd.end(); it++)
+ {
BOOST_FOREACH(CService& addrNode, *(it))
if (pnode->addr == addrNode)
{
- it = vservConnectAddresses.erase(it);
- it--;
+ it = lservAddressesToAdd.erase(it);
+ if(it != lservAddressesToAdd.begin())
+ it--;
break;
}
+ if (it == lservAddressesToAdd.end())
+ break;
+ }
}
- BOOST_FOREACH(vector<CService>& vserv, vservConnectAddresses)
+ BOOST_FOREACH(vector<CService>& vserv, lservAddressesToAdd)
{
+ if (vserv.size() == 0)
+ continue;
CSemaphoreGrant grant(*semOutbound);
- OpenNetworkConnection(CAddress(*(vserv.begin())), &grant);
+ OpenNetworkConnection(CAddress(vserv[i % vserv.size()]), &grant);
Sleep(500);
if (fShutdown)
return;
printf("Error: NewThread(ThreadDNSAddressSeed) failed\n");
// Map ports with UPnP
- if (fUseUPnP)
+ if (!fUseUPnP)
+ printf("UPNP port mapping is disabled\n");
+ else
MapPort();
// Get addresses from IRC and advertise ours
- if (!NewThread(ThreadIRCSeed, NULL))
- printf("Error: NewThread(ThreadIRCSeed) failed\n");
+ if (!GetBoolArg("-irc", true))
+ printf("IRC seeding disabled\n");
+ else
+ if (!NewThread(ThreadIRCSeed, NULL))
+ printf("Error: NewThread(ThreadIRCSeed) failed\n");
// Send and receive from sockets, accept connections
if (!NewThread(ThreadSocketHandler, NULL))
printf("StopNode()\n");
fShutdown = true;
nTransactionsUpdated++;
- int64 nStart = GetTime();
+ int64_t nStart = GetTime();
{
LOCK(cs_main);
ThreadScriptCheckQuit();
Sleep(20);
Sleep(50);
DumpAddresses();
+
return true;
}
if (closesocket(hListenSocket) == SOCKET_ERROR)
printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
+ // clean up some globals (to help leak detection)
+ BOOST_FOREACH(CNode *pnode, vNodes)
+ delete pnode;
+ BOOST_FOREACH(CNode *pnode, vNodesDisconnected)
+ delete pnode;
+ vNodes.clear();
+ vNodesDisconnected.clear();
+ delete semOutbound;
+ semOutbound = NULL;
+ delete pnodeLocalHost;
+ pnodeLocalHost = NULL;
+
#ifdef WIN32
// Shutdown Windows Sockets
WSACleanup();
git://git.novaco.in / novacoin.git / blobdiff