18 #include <miniupnpc/miniwget.h>
19 #include <miniupnpc/miniupnpc.h>
20 #include <miniupnpc/upnpcommands.h>
21 #include <miniupnpc/upnperrors.h>
25 #define DUMP_ADDRESSES_INTERVAL 900
28 using namespace boost;
30 static const int MAX_OUTBOUND_CONNECTIONS = 16;
46 static map<CNetAddr, LocalServiceInfo> mapLocalHost;
47 static bool vfReachable[
NET_MAX] = {};
48 static bool vfLimited[
NET_MAX] = {};
49 static CNode* pnodeLocalHost = NULL;
50 static CNode* pnodeSync = NULL;
52 static std::vector<SOCKET> vhListenSocket;
63 static deque<string> vOneShots;
77 vOneShots.push_back(strDest);
82 return (
unsigned short)(
GetArg(
"-port", GetDefaultPort()));
88 if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
90 pindexLastGetBlocksBegin = pindexBegin;
91 hashLastGetBlocksEnd = hashEnd;
93 PushMessage(
"getblocks",
CBlockLocator(pindexBegin), hashEnd);
103 int nBestReachability = -1;
105 LOCK(cs_mapLocalHost);
106 for (map<CNetAddr, LocalServiceInfo>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++)
108 int nScore = (*it).second.nScore;
109 int nReachability = (*it).first.GetReachabilityFrom(paddrPeer);
110 if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))
112 addr =
CService((*it).first, (*it).second.nPort);
113 nBestReachability = nReachability;
118 return nBestScore >= 0;
141 int nBytes = recv(hSocket, &c, 1, 0);
149 if (strLine.size() >= 9000)
152 else if (nBytes <= 0)
154 boost::this_thread::interruption_point();
166 if (!strLine.empty())
171 printf(
"socket closed\n");
178 printf(
"recv failed: %d\n", nErr);
187 void static AdvertizeLocal()
206 LOCK(cs_mapLocalHost);
207 vfReachable[net] = fFlag;
227 LOCK(cs_mapLocalHost);
228 bool fAlready = mapLocalHost.count(addr) > 0;
230 if (!fAlready || nScore >= info.
nScore) {
231 info.
nScore = nScore + (fAlready ? 1 : 0);
252 LOCK(cs_mapLocalHost);
253 vfLimited[net] = fLimited;
258 LOCK(cs_mapLocalHost);
259 return vfLimited[net];
271 LOCK(cs_mapLocalHost);
272 if (mapLocalHost.count(addr) == 0)
274 mapLocalHost[addr].nScore++;
285 LOCK(cs_mapLocalHost);
286 return mapLocalHost.count(addr) > 0;
292 LOCK(cs_mapLocalHost);
294 return vfReachable[net] && !vfLimited[net];
301 return error(
"GetMyExternalIP() : connection to %s failed", addrConnect.
ToString().c_str());
303 send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
317 if (pszKeyword == NULL)
319 if (strLine.find(pszKeyword) != string::npos)
321 strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
326 if (strLine.find(
"<") != string::npos)
327 strLine = strLine.substr(0, strLine.find(
"<"));
328 strLine = strLine.substr(strspn(strLine.c_str(),
" \t\n\r"));
329 while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
330 strLine.resize(strLine.size()-1);
332 printf(
"GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.
ToString().c_str());
340 return error(
"GetMyExternalIP() : connection closed");
347 const char* pszKeyword;
349 for (
int nLookup = 0; nLookup <= 1; nLookup++)
350 for (
int nHost = 1; nHost <= 2; nHost++)
358 addrConnect =
CService(
"91.198.22.70", 80);
362 CService addrIP(
"checkip.dyndns.org", 80,
true);
364 addrConnect = addrIP;
367 pszGet =
"GET / HTTP/1.1\r\n"
368 "Host: checkip.dyndns.org\r\n"
369 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
370 "Connection: close\r\n"
373 pszKeyword =
"Address:";
377 addrConnect =
CService(
"74.208.43.192", 80);
381 CService addrIP(
"www.showmyip.com", 80,
true);
383 addrConnect = addrIP;
386 pszGet =
"GET /simple/ HTTP/1.1\r\n"
387 "Host: www.showmyip.com\r\n"
388 "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
389 "Connection: close\r\n"
410 printf(
"GetMyExternalIP() returned %s\n", addrLocalHost.
ToStringIP().c_str());
459 if (pszDest == NULL) {
474 printf(
"trying connection %s lastseen=%.1fhrs\n",
475 pszDest ? pszDest : addrConnect.
ToString().c_str(),
485 printf(
"connected %s\n", pszDest ? pszDest : addrConnect.
ToString().c_str());
490 if (ioctlsocket(hSocket, FIONBIO, &nOne) ==
SOCKET_ERROR)
493 if (fcntl(hSocket, F_SETFL, O_NONBLOCK) ==
SOCKET_ERROR)
494 printf(
"ConnectSocket() : fcntl non-blocking setting failed, error %d\n", errno);
498 CNode* pnode =
new CNode(hSocket, addrConnect, pszDest ? pszDest :
"",
false);
520 printf(
"disconnecting node %s\n", addrName.c_str());
531 if (
this == pnodeSync)
547 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());
548 PushMessage(
"version", PROTOCOL_VERSION,
nLocalServices, nTime, addrYou, addrMe,
566 bool fResult =
false;
569 std::map<CNetAddr, int64>::iterator i = setBanned.find(ip);
570 if (i != setBanned.end())
572 int64 t = (*i).second;
584 printf(
"Warning: Local node %s misbehaving (delta: %d)!\n", addrName.c_str(), howmuch);
588 nMisbehavior += howmuch;
589 if (nMisbehavior >=
GetArg(
"-banscore", 100))
592 printf(
"Misbehaving: %s (%d -> %d) DISCONNECTING\n", addr.ToString().c_str(), nMisbehavior-howmuch, nMisbehavior);
595 if (setBanned[addr] < banTime)
596 setBanned[addr] = banTime;
598 CloseSocketDisconnect();
601 printf(
"Misbehaving: %s (%d -> %d)\n", addr.ToString().c_str(), nMisbehavior-howmuch, nMisbehavior);
606 #define X(name) stats.name = name
632 if (vRecvMsg.empty() ||
633 vRecvMsg.back().complete())
643 handled = msg.
readData(pch, nBytes);
658 unsigned int nRemaining = 24 - nHdrPos;
659 unsigned int nCopy = std::min(nRemaining, nBytes);
661 memcpy(&hdrbuf[nHdrPos], pch, nCopy);
672 catch (std::exception &e) {
682 vRecv.resize(hdr.nMessageSize);
689 unsigned int nRemaining = hdr.nMessageSize - nDataPos;
690 unsigned int nCopy = std::min(nRemaining, nBytes);
692 memcpy(&vRecv[nDataPos], pch, nCopy);
709 std::deque<CSerializeData>::iterator it = pnode->
vSendMsg.begin();
711 while (it != pnode->
vSendMsg.end()) {
733 printf(
"socket send error %d\n", nErr);
749 static list<CNode*> vNodesDisconnected;
753 unsigned int nPrevNodeCount = 0;
762 vector<CNode*> vNodesCopy =
vNodes;
763 BOOST_FOREACH(
CNode* pnode, vNodesCopy)
781 vNodesDisconnected.push_back(pnode);
786 list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
787 BOOST_FOREACH(
CNode* pnode, vNodesDisconnectedCopy)
792 bool fDelete =
false;
808 vNodesDisconnected.remove(pnode);
814 if (
vNodes.size() != nPrevNodeCount)
816 nPrevNodeCount =
vNodes.size();
824 struct timeval timeout;
826 timeout.tv_usec = 50000;
833 FD_ZERO(&fdsetError);
835 bool have_fds =
false;
837 BOOST_FOREACH(
SOCKET hListenSocket, vhListenSocket) {
838 FD_SET(hListenSocket, &fdsetRecv);
839 hSocketMax = max(hSocketMax, hListenSocket);
848 FD_SET(pnode->
hSocket, &fdsetError);
849 hSocketMax = max(hSocketMax, pnode->
hSocket);
869 if (lockSend && !pnode->
vSendMsg.empty()) {
870 FD_SET(pnode->
hSocket, &fdsetSend);
879 FD_SET(pnode->
hSocket, &fdsetRecv);
884 int nSelect = select(have_fds ? hSocketMax + 1 : 0,
885 &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
886 boost::this_thread::interruption_point();
893 printf(
"socket select error %d\n", nErr);
894 for (
unsigned int i = 0; i <= hSocketMax; i++)
895 FD_SET(i, &fdsetRecv);
898 FD_ZERO(&fdsetError);
906 BOOST_FOREACH(
SOCKET hListenSocket, vhListenSocket)
907 if (hListenSocket !=
INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
910 struct sockaddr_storage sockaddr;
912 struct sockaddr sockaddr;
914 socklen_t len =
sizeof(sockaddr);
915 SOCKET hSocket = accept(hListenSocket, (
struct sockaddr*)&sockaddr, &len);
920 if (!addr.
SetSockAddr((
const struct sockaddr*)&sockaddr))
921 printf(
"Warning: Unknown socket family\n");
934 printf(
"socket error accept failed: %d\n", nErr);
939 LOCK(cs_setservAddNodeAddresses);
946 printf(
"connection from %s dropped (banned)\n", addr.
ToString().c_str());
952 CNode* pnode =
new CNode(hSocket, addr,
"",
true);
965 vector<CNode*> vNodesCopy;
969 BOOST_FOREACH(
CNode* pnode, vNodesCopy)
972 BOOST_FOREACH(
CNode* pnode, vNodesCopy)
974 boost::this_thread::interruption_point();
981 if (FD_ISSET(pnode->
hSocket, &fdsetRecv) || FD_ISSET(pnode->
hSocket, &fdsetError))
988 char pchBuf[0x10000];
989 int nBytes = recv(pnode->
hSocket, pchBuf,
sizeof(pchBuf), MSG_DONTWAIT);
997 else if (nBytes == 0)
1001 printf(
"socket closed\n");
1004 else if (nBytes < 0)
1011 printf(
"socket recv error %d\n", nErr);
1024 if (FD_ISSET(pnode->
hSocket, &fdsetSend))
1045 printf(
"socket not sending\n");
1050 printf(
"socket inactivity timeout\n");
1057 BOOST_FOREACH(
CNode* pnode, vNodesCopy)
1074 void ThreadMapPort()
1077 const char * multicastif = 0;
1078 const char * minissdpdpath = 0;
1079 struct UPNPDev * devlist = 0;
1082 #ifndef UPNPDISCOVER_SUCCESS
1084 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1088 devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1091 struct UPNPUrls urls;
1092 struct IGDdatas data;
1095 r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr,
sizeof(lanaddr));
1099 char externalIPAddress[40];
1100 r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1101 if(r != UPNPCOMMAND_SUCCESS)
1102 printf(
"UPnP: GetExternalIPAddress() returned %d\n", r);
1105 if(externalIPAddress[0])
1107 printf(
"UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1111 printf(
"UPnP: GetExternalIPAddress failed.\n");
1119 #ifndef UPNPDISCOVER_SUCCESS
1121 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1122 port.c_str(), port.c_str(), lanaddr, strDesc.c_str(),
"TCP", 0);
1125 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1126 port.c_str(), port.c_str(), lanaddr, strDesc.c_str(),
"TCP", 0,
"0");
1129 if(r!=UPNPCOMMAND_SUCCESS)
1130 printf(
"AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1131 port.c_str(), port.c_str(), lanaddr, r, strupnperror(r));
1133 printf(
"UPnP Port Mapping successful.\n");;
1138 catch (boost::thread_interrupted)
1140 r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port.c_str(),
"TCP", 0);
1141 printf(
"UPNP_DeletePortMapping() returned : %d\n", r);
1142 freeUPNPDevlist(devlist); devlist = 0;
1143 FreeUPNPUrls(&urls);
1147 printf(
"No valid UPnP IGDs found\n");
1148 freeUPNPDevlist(devlist); devlist = 0;
1150 FreeUPNPUrls(&urls);
1156 static boost::thread* upnp_thread = NULL;
1161 upnp_thread->interrupt();
1162 upnp_thread->join();
1167 else if (upnp_thread) {
1168 upnp_thread->interrupt();
1169 upnp_thread->join();
1194 static const char *strMainNetDNSSeed[][2] = {
1195 {
"feathercoin.com",
"dnsseed.feathercoin.com"},
1196 {
"alltheco.in",
"dnsseed.alltheco.in"},
1197 {
"btcltcftc.com",
"dnsseed.btcltcftc.com"},
1198 {
"altcointech.net",
"dnsseed.fc.altcointech.net"},
1202 static const char *strTestNetDNSSeed[][2] = {
1203 {
"feathercoin.com",
"testnet-dnsseed.feathercoin.com"},
1209 static const char *(*strDNSSeed)[2] =
fTestNet ? strTestNetDNSSeed : strMainNetDNSSeed;
1213 printf(
"Loading addresses from DNS seeds (could take a while)\n");
1215 for (
unsigned int seed_idx = 0; strDNSSeed[seed_idx][0] != NULL; seed_idx++) {
1219 vector<CNetAddr> vaddr;
1220 vector<CAddress> vAdd;
1221 if (
LookupHost(strDNSSeed[seed_idx][1], vaddr))
1225 int nOneDay = 24*3600;
1228 vAdd.push_back(addr);
1232 addrman.
Add(vAdd,
CNetAddr(strDNSSeed[seed_idx][0],
true));
1236 printf(
"%d addresses found from DNS seeds\n", found);
1252 0xc49c0ed8, 0x1df9d243, 0xd9b75a40, 0xdc525e46, 0x72c321b1, 0x4eedeeb2, 0x18271787, 0xce725232,
1253 0x892aafc0, 0x979f6751, 0x2210f618, 0xfb529ed8, 0x66a74b3e, 0xef5d132e, 0x3b7a116c, 0x2fe45f55,
1254 0x1df9d243, 0xe41f7c70, 0x8f4cd262, 0xb5c29d62, 0x80f1f3a2, 0x47dc614d, 0x6f458b4e, 0x908caa56,
1255 0x553ef762, 0x5aec0852, 0x629a4f54, 0x6a10e13c, 0x4f41c547, 0x4476fd59, 0xcaedbc5a, 0x9f806dc1,
1256 0x1df9d243, 0xe41f7c70, 0x8f4cd262, 0xb5c29d62, 0x80f1f3a2, 0x47dc614d, 0x6f458b4e, 0x908caa56,
1257 0x553ef762, 0x5aec0852, 0x629a4f54, 0x6a10e13c, 0x4f41c547, 0x4476fd59, 0xcaedbc5a, 0x9f806dc1
1267 printf(
"Flushed %d addresses to peers.dat %"PRI64d"ms\n",
1271 void static ProcessOneShot()
1276 if (vOneShots.empty())
1278 strDest = vOneShots.front();
1279 vOneShots.pop_front();
1294 for (
int64 nLoop = 0;; nLoop++)
1297 BOOST_FOREACH(
string strAddr,
mapMultiArgs[
"-connect"])
1301 for (
int i = 0; i < 10 && i < nLoop; i++)
1319 boost::this_thread::interruption_point();
1324 std::vector<CAddress> vAdd;
1325 for (
unsigned int i = 0; i <
ARRAYLEN(pnSeed); i++)
1331 const int64 nOneWeek = 7*24*60*60;
1333 memcpy(&ip, &pnSeed[i],
sizeof(ip));
1336 vAdd.push_back(addr);
1349 set<vector<unsigned char> > setConnected;
1383 if (nANow - addr.
nLastTry < 600 && nTries < 30)
1387 if (addr.
GetPort() != GetDefaultPort() && nTries < 50)
1402 LOCK(cs_vAddedNodes);
1408 list<string> lAddresses(0);
1410 LOCK(cs_vAddedNodes);
1412 lAddresses.push_back(strAddNode);
1414 BOOST_FOREACH(
string& strAddNode, lAddresses) {
1424 for (
unsigned int i = 0;
true; i++)
1426 list<string> lAddresses(0);
1428 LOCK(cs_vAddedNodes);
1430 lAddresses.push_back(strAddNode);
1433 list<vector<CService> > lservAddressesToAdd(0);
1434 BOOST_FOREACH(
string& strAddNode, lAddresses)
1436 vector<CService> vservNode(0);
1439 lservAddressesToAdd.push_back(vservNode);
1441 LOCK(cs_setservAddNodeAddresses);
1442 BOOST_FOREACH(
CService& serv, vservNode)
1452 for (list<vector<CService> >::iterator it = lservAddressesToAdd.begin(); it != lservAddressesToAdd.end(); it++)
1453 BOOST_FOREACH(
CService& addrNode, *(it))
1454 if (pnode->
addr == addrNode)
1456 it = lservAddressesToAdd.erase(it);
1461 BOOST_FOREACH(vector<CService>& vserv, lservAddressesToAdd)
1477 boost::this_thread::interruption_point();
1481 FindNode(addrConnect.ToStringIPPort().c_str()))
1487 boost::this_thread::interruption_point();
1503 double static NodeSyncScore(
const CNode *pnode) {
1507 void static StartSync(
const vector<CNode*> &
vNodes) {
1508 CNode *pnodeNewSync = NULL;
1509 double dBestScore = 0;
1517 BOOST_FOREACH(
CNode* pnode, vNodes) {
1522 (pnode->
nVersion < NOBLKS_VERSION_START || pnode->
nVersion >= NOBLKS_VERSION_END)) {
1524 double dScore = NodeSyncScore(pnode);
1525 if (pnodeNewSync == NULL || dScore > dBestScore) {
1526 pnodeNewSync = pnode;
1527 dBestScore = dScore;
1534 pnodeSync = pnodeNewSync;
1543 bool fHaveSyncNode =
false;
1545 vector<CNode*> vNodesCopy;
1549 BOOST_FOREACH(
CNode* pnode, vNodesCopy) {
1551 if (pnode == pnodeSync)
1552 fHaveSyncNode =
true;
1557 StartSync(vNodesCopy);
1560 CNode* pnodeTrickle = NULL;
1561 if (!vNodesCopy.empty())
1562 pnodeTrickle = vNodesCopy[
GetRand(vNodesCopy.size())];
1566 BOOST_FOREACH(
CNode* pnode, vNodesCopy)
1588 boost::this_thread::interruption_point();
1596 boost::this_thread::interruption_point();
1601 BOOST_FOREACH(
CNode* pnode, vNodesCopy)
1622 struct sockaddr_storage sockaddr;
1624 struct sockaddr sockaddr;
1626 socklen_t len =
sizeof(sockaddr);
1627 if (!addrBind.
GetSockAddr((
struct sockaddr*)&sockaddr, &len))
1629 strError =
strprintf(
"Error: bind address family for %s not supported", addrBind.
ToString().c_str());
1630 printf(
"%s\n", strError.c_str());
1634 SOCKET hListenSocket = socket(((
struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
1637 strError =
strprintf(
"Error: Couldn't open socket for incoming connections (socket returned error %d)",
WSAGetLastError());
1638 printf(
"%s\n", strError.c_str());
1644 setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (
void*)&nOne,
sizeof(
int));
1650 setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (
void*)&nOne,
sizeof(
int));
1656 if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) ==
SOCKET_ERROR)
1658 if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) ==
SOCKET_ERROR)
1661 strError =
strprintf(
"Error: Couldn't set properties on socket for incoming connections (error %d)",
WSAGetLastError());
1662 printf(
"%s\n", strError.c_str());
1672 setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (
const char*)&nOne,
sizeof(
int));
1674 setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (
void*)&nOne,
sizeof(
int));
1678 int nProtLevel = 10 ;
1679 int nParameterId = 23 ;
1681 setsockopt(hListenSocket, IPPROTO_IPV6, nParameterId, (
const char*)&nProtLevel,
sizeof(
int));
1686 if (::bind(hListenSocket, (
struct sockaddr*)&sockaddr, len) ==
SOCKET_ERROR)
1690 strError =
strprintf(
_(
"Unable to bind to %s on this computer. Feathercoin is probably already running."), addrBind.
ToString().c_str());
1692 strError =
strprintf(
_(
"Unable to bind to %s on this computer (bind returned error %d, %s)"), addrBind.
ToString().c_str(), nErr, strerror(nErr));
1693 printf(
"%s\n", strError.c_str());
1701 strError =
strprintf(
"Error: Listening for incoming connections failed (listen returned error %d)",
WSAGetLastError());
1702 printf(
"%s\n", strError.c_str());
1706 vhListenSocket.push_back(hListenSocket);
1714 void static Discover()
1721 char pszHostName[1000] =
"";
1722 if (gethostname(pszHostName,
sizeof(pszHostName)) !=
SOCKET_ERROR)
1724 vector<CNetAddr> vaddr;
1727 BOOST_FOREACH (
const CNetAddr &addr, vaddr)
1735 struct ifaddrs* myaddrs;
1736 if (getifaddrs(&myaddrs) == 0)
1738 for (
struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1740 if (ifa->ifa_addr == NULL)
continue;
1741 if ((ifa->ifa_flags & IFF_UP) == 0)
continue;
1742 if (strcmp(ifa->ifa_name,
"lo") == 0)
continue;
1743 if (strcmp(ifa->ifa_name,
"lo0") == 0)
continue;
1744 if (ifa->ifa_addr->sa_family == AF_INET)
1746 struct sockaddr_in* s4 = (
struct sockaddr_in*)(ifa->ifa_addr);
1752 else if (ifa->ifa_addr->sa_family == AF_INET6)
1754 struct sockaddr_in6* s6 = (
struct sockaddr_in6*)(ifa->ifa_addr);
1761 freeifaddrs(myaddrs);
1772 if (semOutbound == NULL) {
1778 if (pnodeLocalHost == NULL)
1788 printf(
"DNS seeding disabled\n");
1820 for (
int i=0; i<MAX_OUTBOUND_CONNECTIONS; i++)
1821 semOutbound->
post();
1837 BOOST_FOREACH(
CNode* pnode, vNodes)
1840 BOOST_FOREACH(
SOCKET hListenSocket, vhListenSocket)
1846 BOOST_FOREACH(
CNode *pnode, vNodes)
1848 BOOST_FOREACH(
CNode *pnode, vNodesDisconnected)
1851 vNodesDisconnected.clear();
1854 delete pnodeLocalHost;
1855 pnodeLocalHost = NULL;
1892 mapRelay.insert(std::make_pair(inv, ss));
1896 BOOST_FOREACH(
CNode* pnode, vNodes)
bool error(const char *format,...)
void SetReachable(enum Network net, bool fFlag)
void GenerateBitcoins(bool fGenerate, CWallet *pwallet)
Run the miner threads.
void MoveTo(CSemaphoreGrant &grant)
Access to the (IP) address database (peers.dat)
#define strprintf(format,...)
bool GetLocal(CService &addr, const CNetAddr *paddrPeer)
void AddOneShot(string strDest)
unsigned short GetPort() const
CCriticalSection cs_filter
bool AddLocal(const CService &addr, int nScore)
CNode * FindNode(const CNetAddr &ip)
#define TRY_LOCK(cs, name)
STL-like map container that only keeps the N elements with the highest value.
void SetIP(const CNetAddr &ip)
std::string ToStringIP() const
static void ClearBanned()
bool GetMyExternalIP(CNetAddr &ipRet)
const std::string CLIENT_NAME
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
void ThreadOpenConnections()
void SetLimited(enum Network net, bool fLimited)
Make a particular network entirely off-limits (no automatic connects to it)
RAII-style semaphore lock.
deque< pair< int64, CInv > > vRelayExpiration
bool Add(const CAddress &addr, const CNetAddr &source, int64 nTimePenalty=0)
bool ConnectSocketByName(CService &addr, SOCKET &hSocketRet, const char *pszDest, int portDefault, int nTimeout)
Double ended buffer combining vector and stream-like interfaces.
void ThreadDNSAddressSeed()
unsigned short GetListenPort()
CCriticalSection cs_inventory
bool SeenLocal(const CService &addr)
vote for a local address
unsigned long long uint64
vector< std::string > vAddedNodes
void LoopForever(const char *name, Callable func, int64 msecs)
void RenameThread(const char *name)
#define WSAGetLastError()
void PushInventory(const CInv &inv)
limitedmap< CInv, int64 > mapAlreadyAskedFor(MAX_INV_SZ)
bool RecvLine(SOCKET hSocket, string &strLine)
std::deque< CInv > vRecvGetData
void ThreadSocketHandler()
bool NewThread(void(*pfn)(void *), void *parg)
Stochastical (IP) address manager.
CCriticalSection cs_vOneShots
std::deque< CNetMessage > vRecvMsg
unsigned int GetTotalRecvSize()
void CloseSocketDisconnect()
bool GetBoolArg(const std::string &strArg, bool fDefault)
Return boolean argument or default value.
bool Write(const CAddrMan &addr)
std::string FormatSubVersion(const std::string &name, int nClientVersion, const std::vector< std::string > &comments)
void AddressCurrentlyConnected(const CService &addr)
uint64 GetRand(uint64 nMax)
unsigned int ReceiveFloodSize()
bool SendMessages(CNode *pto, bool fSendTrickle)
Send queued protocol messages to be sent to a give node.
void ThreadMessageHandler()
A combination of a network address (CNetAddr) and a (TCP) port.
bool IsReachable(const CNetAddr &addr)
check whether a given address is in a network we can probably connect to
std::vector< char, zero_after_free_allocator< char > > CSerializeData
void TraceThread(const char *name, Callable func)
CClientUIInterface uiInterface
bool IsProxy(const CNetAddr &addr)
#define THREAD_PRIORITY_BELOW_NORMAL
bool ReceiveMsgBytes(const char *pch, unsigned int nBytes)
CCriticalSection cs_setservAddNodeAddresses
A CService with information about it as peer.
unsigned int SendBufferSize()
bool ConnectSocket(const CService &addrDest, SOCKET &hSocketRet, int nTimeout)
void RelayTransaction(const CTransaction &tx, const uint256 &hash)
void Attempt(const CService &addr, int64 nTime=GetAdjustedTime())
bool fSuccessfullyConnected
std::string ToString() const
bool OpenNetworkConnection(const CAddress &addrConnect, CSemaphoreGrant *grantOutbound=NULL, const char *strDest=NULL, bool fOneShot=false)
CNode * ConnectNode(CAddress addrConnect, const char *pszDest)
bool ProcessMessages(CNode *pfrom)
Process protocol messages received from a given node.
#define DUMP_ADDRESSES_INTERVAL
void ThreadGetMyExternalIP(void *parg)
int readData(const char *pch, unsigned int nBytes)
CCriticalSection cs_vAddedNodes
void SetThreadPriority(int nPriority)
void Connected(const CService &addr, int64 nTime=GetAdjustedTime())
boost::signals2::signal< void(int newNumConnections)> NotifyNumConnectionsChanged
Number of network connections changed.
std::vector< unsigned char > GetGroup() const
void SocketSendData(CNode *pnode)
IP address (IPv6, or IPv4 using mapped IPv6 range (::FFFF:0:0/96))
bool BindListenPort(const CService &addrBind, string &strError)
CCriticalSection cs_mapRelay
bool IsRelevantAndUpdate(const CTransaction &tx, const uint256 &hash)
CCriticalSection cs_vRecvMsg
void reserve(size_type n)
The block chain is a tree shaped structure starting with the genesis block at the root...
CSemaphoreGrant grantOutbound
static bool IsBanned(CNetAddr ip)
string FormatFullVersion()
std::string _(const char *psz)
Translation function: Call Translate signal on UI interface, which returns a boost::optional result...
bool Lookup(const char *pszName, std::vector< CService > &vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions)
static CCriticalSection cs_setBanned
CAddress Select(int nUnkBias=50)
unsigned int nTransactionsUpdated
CAddress GetLocalAddress(const CNetAddr *paddrPeer)
bool Misbehaving(int howmuch)
class CNetCleanup instance_of_cnetcleanup
int readHeader(const char *pch, unsigned int nBytes)
std::string GetArg(const std::string &strArg, const std::string &strDefault)
Return string argument or default value.
bool GetMyExternalIP2(const CService &addrConnect, const char *pszGet, const char *pszKeyword, CNetAddr &ipRet)
The basic transaction that is broadcasted on the network and contained in blocks. ...
Information about a peer.
bool LookupHost(const char *pszName, std::vector< CNetAddr > &vIP, unsigned int nMaxSolutions, bool fAllowLookup)
set< CNetAddr > setservAddNodeAddresses
bool SetSockAddr(const struct sockaddr *paddr)
CCriticalSection cs_vSend
void copyStats(CNodeStats &stats)
map< string, vector< string > > mapMultiArgs
void PushGetBlocks(CBlockIndex *pindexBegin, uint256 hashEnd)
static std::map< CNetAddr, int64 > setBanned
void ThreadOpenAddedConnections()
CCriticalSection cs_vNodes
bool GetSockAddr(struct sockaddr *paddr, socklen_t *addrlen) const
bool IsLimited(enum Network net)
void StartNode(boost::thread_group &threadGroup)
map< string, string > mapArgs
map< CInv, CDataStream > mapRelay
bool IsLocal(const CService &addr)
check whether a given address is potentially local
std::deque< CSerializeData > vSendMsg
void PushAddress(const CAddress &addr)
enum Network GetNetwork() const