Merge branch 'tmp-ipv6' into merge-ipv6
This commit is contained in:
commit
203f9e6c00
9 changed files with 559 additions and 184 deletions
36
src/init.cpp
36
src/init.cpp
|
@ -178,12 +178,17 @@ bool AppInit2(int argc, char* argv[])
|
|||
" -dbcache=<n> \t\t " + _("Set database cache size in megabytes (default: 25)") + "\n" +
|
||||
" -dblogsize=<n> \t\t " + _("Set database disk log size in megabytes (default: 100)") + "\n" +
|
||||
" -timeout=<n> \t " + _("Specify connection timeout (in milliseconds)") + "\n" +
|
||||
" -proxy=<ip:port> \t " + _("Connect through socks4 proxy") + "\n" +
|
||||
" -dns \t " + _("Allow DNS lookups for addnode and connect") + "\n" +
|
||||
" -proxy=<ip:port> \t " + _("Connect through socks proxy") + "\n" +
|
||||
" -socks=<n> \t " + _("Select the version of socks proxy to use (4 or 5, 5 is default)") + "\n" +
|
||||
" -dns \t " + _("Allow DNS lookups for -addnode, -seednode and -connect") + "\n" +
|
||||
" -proxydns \t " + _("Pass DNS requests to (SOCKS5) proxy") + "\n" +
|
||||
" -port=<port> \t\t " + _("Listen for connections on <port> (default: 8333 or testnet: 18333)") + "\n" +
|
||||
" -maxconnections=<n>\t " + _("Maintain at most <n> connections to peers (default: 125)") + "\n" +
|
||||
" -addnode=<ip> \t " + _("Add a node to connect to and attempt to keep the connection open") + "\n" +
|
||||
" -connect=<ip> \t\t " + _("Connect only to the specified node") + "\n" +
|
||||
" -seednode=<ip> \t\t " + _("Connect to a node to retrieve peer addresses, and disconnect") + "\n" +
|
||||
" -externalip=<ip> \t " + _("Specify your own public address") + "\n" +
|
||||
" -discover \t " + _("Try to discover public IP address (default: 1)") + "\n" +
|
||||
" -irc \t " + _("Find peers using internet relay chat (default: 0)") + "\n" +
|
||||
" -listen \t " + _("Accept connections from outside (default: 1)") + "\n" +
|
||||
#ifdef QT_GUI
|
||||
|
@ -527,6 +532,9 @@ bool AppInit2(int argc, char* argv[])
|
|||
}
|
||||
}
|
||||
|
||||
if (mapArgs.count("-connect"))
|
||||
SoftSetBoolArg("-dnsseed", false);
|
||||
|
||||
bool fTor = (fUseProxy && addrProxy.GetPort() == 9050);
|
||||
if (fTor)
|
||||
{
|
||||
|
@ -534,13 +542,20 @@ bool AppInit2(int argc, char* argv[])
|
|||
// Note: the GetBoolArg() calls for all of these must happen later.
|
||||
SoftSetBoolArg("-listen", false);
|
||||
SoftSetBoolArg("-irc", false);
|
||||
SoftSetBoolArg("-dnsseed", false);
|
||||
SoftSetBoolArg("-proxydns", true);
|
||||
SoftSetBoolArg("-upnp", false);
|
||||
SoftSetBoolArg("-dns", false);
|
||||
SoftSetBoolArg("-discover", false);
|
||||
}
|
||||
|
||||
fAllowDNS = GetBoolArg("-dns");
|
||||
fNameLookup = GetBoolArg("-dns");
|
||||
fProxyNameLookup = GetBoolArg("-proxydns");
|
||||
if (fProxyNameLookup)
|
||||
fNameLookup = true;
|
||||
fNoListen = !GetBoolArg("-listen", true);
|
||||
nSocksVersion = GetArg("-socks", 5);
|
||||
|
||||
BOOST_FOREACH(string strDest, mapMultiArgs["-seednode"])
|
||||
AddOneShot(strDest);
|
||||
|
||||
// Continue to put "/P2SH/" in the coinbase to monitor
|
||||
// BIP16 support.
|
||||
|
@ -558,15 +573,10 @@ bool AppInit2(int argc, char* argv[])
|
|||
}
|
||||
}
|
||||
|
||||
if (mapArgs.count("-addnode"))
|
||||
if (mapArgs.count("-externalip"))
|
||||
{
|
||||
BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
|
||||
{
|
||||
CAddress addr(CService(strAddr, GetDefaultPort(), fAllowDNS));
|
||||
addr.nTime = 0; // so it won't relay unless successfully connected
|
||||
if (addr.IsValid())
|
||||
addrman.Add(addr, CNetAddr("127.0.0.1"));
|
||||
}
|
||||
BOOST_FOREACH(string strAddr, mapMultiArgs["-externalip"])
|
||||
AddLocal(CNetAddr(strAddr, fNameLookup), LOCAL_MANUAL);
|
||||
}
|
||||
|
||||
if (mapArgs.count("-paytxfee"))
|
||||
|
|
13
src/irc.cpp
13
src/irc.cpp
|
@ -12,7 +12,6 @@ using namespace std;
|
|||
using namespace boost;
|
||||
|
||||
int nGotIRCAddresses = 0;
|
||||
bool fGotExternalIP = false;
|
||||
|
||||
void ThreadIRCSeed2(void* parg);
|
||||
|
||||
|
@ -216,7 +215,6 @@ void ThreadIRCSeed2(void* parg)
|
|||
printf("ThreadIRCSeed started\n");
|
||||
int nErrorWait = 10;
|
||||
int nRetryWait = 10;
|
||||
bool fNameInUse = false;
|
||||
|
||||
while (!fShutdown)
|
||||
{
|
||||
|
@ -248,9 +246,10 @@ void ThreadIRCSeed2(void* parg)
|
|||
return;
|
||||
}
|
||||
|
||||
CNetAddr addrLocal;
|
||||
string strMyName;
|
||||
if (addrLocalHost.IsRoutable() && !fUseProxy && !fNameInUse)
|
||||
strMyName = EncodeAddress(addrLocalHost);
|
||||
if (GetLocal(addrLocal, &addrConnect))
|
||||
strMyName = EncodeAddress(GetLocalAddress(&addrConnect));
|
||||
else
|
||||
strMyName = strprintf("x%u", GetRand(1000000000));
|
||||
|
||||
|
@ -265,7 +264,6 @@ void ThreadIRCSeed2(void* parg)
|
|||
if (nRet == 2)
|
||||
{
|
||||
printf("IRC name already in use\n");
|
||||
fNameInUse = true;
|
||||
Wait(10);
|
||||
continue;
|
||||
}
|
||||
|
@ -285,9 +283,8 @@ void ThreadIRCSeed2(void* parg)
|
|||
if (!fUseProxy && addrFromIRC.IsRoutable())
|
||||
{
|
||||
// IRC lets you to re-nick
|
||||
fGotExternalIP = true;
|
||||
addrLocalHost.SetIP(addrFromIRC);
|
||||
strMyName = EncodeAddress(addrLocalHost);
|
||||
AddLocal(addrFromIRC, LOCAL_IRC);
|
||||
strMyName = EncodeAddress(GetLocalAddress(&addrConnect));
|
||||
Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
|
||||
}
|
||||
}
|
||||
|
|
|
@ -8,6 +8,5 @@
|
|||
void ThreadIRCSeed(void* parg);
|
||||
|
||||
extern int nGotIRCAddresses;
|
||||
extern bool fGotExternalIP;
|
||||
|
||||
#endif
|
||||
|
|
29
src/main.cpp
29
src/main.cpp
|
@ -2312,6 +2312,12 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
|
|||
if (!vRecv.empty())
|
||||
vRecv >> pfrom->nStartingHeight;
|
||||
|
||||
if (pfrom->fInbound && addrMe.IsRoutable())
|
||||
{
|
||||
pfrom->addrLocal = addrMe;
|
||||
SeenLocal(addrMe);
|
||||
}
|
||||
|
||||
// Disconnect if we connected to ourself
|
||||
if (nNonce == nLocalHostNonce && nNonce > 1)
|
||||
{
|
||||
|
@ -2335,16 +2341,15 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
|
|||
if (!pfrom->fInbound)
|
||||
{
|
||||
// Advertise our address
|
||||
if (!fNoListen && !fUseProxy && addrLocalHost.IsRoutable() &&
|
||||
!IsInitialBlockDownload())
|
||||
if (!fNoListen && !fUseProxy && !IsInitialBlockDownload())
|
||||
{
|
||||
CAddress addr(addrLocalHost);
|
||||
addr.nTime = GetAdjustedTime();
|
||||
pfrom->PushAddress(addr);
|
||||
CAddress addr = GetLocalAddress(&pfrom->addr);
|
||||
if (addr.IsRoutable())
|
||||
pfrom->PushAddress(addr);
|
||||
}
|
||||
|
||||
// Get recent addresses
|
||||
if (pfrom->nVersion >= CADDR_TIME_VERSION || addrman.size() < 1000)
|
||||
if (pfrom->fOneShot || pfrom->nVersion >= CADDR_TIME_VERSION || addrman.size() < 1000)
|
||||
{
|
||||
pfrom->PushMessage("getaddr");
|
||||
pfrom->fGetAddr = true;
|
||||
|
@ -2360,7 +2365,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
|
|||
|
||||
// Ask the first connected node for block updates
|
||||
static int nAskedForBlocks = 0;
|
||||
if (!pfrom->fClient &&
|
||||
if (!pfrom->fClient && !pfrom->fOneShot &&
|
||||
(pfrom->nVersion < NOBLKS_VERSION_START ||
|
||||
pfrom->nVersion >= NOBLKS_VERSION_END) &&
|
||||
(nAskedForBlocks < 1 || vNodes.size() <= 1))
|
||||
|
@ -2458,6 +2463,8 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
|
|||
addrman.Add(vAddr, pfrom->addr, 2 * 60 * 60);
|
||||
if (vAddr.size() < 1000)
|
||||
pfrom->fGetAddr = false;
|
||||
if (pfrom->fOneShot)
|
||||
pfrom->fDisconnect = true;
|
||||
}
|
||||
|
||||
|
||||
|
@ -2979,11 +2986,11 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
|
|||
pnode->setAddrKnown.clear();
|
||||
|
||||
// Rebroadcast our address
|
||||
if (!fNoListen && !fUseProxy && addrLocalHost.IsRoutable())
|
||||
if (!fNoListen && !fUseProxy)
|
||||
{
|
||||
CAddress addr(addrLocalHost);
|
||||
addr.nTime = GetAdjustedTime();
|
||||
pnode->PushAddress(addr);
|
||||
CAddress addr = GetLocalAddress(&pnode->addr);
|
||||
if (addr.IsRoutable())
|
||||
pnode->PushAddress(addr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
346
src/net.cpp
346
src/net.cpp
|
@ -35,7 +35,7 @@ void ThreadOpenAddedConnections2(void* parg);
|
|||
void ThreadMapPort2(void* parg);
|
||||
#endif
|
||||
void ThreadDNSAddressSeed2(void* parg);
|
||||
bool OpenNetworkConnection(const CAddress& addrConnect);
|
||||
bool OpenNetworkConnection(const CAddress& addrConnect, const char *strDest = NULL, bool fOneShot = false);
|
||||
|
||||
|
||||
|
||||
|
@ -43,10 +43,10 @@ bool OpenNetworkConnection(const CAddress& addrConnect);
|
|||
// Global state variables
|
||||
//
|
||||
bool fClient = false;
|
||||
bool fAllowDNS = false;
|
||||
static bool fUseUPnP = false;
|
||||
uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
|
||||
CAddress addrLocalHost(CService("0.0.0.0", 0), nLocalServices);
|
||||
CCriticalSection cs_mapLocalHost;
|
||||
map<CNetAddr, int> mapLocalHost;
|
||||
static CNode* pnodeLocalHost = NULL;
|
||||
uint64 nLocalHostNonce = 0;
|
||||
array<int, THREAD_MAX> vnThreadsRunning;
|
||||
|
@ -60,6 +60,8 @@ deque<pair<int64, CInv> > vRelayExpiration;
|
|||
CCriticalSection cs_mapRelay;
|
||||
map<CInv, int64> mapAlreadyAskedFor;
|
||||
|
||||
static deque<string> vOneShots;
|
||||
CCriticalSection cs_vOneShots;
|
||||
|
||||
set<CNetAddr> setservAddNodeAddresses;
|
||||
CCriticalSection cs_setservAddNodeAddresses;
|
||||
|
@ -69,6 +71,12 @@ static int nOutbound = 0;
|
|||
static CConditionVariable condOutbound;
|
||||
|
||||
|
||||
void AddOneShot(string strDest)
|
||||
{
|
||||
LOCK(cs_vOneShots);
|
||||
vOneShots.push_back(strDest);
|
||||
}
|
||||
|
||||
unsigned short GetListenPort()
|
||||
{
|
||||
return (unsigned short)(GetArg("-port", GetDefaultPort()));
|
||||
|
@ -85,7 +93,45 @@ void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
|
|||
PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
|
||||
}
|
||||
|
||||
// find 'best' local address for a particular peer
|
||||
bool GetLocal(CNetAddr& addr, const CNetAddr *paddrPeer)
|
||||
{
|
||||
if (fUseProxy || mapArgs.count("-connect") || fNoListen)
|
||||
return false;
|
||||
|
||||
int nBestCount = -1;
|
||||
int nBestReachability = -1;
|
||||
{
|
||||
LOCK(cs_mapLocalHost);
|
||||
for (map<CNetAddr, int>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++)
|
||||
{
|
||||
int nCount = (*it).second;
|
||||
int nReachability = (*it).first.GetReachabilityFrom(paddrPeer);
|
||||
if (nReachability > nBestReachability || (nReachability == nBestReachability && nCount > nBestCount))
|
||||
{
|
||||
addr = (*it).first;
|
||||
nBestReachability = nReachability;
|
||||
nBestCount = nCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
return nBestCount >= 0;
|
||||
}
|
||||
|
||||
// get best local address for a particular peer as a CAddress
|
||||
CAddress GetLocalAddress(const CNetAddr *paddrPeer)
|
||||
{
|
||||
CAddress ret(CService("0.0.0.0",0),0);
|
||||
CNetAddr addr;
|
||||
if (GetLocal(addr, paddrPeer))
|
||||
{
|
||||
ret.SetIP(addr);
|
||||
ret.SetPort(GetListenPort());
|
||||
ret.nServices = nLocalServices;
|
||||
ret.nTime = GetAdjustedTime();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool RecvLine(SOCKET hSocket, string& strLine)
|
||||
{
|
||||
|
@ -138,6 +184,64 @@ bool RecvLine(SOCKET hSocket, string& strLine)
|
|||
}
|
||||
}
|
||||
|
||||
// used when scores of local addresses may have changed
|
||||
// pushes better local address to peers
|
||||
void static AdvertizeLocal()
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
BOOST_FOREACH(CNode* pnode, vNodes)
|
||||
{
|
||||
if (pnode->fSuccessfullyConnected)
|
||||
{
|
||||
CAddress addrLocal = GetLocalAddress(&pnode->addr);
|
||||
if (addrLocal.IsRoutable() && (CNetAddr)addrLocal != (CNetAddr)pnode->addrLocal)
|
||||
{
|
||||
pnode->PushAddress(addrLocal);
|
||||
pnode->addrLocal = addrLocal;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// learn a new local address
|
||||
bool AddLocal(const CNetAddr& addr, int nScore)
|
||||
{
|
||||
if (!addr.IsRoutable())
|
||||
return false;
|
||||
|
||||
printf("AddLocal(%s,%i)\n", addr.ToString().c_str(), nScore);
|
||||
|
||||
{
|
||||
LOCK(cs_mapLocalHost);
|
||||
mapLocalHost[addr] = std::max(nScore, mapLocalHost[addr]) + (mapLocalHost.count(addr) ? 1 : 0);
|
||||
}
|
||||
|
||||
AdvertizeLocal();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// vote for a local address
|
||||
bool SeenLocal(const CNetAddr& addr)
|
||||
{
|
||||
{
|
||||
LOCK(cs_mapLocalHost);
|
||||
if (mapLocalHost.count(addr) == 0)
|
||||
return false;
|
||||
mapLocalHost[addr]++;
|
||||
}
|
||||
|
||||
AdvertizeLocal();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// check whether a given address is potentially local
|
||||
bool IsLocal(const CNetAddr& addr)
|
||||
{
|
||||
LOCK(cs_mapLocalHost);
|
||||
return mapLocalHost.count(addr) > 0;
|
||||
}
|
||||
|
||||
|
||||
bool GetMyExternalIP2(const CService& addrConnect, const char* pszGet, const char* pszKeyword, CNetAddr& ipRet)
|
||||
|
@ -251,33 +355,11 @@ bool GetMyExternalIP(CNetAddr& ipRet)
|
|||
|
||||
void ThreadGetMyExternalIP(void* parg)
|
||||
{
|
||||
// Wait for IRC to get it first
|
||||
if (GetBoolArg("-irc", false))
|
||||
{
|
||||
for (int i = 0; i < 2 * 60; i++)
|
||||
{
|
||||
Sleep(1000);
|
||||
if (fGotExternalIP || fShutdown)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback in case IRC fails to get it
|
||||
CNetAddr addrLocalHost;
|
||||
if (GetMyExternalIP(addrLocalHost))
|
||||
{
|
||||
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();
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
BOOST_FOREACH(CNode* pnode, vNodes)
|
||||
pnode->PushAddress(addr);
|
||||
}
|
||||
}
|
||||
AddLocal(addrLocalHost, LOCAL_HTTP);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -307,6 +389,15 @@ CNode* FindNode(const CNetAddr& ip)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
CNode* FindNode(std::string addrName)
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
BOOST_FOREACH(CNode* pnode, vNodes)
|
||||
if (pnode->addrName == addrName)
|
||||
return (pnode);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CNode* FindNode(const CService& addr)
|
||||
{
|
||||
{
|
||||
|
@ -318,35 +409,38 @@ CNode* FindNode(const CService& addr)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
|
||||
CNode* ConnectNode(CAddress addrConnect, const char *pszDest, int64 nTimeout)
|
||||
{
|
||||
if ((CNetAddr)addrConnect == (CNetAddr)addrLocalHost)
|
||||
return NULL;
|
||||
if (pszDest == NULL) {
|
||||
if (IsLocal(addrConnect))
|
||||
return NULL;
|
||||
|
||||
// Look for an existing connection
|
||||
CNode* pnode = FindNode((CService)addrConnect);
|
||||
if (pnode)
|
||||
{
|
||||
if (nTimeout != 0)
|
||||
pnode->AddRef(nTimeout);
|
||||
else
|
||||
pnode->AddRef();
|
||||
return pnode;
|
||||
// Look for an existing connection
|
||||
CNode* pnode = FindNode((CService)addrConnect);
|
||||
if (pnode)
|
||||
{
|
||||
if (nTimeout != 0)
|
||||
pnode->AddRef(nTimeout);
|
||||
else
|
||||
pnode->AddRef();
|
||||
return pnode;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// debug print
|
||||
printf("trying connection %s lastseen=%.1fhrs\n",
|
||||
addrConnect.ToString().c_str(),
|
||||
(double)(addrConnect.nTime - GetAdjustedTime())/3600.0);
|
||||
|
||||
addrman.Attempt(addrConnect);
|
||||
pszDest ? pszDest : addrConnect.ToString().c_str(),
|
||||
pszDest ? 0 : (double)(addrConnect.nTime - GetAdjustedTime())/3600.0);
|
||||
|
||||
// Connect
|
||||
SOCKET hSocket;
|
||||
if (ConnectSocket(addrConnect, hSocket))
|
||||
if (pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, GetDefaultPort()) : ConnectSocket(addrConnect, hSocket))
|
||||
{
|
||||
addrman.Attempt(addrConnect);
|
||||
|
||||
/// debug print
|
||||
printf("connected %s\n", addrConnect.ToString().c_str());
|
||||
printf("connected %s\n", pszDest ? pszDest : addrConnect.ToString().c_str());
|
||||
|
||||
// Set to nonblocking
|
||||
#ifdef WIN32
|
||||
|
@ -359,11 +453,12 @@ CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
|
|||
#endif
|
||||
|
||||
// Add node
|
||||
CNode* pnode = new CNode(hSocket, addrConnect, false);
|
||||
CNode* pnode = new CNode(hSocket, addrConnect, pszDest ? pszDest : "", false);
|
||||
if (nTimeout != 0)
|
||||
pnode->AddRef(nTimeout);
|
||||
else
|
||||
pnode->AddRef();
|
||||
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
vNodes.push_back(pnode);
|
||||
|
@ -389,7 +484,7 @@ void CNode::CloseSocketDisconnect()
|
|||
{
|
||||
if (fDebug)
|
||||
printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
|
||||
printf("disconnecting node %s\n", addr.ToString().c_str());
|
||||
printf("disconnecting node %s\n", addrName.c_str());
|
||||
closesocket(hSocket);
|
||||
hSocket = INVALID_SOCKET;
|
||||
vRecv.clear();
|
||||
|
@ -406,7 +501,7 @@ void CNode::PushVersion()
|
|||
/// when NTP implemented, change to just nTime = GetAdjustedTime()
|
||||
int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
|
||||
CAddress addrYou = (fUseProxy ? CAddress(CService("0.0.0.0",0)) : addr);
|
||||
CAddress addrMe = (fUseProxy || !addrLocalHost.IsRoutable() ? CAddress(CService("0.0.0.0",0)) : addrLocalHost);
|
||||
CAddress addrMe = GetLocalAddress(&addr);
|
||||
RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
|
||||
PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
|
||||
nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight);
|
||||
|
@ -444,7 +539,7 @@ bool CNode::Misbehaving(int howmuch)
|
|||
{
|
||||
if (addr.IsLocal())
|
||||
{
|
||||
printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
|
||||
printf("Warning: local node %s misbehaving\n", addrName.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -458,7 +553,7 @@ bool CNode::Misbehaving(int howmuch)
|
|||
setBanned[addr] = banTime;
|
||||
}
|
||||
CloseSocketDisconnect();
|
||||
printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
|
||||
printf("Disconnected %s for misbehavior (score=%d)\n", addrName.c_str(), nMisbehavior);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
@ -675,7 +770,7 @@ void ThreadSocketHandler2(void* parg)
|
|||
else
|
||||
{
|
||||
printf("accepted connection %s\n", addr.ToString().c_str());
|
||||
CNode* pnode = new CNode(hSocket, addr, true);
|
||||
CNode* pnode = new CNode(hSocket, addr, "", true);
|
||||
pnode->AddRef();
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
|
@ -878,8 +973,7 @@ void ThreadMapPort2(void* parg)
|
|||
r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
|
||||
if (r == 1)
|
||||
{
|
||||
if (!addrLocalHost.IsRoutable())
|
||||
{
|
||||
if (GetBoolArg("-discover", true)) {
|
||||
char externalIPAddress[40];
|
||||
r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
|
||||
if(r != UPNPCOMMAND_SUCCESS)
|
||||
|
@ -889,9 +983,7 @@ void ThreadMapPort2(void* parg)
|
|||
if(externalIPAddress[0])
|
||||
{
|
||||
printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
|
||||
CAddress addrExternalFromUPnP(CService(externalIPAddress, 0), nLocalServices);
|
||||
if (addrExternalFromUPnP.IsRoutable())
|
||||
addrLocalHost = addrExternalFromUPnP;
|
||||
AddLocal(CNetAddr(externalIPAddress), LOCAL_UPNP);
|
||||
}
|
||||
else
|
||||
printf("UPnP: GetExternalIPAddress failed.\n");
|
||||
|
@ -1025,20 +1117,24 @@ void ThreadDNSAddressSeed2(void* parg)
|
|||
printf("Loading addresses from DNS seeds (could take a while)\n");
|
||||
|
||||
for (unsigned int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
|
||||
vector<CNetAddr> vaddr;
|
||||
vector<CAddress> vAdd;
|
||||
if (LookupHost(strDNSSeed[seed_idx][1], vaddr))
|
||||
{
|
||||
BOOST_FOREACH(CNetAddr& ip, vaddr)
|
||||
if (fProxyNameLookup) {
|
||||
AddOneShot(strDNSSeed[seed_idx][1]);
|
||||
} else {
|
||||
vector<CNetAddr> vaddr;
|
||||
vector<CAddress> vAdd;
|
||||
if (LookupHost(strDNSSeed[seed_idx][1], vaddr))
|
||||
{
|
||||
int nOneDay = 24*3600;
|
||||
CAddress addr = CAddress(CService(ip, GetDefaultPort()));
|
||||
addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
|
||||
vAdd.push_back(addr);
|
||||
found++;
|
||||
BOOST_FOREACH(CNetAddr& ip, vaddr)
|
||||
{
|
||||
int nOneDay = 24*3600;
|
||||
CAddress addr = CAddress(CService(ip, GetDefaultPort()));
|
||||
addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
|
||||
vAdd.push_back(addr);
|
||||
found++;
|
||||
}
|
||||
}
|
||||
addrman.Add(vAdd, CNetAddr(strDNSSeed[seed_idx][0], true));
|
||||
}
|
||||
addrman.Add(vAdd, CNetAddr(strDNSSeed[seed_idx][0], true));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1188,6 +1284,21 @@ void ThreadOpenConnections(void* parg)
|
|||
printf("ThreadOpenConnections exiting\n");
|
||||
}
|
||||
|
||||
void static ProcessOneShot()
|
||||
{
|
||||
string strDest;
|
||||
{
|
||||
LOCK(cs_vOneShots);
|
||||
if (vOneShots.empty())
|
||||
return;
|
||||
strDest = vOneShots.front();
|
||||
vOneShots.pop_front();
|
||||
}
|
||||
CAddress addr;
|
||||
if (!OpenNetworkConnection(addr, strDest.c_str(), true))
|
||||
AddOneShot(strDest);
|
||||
}
|
||||
|
||||
void ThreadOpenConnections2(void* parg)
|
||||
{
|
||||
printf("ThreadOpenConnections started\n");
|
||||
|
@ -1197,11 +1308,11 @@ void ThreadOpenConnections2(void* parg)
|
|||
{
|
||||
for (int64 nLoop = 0;; nLoop++)
|
||||
{
|
||||
ProcessOneShot();
|
||||
BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
|
||||
{
|
||||
CAddress addr(CService(strAddr, GetDefaultPort(), fAllowDNS));
|
||||
if (addr.IsValid())
|
||||
OpenNetworkConnection(addr);
|
||||
CAddress addr;
|
||||
OpenNetworkConnection(addr, strAddr.c_str());
|
||||
for (int i = 0; i < 10 && i < nLoop; i++)
|
||||
{
|
||||
Sleep(500);
|
||||
|
@ -1216,6 +1327,8 @@ void ThreadOpenConnections2(void* parg)
|
|||
int64 nStart = GetTime();
|
||||
loop
|
||||
{
|
||||
ProcessOneShot();
|
||||
|
||||
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
|
||||
Sleep(500);
|
||||
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
|
||||
|
@ -1277,7 +1390,7 @@ void ThreadOpenConnections2(void* parg)
|
|||
CAddress addr = addrman.Select(10 + min(nOutbound,8)*10);
|
||||
|
||||
// if we selected an invalid address, restart
|
||||
if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.GetGroup()) || addr == addrLocalHost)
|
||||
if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.GetGroup()) || IsLocal(addr))
|
||||
break;
|
||||
|
||||
nTries++;
|
||||
|
@ -1325,11 +1438,25 @@ void ThreadOpenAddedConnections2(void* parg)
|
|||
if (mapArgs.count("-addnode") == 0)
|
||||
return;
|
||||
|
||||
if (fProxyNameLookup) {
|
||||
while(!fShutdown) {
|
||||
BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"]) {
|
||||
CAddress addr;
|
||||
OpenNetworkConnection(addr, strAddNode.c_str());
|
||||
Sleep(500);
|
||||
}
|
||||
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
|
||||
Sleep(120000); // Retry every 2 minutes
|
||||
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
vector<vector<CService> > vservAddressesToAdd(0);
|
||||
BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"])
|
||||
{
|
||||
vector<CService> vservNode(0);
|
||||
if(Lookup(strAddNode.c_str(), vservNode, GetDefaultPort(), fAllowDNS, 0))
|
||||
if(Lookup(strAddNode.c_str(), vservNode, GetDefaultPort(), fNameLookup, 0))
|
||||
{
|
||||
vservAddressesToAdd.push_back(vservNode);
|
||||
{
|
||||
|
@ -1343,7 +1470,7 @@ void ThreadOpenAddedConnections2(void* parg)
|
|||
{
|
||||
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 fAllowDNS)
|
||||
// (keeping in mind that addnode entries can have many IPs if fNameLookup)
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
BOOST_FOREACH(CNode* pnode, vNodes)
|
||||
|
@ -1373,25 +1500,31 @@ void ThreadOpenAddedConnections2(void* parg)
|
|||
}
|
||||
}
|
||||
|
||||
bool OpenNetworkConnection(const CAddress& addrConnect)
|
||||
bool OpenNetworkConnection(const CAddress& addrConnect, const char *strDest, bool fOneShot)
|
||||
{
|
||||
//
|
||||
// Initiate outbound network connection
|
||||
//
|
||||
if (fShutdown)
|
||||
return false;
|
||||
if ((CNetAddr)addrConnect == (CNetAddr)addrLocalHost || !addrConnect.IsIPv4() ||
|
||||
FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect))
|
||||
if (!strDest)
|
||||
if (IsLocal(addrConnect) ||
|
||||
FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect) ||
|
||||
FindNode(addrConnect.ToStringIPPort().c_str()))
|
||||
return false;
|
||||
if (strDest && FindNode(strDest))
|
||||
return false;
|
||||
|
||||
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
|
||||
CNode* pnode = ConnectNode(addrConnect);
|
||||
CNode* pnode = ConnectNode(addrConnect, strDest);
|
||||
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
|
||||
if (fShutdown)
|
||||
return false;
|
||||
if (!pnode)
|
||||
return false;
|
||||
pnode->fNetworkNode = true;
|
||||
if (fOneShot)
|
||||
pnode->fOneShot = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
@ -1489,7 +1622,6 @@ bool BindListenPort(string& strError)
|
|||
{
|
||||
strError = "";
|
||||
int nOne = 1;
|
||||
addrLocalHost.SetPort(GetListenPort());
|
||||
|
||||
#ifdef WIN32
|
||||
// Initialize Windows Sockets
|
||||
|
@ -1565,18 +1697,10 @@ bool BindListenPort(string& strError)
|
|||
return true;
|
||||
}
|
||||
|
||||
void StartNode(void* parg)
|
||||
void static Discover()
|
||||
{
|
||||
#ifdef USE_UPNP
|
||||
#if USE_UPNP
|
||||
fUseUPnP = GetBoolArg("-upnp", true);
|
||||
#else
|
||||
fUseUPnP = GetBoolArg("-upnp", false);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (pnodeLocalHost == NULL)
|
||||
pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress(CService("127.0.0.1", 0), nLocalServices));
|
||||
if (!GetBoolArg("-discover", true))
|
||||
return;
|
||||
|
||||
#ifdef WIN32
|
||||
// Get local host ip
|
||||
|
@ -1588,11 +1712,7 @@ void StartNode(void* parg)
|
|||
{
|
||||
BOOST_FOREACH (const CNetAddr &addr, vaddr)
|
||||
{
|
||||
if (!addr.IsLocal())
|
||||
{
|
||||
addrLocalHost.SetIP(addr);
|
||||
break;
|
||||
}
|
||||
AddLocal(addr, LOCAL_IF);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1615,35 +1735,45 @@ void StartNode(void* parg)
|
|||
printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
|
||||
|
||||
// Take the first IP that isn't loopback 127.x.x.x
|
||||
CAddress addr(CService(s4->sin_addr, GetListenPort()), nLocalServices);
|
||||
if (addr.IsValid() && !addr.IsLocal())
|
||||
{
|
||||
addrLocalHost = addr;
|
||||
break;
|
||||
}
|
||||
CNetAddr addr(s4->sin_addr);
|
||||
AddLocal(addr, LOCAL_IF);
|
||||
}
|
||||
else if (ifa->ifa_addr->sa_family == AF_INET6)
|
||||
{
|
||||
struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
|
||||
if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
|
||||
printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
|
||||
|
||||
#ifdef USE_IPV6
|
||||
CNetAddr addr(s6->sin6_addr);
|
||||
AddLocal(addr, LOCAL_IF);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
freeifaddrs(myaddrs);
|
||||
}
|
||||
#endif
|
||||
printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
|
||||
|
||||
if (fUseProxy || mapArgs.count("-connect") || fNoListen)
|
||||
{
|
||||
// Proxies can't take incoming connections
|
||||
addrLocalHost.SetIP(CNetAddr("0.0.0.0"));
|
||||
printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
|
||||
}
|
||||
else
|
||||
if (!fUseProxy && !mapArgs.count("-connect") && !fNoListen)
|
||||
{
|
||||
CreateThread(ThreadGetMyExternalIP, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
void StartNode(void* parg)
|
||||
{
|
||||
#ifdef USE_UPNP
|
||||
#if USE_UPNP
|
||||
fUseUPnP = GetBoolArg("-upnp", true);
|
||||
#else
|
||||
fUseUPnP = GetBoolArg("-upnp", false);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (pnodeLocalHost == NULL)
|
||||
pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress(CService("127.0.0.1", 0), nLocalServices));
|
||||
|
||||
Discover();
|
||||
|
||||
//
|
||||
// Start threads
|
||||
|
|
30
src/net.h
30
src/net.h
|
@ -30,17 +30,36 @@ extern int nBestHeight;
|
|||
inline unsigned int ReceiveBufferSize() { return 1000*GetArg("-maxreceivebuffer", 10*1000); }
|
||||
inline unsigned int SendBufferSize() { return 1000*GetArg("-maxsendbuffer", 10*1000); }
|
||||
|
||||
void AddOneShot(std::string strDest);
|
||||
bool RecvLine(SOCKET hSocket, std::string& strLine);
|
||||
bool GetMyExternalIP(CNetAddr& ipRet);
|
||||
void AddressCurrentlyConnected(const CService& addr);
|
||||
CNode* FindNode(const CNetAddr& ip);
|
||||
CNode* FindNode(const CService& ip);
|
||||
CNode* ConnectNode(CAddress addrConnect, int64 nTimeout=0);
|
||||
CNode* ConnectNode(CAddress addrConnect, const char *strDest = NULL, int64 nTimeout=0);
|
||||
void MapPort(bool fMapPort);
|
||||
bool BindListenPort(std::string& strError=REF(std::string()));
|
||||
void StartNode(void* parg);
|
||||
bool StopNode();
|
||||
|
||||
enum
|
||||
{
|
||||
LOCAL_NONE,
|
||||
LOCAL_IF,
|
||||
LOCAL_UPNP,
|
||||
LOCAL_IRC,
|
||||
LOCAL_HTTP,
|
||||
LOCAL_MANUAL,
|
||||
|
||||
LOCAL_MAX
|
||||
};
|
||||
|
||||
bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
|
||||
bool SeenLocal(const CNetAddr& addr);
|
||||
bool IsLocal(const CNetAddr& addr);
|
||||
bool GetLocal(CNetAddr &addr, const CNetAddr *paddrPeer = NULL);
|
||||
CAddress GetLocalAddress(const CNetAddr *paddrPeer = NULL);
|
||||
|
||||
enum
|
||||
{
|
||||
MSG_TX = 1,
|
||||
|
@ -83,9 +102,7 @@ enum threadId
|
|||
};
|
||||
|
||||
extern bool fClient;
|
||||
extern bool fAllowDNS;
|
||||
extern uint64 nLocalServices;
|
||||
extern CAddress addrLocalHost;
|
||||
extern uint64 nLocalHostNonce;
|
||||
extern boost::array<int, THREAD_MAX> vnThreadsRunning;
|
||||
extern CAddrMan addrman;
|
||||
|
@ -120,8 +137,11 @@ public:
|
|||
int nHeaderStart;
|
||||
unsigned int nMessageStart;
|
||||
CAddress addr;
|
||||
std::string addrName;
|
||||
CNetAddr addrLocal;
|
||||
int nVersion;
|
||||
std::string strSubVer;
|
||||
bool fOneShot;
|
||||
bool fClient;
|
||||
bool fInbound;
|
||||
bool fNetworkNode;
|
||||
|
@ -157,7 +177,7 @@ public:
|
|||
CCriticalSection cs_inventory;
|
||||
std::multimap<int64, CInv> mapAskFor;
|
||||
|
||||
CNode(SOCKET hSocketIn, CAddress addrIn, bool fInboundIn=false) : vSend(SER_NETWORK, MIN_PROTO_VERSION), vRecv(SER_NETWORK, MIN_PROTO_VERSION)
|
||||
CNode(SOCKET hSocketIn, CAddress addrIn, std::string addrNameIn = "", bool fInboundIn=false) : vSend(SER_NETWORK, MIN_PROTO_VERSION), vRecv(SER_NETWORK, MIN_PROTO_VERSION)
|
||||
{
|
||||
nServices = 0;
|
||||
hSocket = hSocketIn;
|
||||
|
@ -168,8 +188,10 @@ public:
|
|||
nHeaderStart = -1;
|
||||
nMessageStart = -1;
|
||||
addr = addrIn;
|
||||
addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
|
||||
nVersion = 0;
|
||||
strSubVer = "";
|
||||
fOneShot = false;
|
||||
fClient = false; // set by version message
|
||||
fInbound = fInboundIn;
|
||||
fNetworkNode = false;
|
||||
|
|
275
src/netbase.cpp
275
src/netbase.cpp
|
@ -15,7 +15,10 @@
|
|||
using namespace std;
|
||||
|
||||
// Settings
|
||||
int nSocksVersion = 5;
|
||||
int fUseProxy = false;
|
||||
bool fProxyNameLookup = false;
|
||||
bool fNameLookup = false;
|
||||
CService addrProxy("127.0.0.1",9050);
|
||||
int nConnectTimeout = 5000;
|
||||
|
||||
|
@ -156,7 +159,149 @@ bool LookupNumeric(const char *pszName, CService& addr, int portDefault)
|
|||
return Lookup(pszName, addr, portDefault, false);
|
||||
}
|
||||
|
||||
bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
|
||||
bool static Socks4(const CService &addrDest, SOCKET& hSocket)
|
||||
{
|
||||
printf("SOCKS4 connecting %s\n", addrDest.ToString().c_str());
|
||||
if (!addrDest.IsIPv4())
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Proxy destination is not IPv4");
|
||||
}
|
||||
char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
|
||||
struct sockaddr_in addr;
|
||||
addrDest.GetSockAddr(&addr);
|
||||
memcpy(pszSocks4IP + 2, &addr.sin_port, 2);
|
||||
memcpy(pszSocks4IP + 4, &addr.sin_addr, 4);
|
||||
char* pszSocks4 = pszSocks4IP;
|
||||
int nSize = sizeof(pszSocks4IP);
|
||||
|
||||
int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
|
||||
if (ret != nSize)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error sending to proxy");
|
||||
}
|
||||
char pchRet[8];
|
||||
if (recv(hSocket, pchRet, 8, 0) != 8)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error reading proxy response");
|
||||
}
|
||||
if (pchRet[1] != 0x5a)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
if (pchRet[1] != 0x5b)
|
||||
printf("ERROR: Proxy returned error %d\n", pchRet[1]);
|
||||
return false;
|
||||
}
|
||||
printf("SOCKS4 connected %s\n", addrDest.ToString().c_str());
|
||||
return true;
|
||||
}
|
||||
|
||||
bool static Socks5(string strDest, int port, SOCKET& hSocket)
|
||||
{
|
||||
printf("SOCKS5 connecting %s\n", strDest.c_str());
|
||||
if (strDest.size() > 255)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Hostname too long");
|
||||
}
|
||||
char pszSocks5Init[] = "\5\1\0";
|
||||
char *pszSocks5 = pszSocks5Init;
|
||||
int nSize = sizeof(pszSocks5Init);
|
||||
|
||||
int ret = send(hSocket, pszSocks5, nSize, MSG_NOSIGNAL);
|
||||
if (ret != nSize)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error sending to proxy");
|
||||
}
|
||||
char pchRet1[2];
|
||||
if (recv(hSocket, pchRet1, 2, 0) != 2)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error reading proxy response");
|
||||
}
|
||||
if (pchRet1[0] != 0x05 || pchRet1[1] != 0x00)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Proxy failed to initialize");
|
||||
}
|
||||
string strSocks5("\5\1");
|
||||
strSocks5 += '\000'; strSocks5 += '\003';
|
||||
strSocks5 += static_cast<char>(std::min((int)strDest.size(), 255));
|
||||
strSocks5 += strDest;
|
||||
strSocks5 += static_cast<char>((port >> 8) & 0xFF);
|
||||
strSocks5 += static_cast<char>((port >> 0) & 0xFF);
|
||||
ret = send(hSocket, strSocks5.c_str(), strSocks5.size(), MSG_NOSIGNAL);
|
||||
if (ret != strSocks5.size())
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error sending to proxy");
|
||||
}
|
||||
char pchRet2[4];
|
||||
if (recv(hSocket, pchRet2, 4, 0) != 4)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error reading proxy response");
|
||||
}
|
||||
if (pchRet2[0] != 0x05)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Proxy failed to accept request");
|
||||
}
|
||||
if (pchRet2[1] != 0x00)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
switch (pchRet2[1])
|
||||
{
|
||||
case 0x01: return error("Proxy error: general failure");
|
||||
case 0x02: return error("Proxy error: connection not allowed");
|
||||
case 0x03: return error("Proxy error: network unreachable");
|
||||
case 0x04: return error("Proxy error: host unreachable");
|
||||
case 0x05: return error("Proxy error: connection refused");
|
||||
case 0x06: return error("Proxy error: TTL expired");
|
||||
case 0x07: return error("Proxy error: protocol error");
|
||||
case 0x08: return error("Proxy error: address type not supported");
|
||||
default: return error("Proxy error: unknown");
|
||||
}
|
||||
}
|
||||
if (pchRet2[2] != 0x00)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error: malformed proxy response");
|
||||
}
|
||||
char pchRet3[256];
|
||||
switch (pchRet2[3])
|
||||
{
|
||||
case 0x01: ret = recv(hSocket, pchRet3, 4, 0) != 4; break;
|
||||
case 0x04: ret = recv(hSocket, pchRet3, 16, 0) != 16; break;
|
||||
case 0x03:
|
||||
{
|
||||
ret = recv(hSocket, pchRet3, 1, 0) != 1;
|
||||
if (ret)
|
||||
return error("Error reading from proxy");
|
||||
int nRecv = pchRet3[0];
|
||||
ret = recv(hSocket, pchRet3, nRecv, 0) != nRecv;
|
||||
break;
|
||||
}
|
||||
default: closesocket(hSocket); return error("Error: malformed proxy response");
|
||||
}
|
||||
if (ret)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error reading from proxy");
|
||||
}
|
||||
if (recv(hSocket, pchRet3, 2, 0) != 2)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error reading from proxy");
|
||||
}
|
||||
printf("SOCKS5 connected %s\n", strDest.c_str());
|
||||
return true;
|
||||
}
|
||||
|
||||
bool static ConnectSocketDirectly(const CService &addrConnect, SOCKET& hSocketRet, int nTimeout)
|
||||
{
|
||||
hSocketRet = INVALID_SOCKET;
|
||||
|
||||
|
@ -168,12 +313,12 @@ bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
|
|||
setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
|
||||
#endif
|
||||
|
||||
bool fProxy = (fUseProxy && addrDest.IsRoutable());
|
||||
struct sockaddr_in sockaddr;
|
||||
if (fProxy)
|
||||
addrProxy.GetSockAddr(&sockaddr);
|
||||
else
|
||||
addrDest.GetSockAddr(&sockaddr);
|
||||
if (!addrConnect.GetSockAddr(&sockaddr))
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
u_long fNonblock = 1;
|
||||
|
@ -187,7 +332,6 @@ bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
|
|||
return false;
|
||||
}
|
||||
|
||||
|
||||
if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
|
||||
{
|
||||
// WSAEINVAL is here because some legacy version of winsock uses it
|
||||
|
@ -258,43 +402,81 @@ bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
|
|||
return false;
|
||||
}
|
||||
|
||||
hSocketRet = hSocket;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
|
||||
{
|
||||
SOCKET hSocket = INVALID_SOCKET;
|
||||
bool fProxy = (fUseProxy && addrDest.IsRoutable());
|
||||
|
||||
if (!ConnectSocketDirectly(fProxy ? addrProxy : addrDest, hSocket, nTimeout))
|
||||
return false;
|
||||
|
||||
if (fProxy)
|
||||
{
|
||||
printf("proxy connecting %s\n", addrDest.ToString().c_str());
|
||||
char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
|
||||
struct sockaddr_in addr;
|
||||
addrDest.GetSockAddr(&addr);
|
||||
memcpy(pszSocks4IP + 2, &addr.sin_port, 2);
|
||||
memcpy(pszSocks4IP + 4, &addr.sin_addr, 4);
|
||||
char* pszSocks4 = pszSocks4IP;
|
||||
int nSize = sizeof(pszSocks4IP);
|
||||
switch(nSocksVersion)
|
||||
{
|
||||
case 4:
|
||||
if (!Socks4(addrDest, hSocket))
|
||||
return false;
|
||||
break;
|
||||
|
||||
int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
|
||||
if (ret != nSize)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error sending to proxy");
|
||||
}
|
||||
char pchRet[8];
|
||||
if (recv(hSocket, pchRet, 8, 0) != 8)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
return error("Error reading proxy response");
|
||||
}
|
||||
if (pchRet[1] != 0x5a)
|
||||
{
|
||||
closesocket(hSocket);
|
||||
if (pchRet[1] != 0x5b)
|
||||
printf("ERROR: Proxy returned error %d\n", pchRet[1]);
|
||||
return false;
|
||||
}
|
||||
printf("proxy connected %s\n", addrDest.ToString().c_str());
|
||||
case 5:
|
||||
default:
|
||||
if (!Socks5(addrDest.ToStringIP(), addrDest.GetPort(), hSocket))
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
hSocketRet = hSocket;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault, int nTimeout)
|
||||
{
|
||||
string strDest(pszDest);
|
||||
int port = portDefault;
|
||||
|
||||
size_t colon = strDest.find_last_of(':');
|
||||
char *endp = NULL;
|
||||
int n = strtol(pszDest + colon + 1, &endp, 10);
|
||||
if (endp && *endp == 0 && n >= 0) {
|
||||
strDest = strDest.substr(0, colon);
|
||||
if (n > 0 && n < 0x10000)
|
||||
port = n;
|
||||
}
|
||||
if (strDest[0] == '[' && strDest[strDest.size()-1] == ']')
|
||||
strDest = strDest.substr(1, strDest.size()-2);
|
||||
|
||||
SOCKET hSocket = INVALID_SOCKET;
|
||||
CService addrResolved(CNetAddr(strDest, fNameLookup && !fProxyNameLookup), port);
|
||||
if (addrResolved.IsValid()) {
|
||||
addr = addrResolved;
|
||||
return ConnectSocket(addr, hSocketRet, nTimeout);
|
||||
}
|
||||
addr = CService("0.0.0.0:0");
|
||||
if (!fNameLookup)
|
||||
return false;
|
||||
if (!ConnectSocketDirectly(addrProxy, hSocket, nTimeout))
|
||||
return false;
|
||||
|
||||
switch(nSocksVersion)
|
||||
{
|
||||
case 4: return false;
|
||||
case 5:
|
||||
default:
|
||||
if (!Socks5(strDest, port, hSocket))
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
|
||||
hSocketRet = hSocket;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CNetAddr::Init()
|
||||
{
|
||||
memset(ip, 0, 16);
|
||||
|
@ -590,6 +772,29 @@ void CNetAddr::print() const
|
|||
printf("CNetAddr(%s)\n", ToString().c_str());
|
||||
}
|
||||
|
||||
// for IPv6 partners: for unknown/Teredo partners: for IPv4 partners:
|
||||
// 0 - unroutable // 0 - unroutable // 0 - unroutable
|
||||
// 1 - teredo // 1 - teredo // 1 - ipv4
|
||||
// 2 - tunneled ipv6 // 2 - tunneled ipv6
|
||||
// 3 - ipv4 // 3 - ipv6
|
||||
// 4 - ipv6 // 4 - ipv4
|
||||
int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const
|
||||
{
|
||||
if (!IsValid() || !IsRoutable())
|
||||
return 0;
|
||||
if (paddrPartner && paddrPartner->IsIPv4())
|
||||
return IsIPv4() ? 1 : 0;
|
||||
if (IsRFC4380())
|
||||
return 1;
|
||||
if (IsRFC3964() || IsRFC6052())
|
||||
return 2;
|
||||
bool fRealIPv6 = paddrPartner && !paddrPartner->IsRFC4380() && paddrPartner->IsValid() && paddrPartner->IsRoutable();
|
||||
if (fRealIPv6)
|
||||
return IsIPv4() ? 3 : 4;
|
||||
else
|
||||
return IsIPv4() ? 4 : 3;
|
||||
}
|
||||
|
||||
void CService::Init()
|
||||
{
|
||||
port = 0;
|
||||
|
|
|
@ -51,6 +51,7 @@ class CNetAddr
|
|||
int64 GetHash() const;
|
||||
bool GetInAddr(struct in_addr* pipv4Addr) const;
|
||||
std::vector<unsigned char> GetGroup() const;
|
||||
int GetReachabilityFrom(const CNetAddr *paddrPartner = NULL) const;
|
||||
void print() const;
|
||||
|
||||
#ifdef USE_IPV6
|
||||
|
@ -119,9 +120,13 @@ bool Lookup(const char *pszName, CService& addr, int portDefault = 0, bool fAllo
|
|||
bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault = 0, bool fAllowLookup = true, unsigned int nMaxSolutions = 0);
|
||||
bool LookupNumeric(const char *pszName, CService& addr, int portDefault = 0);
|
||||
bool ConnectSocket(const CService &addr, SOCKET& hSocketRet, int nTimeout = nConnectTimeout);
|
||||
bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault = 0, int nTimeout = nConnectTimeout);
|
||||
|
||||
// Settings
|
||||
extern int nSocksVersion;
|
||||
extern int fUseProxy;
|
||||
extern bool fProxyNameLookup;
|
||||
extern bool fNameLookup;
|
||||
extern CService addrProxy;
|
||||
|
||||
#endif
|
||||
|
|
|
@ -31,13 +31,13 @@ BOOST_AUTO_TEST_CASE(DoS_banning)
|
|||
{
|
||||
CNode::ClearBanned();
|
||||
CAddress addr1(ip(0xa0b0c001));
|
||||
CNode dummyNode1(INVALID_SOCKET, addr1, true);
|
||||
CNode dummyNode1(INVALID_SOCKET, addr1, "", true);
|
||||
dummyNode1.Misbehaving(100); // Should get banned
|
||||
BOOST_CHECK(CNode::IsBanned(addr1));
|
||||
BOOST_CHECK(!CNode::IsBanned(ip(0xa0b0c001|0x0000ff00))); // Different ip, not banned
|
||||
|
||||
CAddress addr2(ip(0xa0b0c002));
|
||||
CNode dummyNode2(INVALID_SOCKET, addr2, true);
|
||||
CNode dummyNode2(INVALID_SOCKET, addr2, "", true);
|
||||
dummyNode2.Misbehaving(50);
|
||||
BOOST_CHECK(!CNode::IsBanned(addr2)); // 2 not banned yet...
|
||||
BOOST_CHECK(CNode::IsBanned(addr1)); // ... but 1 still should be
|
||||
|
@ -50,7 +50,7 @@ BOOST_AUTO_TEST_CASE(DoS_banscore)
|
|||
CNode::ClearBanned();
|
||||
mapArgs["-banscore"] = "111"; // because 11 is my favorite number
|
||||
CAddress addr1(ip(0xa0b0c001));
|
||||
CNode dummyNode1(INVALID_SOCKET, addr1, true);
|
||||
CNode dummyNode1(INVALID_SOCKET, addr1, "", true);
|
||||
dummyNode1.Misbehaving(100);
|
||||
BOOST_CHECK(!CNode::IsBanned(addr1));
|
||||
dummyNode1.Misbehaving(10);
|
||||
|
@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE(DoS_bantime)
|
|||
SetMockTime(nStartTime); // Overrides future calls to GetTime()
|
||||
|
||||
CAddress addr(ip(0xa0b0c001));
|
||||
CNode dummyNode(INVALID_SOCKET, addr, true);
|
||||
CNode dummyNode(INVALID_SOCKET, addr, "", true);
|
||||
|
||||
dummyNode.Misbehaving(100);
|
||||
BOOST_CHECK(CNode::IsBanned(addr));
|
||||
|
|
Loading…
Reference in a new issue