No OneTemporary
Actions

Size

80 KB

Subscribers

None

View Options

	diff --git a/src/netbase.cpp b/src/netbase.cpp
	index ffd3ea68a..21fca4737 100644
	--- a/src/netbase.cpp
	+++ b/src/netbase.cpp
	@@ -1,1059 +1,1120 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2012 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "netbase.h"
	#include "util.h"

	#ifndef WIN32
	#include <sys/fcntl.h>
	#endif

	#include "strlcpy.h"
	#include <boost/algorithm/string/case_conv.hpp> // for to_lower()

	using namespace std;

	// Settings
	typedef std::pair<CService, int> proxyType;
	static proxyType proxyInfo[NET_MAX];
	static proxyType nameproxyInfo;
	int nConnectTimeout = 5000;
	bool fNameLookup = false;

	static const unsigned char pchIPv4[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };

	enum Network ParseNetwork(std::string net) {
	boost::to_lower(net);
	if (net == "ipv4") return NET_IPV4;
	if (net == "ipv6") return NET_IPV6;
	if (net == "tor") return NET_TOR;
	if (net == "i2p") return NET_I2P;
	return NET_UNROUTABLE;
	}

	void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {
	size_t colon = in.find_last_of(':');
	// if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
	bool fHaveColon = colon != in.npos;
	bool fBracketed = fHaveColon && (in[0]=='[' && in[colon-1]==']'); // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is safe
	bool fMultiColon = fHaveColon && (in.find_last_of(':',colon-1) != in.npos);
	if (fHaveColon && (colon==0 \|\| fBracketed \|\| !fMultiColon)) {
	char *endp = NULL;
	int n = strtol(in.c_str() + colon + 1, &endp, 10);
	if (endp && *endp == 0 && n >= 0) {
	in = in.substr(0, colon);
	if (n > 0 && n < 0x10000)
	portOut = n;
	}
	}
	if (in.size()>0 && in[0] == '[' && in[in.size()-1] == ']')
	hostOut = in.substr(1, in.size()-2);
	else
	hostOut = in;
	}

	bool static LookupIntern(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup)
	{
	vIP.clear();
	+
	+ {
	+ CNetAddr addr;
	+ if (addr.SetSpecial(std::string(pszName))) {
	+ vIP.push_back(addr);
	+ return true;
	+ }
	+ }
	+
	struct addrinfo aiHint;
	memset(&aiHint, 0, sizeof(struct addrinfo));

	aiHint.ai_socktype = SOCK_STREAM;
	aiHint.ai_protocol = IPPROTO_TCP;
	#ifdef WIN32
	# ifdef USE_IPV6
	aiHint.ai_family = AF_UNSPEC;
	# else
	aiHint.ai_family = AF_INET;
	# endif
	aiHint.ai_flags = fAllowLookup ? 0 : AI_NUMERICHOST;
	#else
	# ifdef USE_IPV6
	aiHint.ai_family = AF_UNSPEC;
	# else
	aiHint.ai_family = AF_INET;
	# endif
	aiHint.ai_flags = fAllowLookup ? AI_ADDRCONFIG : AI_NUMERICHOST;
	#endif
	struct addrinfo *aiRes = NULL;
	int nErr = getaddrinfo(pszName, NULL, &aiHint, &aiRes);
	if (nErr)
	return false;

	struct addrinfo *aiTrav = aiRes;
	while (aiTrav != NULL && (nMaxSolutions == 0 \|\| vIP.size() < nMaxSolutions))
	{
	if (aiTrav->ai_family == AF_INET)
	{
	assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in));
	vIP.push_back(CNetAddr(((struct sockaddr_in*)(aiTrav->ai_addr))->sin_addr));
	}

	#ifdef USE_IPV6
	if (aiTrav->ai_family == AF_INET6)
	{
	assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in6));
	vIP.push_back(CNetAddr(((struct sockaddr_in6*)(aiTrav->ai_addr))->sin6_addr));
	}
	#endif

	aiTrav = aiTrav->ai_next;
	}

	freeaddrinfo(aiRes);

	return (vIP.size() > 0);
	}

	bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup)
	{
	if (pszName[0] == 0)
	return false;
	char psz[256];
	char *pszHost = psz;
	strlcpy(psz, pszName, sizeof(psz));
	if (psz[0] == '[' && psz[strlen(psz)-1] == ']')
	{
	pszHost = psz+1;
	psz[strlen(psz)-1] = 0;
	}

	return LookupIntern(pszHost, vIP, nMaxSolutions, fAllowLookup);
	}

	bool LookupHostNumeric(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions)
	{
	return LookupHost(pszName, vIP, nMaxSolutions, false);
	}

	bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions)
	{
	if (pszName[0] == 0)
	return false;
	int port = portDefault;
	std::string hostname = "";
	SplitHostPort(std::string(pszName), port, hostname);

	std::vector<CNetAddr> vIP;
	bool fRet = LookupIntern(hostname.c_str(), vIP, nMaxSolutions, fAllowLookup);
	if (!fRet)
	return false;
	vAddr.resize(vIP.size());
	for (unsigned int i = 0; i < vIP.size(); i++)
	vAddr[i] = CService(vIP[i], port);
	return true;
	}

	bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup)
	{
	std::vector<CService> vService;
	bool fRet = Lookup(pszName, vService, portDefault, fAllowLookup, 1);
	if (!fRet)
	return false;
	addr = vService[0];
	return true;
	}

	bool LookupNumeric(const char *pszName, CService& addr, int portDefault)
	{
	return Lookup(pszName, addr, portDefault, false);
	}

	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;
	socklen_t len = sizeof(addr);
	if (!addrDest.GetSockAddr((struct sockaddr*)&addr, &len) \|\| addr.sin_family != AF_INET)
	{
	closesocket(hSocket);
	return error("Cannot get proxy destination address");
	}
	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;
	ssize_t nSize = sizeof(pszSocks5Init);

	ssize_t 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 != (ssize_t)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;

	#ifdef USE_IPV6
	struct sockaddr_storage sockaddr;
	#else
	struct sockaddr sockaddr;
	#endif
	socklen_t len = sizeof(sockaddr);
	if (!addrConnect.GetSockAddr((struct sockaddr*)&sockaddr, &len)) {
	printf("Cannot connect to %s: unsupported network\n", addrConnect.ToString().c_str());
	return false;
	}

	SOCKET hSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
	if (hSocket == INVALID_SOCKET)
	return false;
	#ifdef SO_NOSIGPIPE
	int set = 1;
	setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
	#endif

	#ifdef WIN32
	u_long fNonblock = 1;
	if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
	#else
	int fFlags = fcntl(hSocket, F_GETFL, 0);
	if (fcntl(hSocket, F_SETFL, fFlags \| O_NONBLOCK) == -1)
	#endif
	{
	closesocket(hSocket);
	return false;
	}

	if (connect(hSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)
	{
	// WSAEINVAL is here because some legacy version of winsock uses it
	if (WSAGetLastError() == WSAEINPROGRESS \|\| WSAGetLastError() == WSAEWOULDBLOCK \|\| WSAGetLastError() == WSAEINVAL)
	{
	struct timeval timeout;
	timeout.tv_sec = nTimeout / 1000;
	timeout.tv_usec = (nTimeout % 1000) * 1000;

	fd_set fdset;
	FD_ZERO(&fdset);
	FD_SET(hSocket, &fdset);
	int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
	if (nRet == 0)
	{
	printf("connection timeout\n");
	closesocket(hSocket);
	return false;
	}
	if (nRet == SOCKET_ERROR)
	{
	printf("select() for connection failed: %i\n",WSAGetLastError());
	closesocket(hSocket);
	return false;
	}
	socklen_t nRetSize = sizeof(nRet);
	#ifdef WIN32
	if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
	#else
	if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
	#endif
	{
	printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
	closesocket(hSocket);
	return false;
	}
	if (nRet != 0)
	{
	printf("connect() failed after select(): %s\n",strerror(nRet));
	closesocket(hSocket);
	return false;
	}
	}
	#ifdef WIN32
	else if (WSAGetLastError() != WSAEISCONN)
	#else
	else
	#endif
	{
	printf("connect() failed: %i\n",WSAGetLastError());
	closesocket(hSocket);
	return false;
	}
	}

	// this isn't even strictly necessary
	// CNode::ConnectNode immediately turns the socket back to non-blocking
	// but we'll turn it back to blocking just in case
	#ifdef WIN32
	fNonblock = 0;
	if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
	#else
	fFlags = fcntl(hSocket, F_GETFL, 0);
	if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
	#endif
	{
	closesocket(hSocket);
	return false;
	}

	hSocketRet = hSocket;
	return true;
	}

	bool SetProxy(enum Network net, CService addrProxy, int nSocksVersion) {
	assert(net >= 0 && net < NET_MAX);
	if (nSocksVersion != 0 && nSocksVersion != 4 && nSocksVersion != 5)
	return false;
	if (nSocksVersion != 0 && !addrProxy.IsValid())
	return false;
	proxyInfo[net] = std::make_pair(addrProxy, nSocksVersion);
	return true;
	}

	bool GetProxy(enum Network net, CService &addrProxy) {
	assert(net >= 0 && net < NET_MAX);
	if (!proxyInfo[net].second)
	return false;
	addrProxy = proxyInfo[net].first;
	return true;
	}

	bool SetNameProxy(CService addrProxy, int nSocksVersion) {
	if (nSocksVersion != 0 && nSocksVersion != 5)
	return false;
	if (nSocksVersion != 0 && !addrProxy.IsValid())
	return false;
	nameproxyInfo = std::make_pair(addrProxy, nSocksVersion);
	return true;
	}

	bool GetNameProxy() {
	return nameproxyInfo.second != 0;
	}

	bool IsProxy(const CNetAddr &addr) {
	for (int i=0; i<NET_MAX; i++) {
	if (proxyInfo[i].second && (addr == (CNetAddr)proxyInfo[i].first))
	return true;
	}
	return false;
	}

	bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
	{
	const proxyType &proxy = proxyInfo[addrDest.GetNetwork()];

	// no proxy needed
	if (!proxy.second)
	return ConnectSocketDirectly(addrDest, hSocketRet, nTimeout);

	SOCKET hSocket = INVALID_SOCKET;

	// first connect to proxy server
	if (!ConnectSocketDirectly(proxy.first, hSocket, nTimeout))
	return false;

	// do socks negotiation
	switch (proxy.second) {
	case 4:
	if (!Socks4(addrDest, hSocket))
	return false;
	break;
	case 5:
	if (!Socks5(addrDest.ToStringIP(), addrDest.GetPort(), hSocket))
	return false;
	break;
	default:
	return false;
	}

	hSocketRet = hSocket;
	return true;
	}

	bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault, int nTimeout)
	{
	string strDest;
	int port = portDefault;
	SplitHostPort(string(pszDest), port, strDest);

	SOCKET hSocket = INVALID_SOCKET;
	CService addrResolved(CNetAddr(strDest, fNameLookup && !nameproxyInfo.second), port);
	if (addrResolved.IsValid()) {
	addr = addrResolved;
	return ConnectSocket(addr, hSocketRet, nTimeout);
	}
	addr = CService("0.0.0.0:0");
	if (!nameproxyInfo.second)
	return false;
	if (!ConnectSocketDirectly(nameproxyInfo.first, hSocket, nTimeout))
	return false;

	switch(nameproxyInfo.second)
	{
	default:
	case 4: return false;
	case 5:
	if (!Socks5(strDest, port, hSocket))
	return false;
	break;
	}

	hSocketRet = hSocket;
	return true;
	}

	void CNetAddr::Init()
	{
	memset(ip, 0, 16);
	}

	void CNetAddr::SetIP(const CNetAddr& ipIn)
	{
	memcpy(ip, ipIn.ip, sizeof(ip));
	}

	+static const unsigned char pchOnionCat[] = {0xFD,0x87,0xD8,0x7E,0xEB,0x43};
	+static const unsigned char pchGarliCat[] = {0xFD,0x60,0xDB,0x4D,0xDD,0xB5};
	+
	+bool CNetAddr::SetSpecial(const std::string &strName)
	+{
	+ if (strName.size()>6 && strName.substr(strName.size() - 6, 6) == ".onion") {
	+ std::vector<unsigned char> vchAddr = DecodeBase32(strName.substr(0, strName.size() - 6).c_str());
	+ if (vchAddr.size() != 16-sizeof(pchOnionCat))
	+ return false;
	+ memcpy(ip, pchOnionCat, sizeof(pchOnionCat));
	+ for (unsigned int i=0; i<16-sizeof(pchOnionCat); i++)
	+ ip[i + sizeof(pchOnionCat)] = vchAddr[i];
	+ return true;
	+ }
	+ if (strName.size()>11 && strName.substr(strName.size() - 11, 11) == ".oc.b32.i2p") {
	+ std::vector<unsigned char> vchAddr = DecodeBase32(strName.substr(0, strName.size() - 11).c_str());
	+ if (vchAddr.size() != 16-sizeof(pchGarliCat))
	+ return false;
	+ memcpy(ip, pchOnionCat, sizeof(pchGarliCat));
	+ for (unsigned int i=0; i<16-sizeof(pchGarliCat); i++)
	+ ip[i + sizeof(pchGarliCat)] = vchAddr[i];
	+ return true;
	+ }
	+ return false;
	+}
	+
	CNetAddr::CNetAddr()
	{
	Init();
	}

	CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)
	{
	memcpy(ip, pchIPv4, 12);
	memcpy(ip+12, &ipv4Addr, 4);
	}

	#ifdef USE_IPV6
	CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr)
	{
	memcpy(ip, &ipv6Addr, 16);
	}
	#endif

	CNetAddr::CNetAddr(const char *pszIp, bool fAllowLookup)
	{
	Init();
	std::vector<CNetAddr> vIP;
	if (LookupHost(pszIp, vIP, 1, fAllowLookup))
	*this = vIP[0];
	}

	CNetAddr::CNetAddr(const std::string &strIp, bool fAllowLookup)
	{
	Init();
	std::vector<CNetAddr> vIP;
	if (LookupHost(strIp.c_str(), vIP, 1, fAllowLookup))
	*this = vIP[0];
	}

	int CNetAddr::GetByte(int n) const
	{
	return ip[15-n];
	}

	bool CNetAddr::IsIPv4() const
	{
	return (memcmp(ip, pchIPv4, sizeof(pchIPv4)) == 0);
	}

	bool CNetAddr::IsIPv6() const
	{
	- return (!IsIPv4());
	+ return (!IsIPv4() && !IsTor() && !IsI2P());
	}

	bool CNetAddr::IsRFC1918() const
	{
	return IsIPv4() && (
	GetByte(3) == 10 \|\|
	(GetByte(3) == 192 && GetByte(2) == 168) \|\|
	(GetByte(3) == 172 && (GetByte(2) >= 16 && GetByte(2) <= 31)));
	}

	bool CNetAddr::IsRFC3927() const
	{
	return IsIPv4() && (GetByte(3) == 169 && GetByte(2) == 254);
	}

	bool CNetAddr::IsRFC3849() const
	{
	return GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x0D && GetByte(12) == 0xB8;
	}

	bool CNetAddr::IsRFC3964() const
	{
	return (GetByte(15) == 0x20 && GetByte(14) == 0x02);
	}

	bool CNetAddr::IsRFC6052() const
	{
	static const unsigned char pchRFC6052[] = {0,0x64,0xFF,0x9B,0,0,0,0,0,0,0,0};
	return (memcmp(ip, pchRFC6052, sizeof(pchRFC6052)) == 0);
	}

	bool CNetAddr::IsRFC4380() const
	{
	return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 && GetByte(12) == 0);
	}

	bool CNetAddr::IsRFC4862() const
	{
	static const unsigned char pchRFC4862[] = {0xFE,0x80,0,0,0,0,0,0};
	return (memcmp(ip, pchRFC4862, sizeof(pchRFC4862)) == 0);
	}

	bool CNetAddr::IsRFC4193() const
	{
	return ((GetByte(15) & 0xFE) == 0xFC);
	}

	bool CNetAddr::IsRFC6145() const
	{
	static const unsigned char pchRFC6145[] = {0,0,0,0,0,0,0,0,0xFF,0xFF,0,0};
	return (memcmp(ip, pchRFC6145, sizeof(pchRFC6145)) == 0);
	}

	bool CNetAddr::IsRFC4843() const
	{
	return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && (GetByte(12) & 0xF0) == 0x10);
	}

	-bool CNetAddr::IsOnionCat() const
	+bool CNetAddr::IsTor() const
	{
	- static const unsigned char pchOnionCat[] = {0xFD,0x87,0xD8,0x7E,0xEB,0x43};
	return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0);
	}

	-bool CNetAddr::IsGarliCat() const
	+bool CNetAddr::IsI2P() const
	{
	- static const unsigned char pchGarliCat[] = {0xFD,0x60,0xDB,0x4D,0xDD,0xB5};
	return (memcmp(ip, pchGarliCat, sizeof(pchGarliCat)) == 0);
	}

	bool CNetAddr::IsLocal() const
	{
	// IPv4 loopback
	if (IsIPv4() && (GetByte(3) == 127 \|\| GetByte(3) == 0))
	return true;

	// IPv6 loopback (::1/128)
	static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
	if (memcmp(ip, pchLocal, 16) == 0)
	return true;

	return false;
	}

	bool CNetAddr::IsMulticast() const
	{
	return (IsIPv4() && (GetByte(3) & 0xF0) == 0xE0)
	\|\| (GetByte(15) == 0xFF);
	}

	bool CNetAddr::IsValid() const
	{
	// Clean up 3-byte shifted addresses caused by garbage in size field
	// of addr messages from versions before 0.2.9 checksum.
	// Two consecutive addr messages look like this:
	// header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26 addr26 addr26...
	// so if the first length field is garbled, it reads the second batch
	// of addr misaligned by 3 bytes.
	if (memcmp(ip, pchIPv4+3, sizeof(pchIPv4)-3) == 0)
	return false;

	// unspecified IPv6 address (::/128)
	unsigned char ipNone[16] = {};
	if (memcmp(ip, ipNone, 16) == 0)
	return false;

	// documentation IPv6 address
	if (IsRFC3849())
	return false;

	if (IsIPv4())
	{
	// INADDR_NONE
	uint32_t ipNone = INADDR_NONE;
	if (memcmp(ip+12, &ipNone, 4) == 0)
	return false;

	// 0
	ipNone = 0;
	if (memcmp(ip+12, &ipNone, 4) == 0)
	return false;
	}

	return true;
	}

	bool CNetAddr::IsRoutable() const
	{
	- return IsValid() && !(IsRFC1918() \|\| IsRFC3927() \|\| IsRFC4862() \|\| (IsRFC4193() && !IsOnionCat() && !IsGarliCat()) \|\| IsRFC4843() \|\| IsLocal());
	+ return IsValid() && !(IsRFC1918() \|\| IsRFC3927() \|\| IsRFC4862() \|\| (IsRFC4193() && !IsTor() && !IsI2P()) \|\| IsRFC4843() \|\| IsLocal());
	}

	enum Network CNetAddr::GetNetwork() const
	{
	if (!IsRoutable())
	return NET_UNROUTABLE;

	if (IsIPv4())
	return NET_IPV4;

	- if (IsOnionCat())
	+ if (IsTor())
	return NET_TOR;

	- if (IsGarliCat())
	+ if (IsI2P())
	return NET_I2P;

	return NET_IPV6;
	}

	std::string CNetAddr::ToStringIP() const
	{
	+ if (IsTor())
	+ return EncodeBase32(&ip[6], 10) + ".onion";
	+ if (IsI2P())
	+ return EncodeBase32(&ip[6], 10) + ".oc.b32.i2p";
	CService serv(*this, 0);
	#ifdef USE_IPV6
	struct sockaddr_storage sockaddr;
	#else
	struct sockaddr sockaddr;
	#endif
	socklen_t socklen = sizeof(sockaddr);
	if (serv.GetSockAddr((struct sockaddr*)&sockaddr, &socklen)) {
	char name[1025] = "";
	if (!getnameinfo((const struct sockaddr*)&sockaddr, socklen, name, sizeof(name), NULL, 0, NI_NUMERICHOST))
	return std::string(name);
	}
	- if (IsIPv4())
	+ if (IsIPv4())
	return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1), GetByte(0));
	else
	return strprintf("%x:%x:%x:%x:%x:%x:%x:%x",
	GetByte(15) << 8 \| GetByte(14), GetByte(13) << 8 \| GetByte(12),
	GetByte(11) << 8 \| GetByte(10), GetByte(9) << 8 \| GetByte(8),
	GetByte(7) << 8 \| GetByte(6), GetByte(5) << 8 \| GetByte(4),
	GetByte(3) << 8 \| GetByte(2), GetByte(1) << 8 \| GetByte(0));
	}

	std::string CNetAddr::ToString() const
	{
	return ToStringIP();
	}

	bool operator==(const CNetAddr& a, const CNetAddr& b)
	{
	return (memcmp(a.ip, b.ip, 16) == 0);
	}

	bool operator!=(const CNetAddr& a, const CNetAddr& b)
	{
	return (memcmp(a.ip, b.ip, 16) != 0);
	}

	bool operator<(const CNetAddr& a, const CNetAddr& b)
	{
	return (memcmp(a.ip, b.ip, 16) < 0);
	}

	bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const
	{
	if (!IsIPv4())
	return false;
	memcpy(pipv4Addr, ip+12, 4);
	return true;
	}

	#ifdef USE_IPV6
	bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const
	{
	memcpy(pipv6Addr, ip, 16);
	return true;
	}
	#endif

	// get canonical identifier of an address' group
	// no two connections will be attempted to addresses with the same group
	std::vector<unsigned char> CNetAddr::GetGroup() const
	{
	std::vector<unsigned char> vchRet;
	int nClass = NET_IPV6;
	int nStartByte = 0;
	int nBits = 16;

	// all local addresses belong to the same group
	if (IsLocal())
	{
	nClass = 255;
	nBits = 0;
	}

	// all unroutable addresses belong to the same group
	if (!IsRoutable())
	{
	nClass = NET_UNROUTABLE;
	nBits = 0;
	}
	// for IPv4 addresses, '1' + the 16 higher-order bits of the IP
	// includes mapped IPv4, SIIT translated IPv4, and the well-known prefix
	else if (IsIPv4() \|\| IsRFC6145() \|\| IsRFC6052())
	{
	nClass = NET_IPV4;
	nStartByte = 12;
	}
	// for 6to4 tunneled addresses, use the encapsulated IPv4 address
	else if (IsRFC3964())
	{
	nClass = NET_IPV4;
	nStartByte = 2;
	}
	// for Teredo-tunneled IPv6 addresses, use the encapsulated IPv4 address
	else if (IsRFC4380())
	{
	vchRet.push_back(NET_IPV4);
	vchRet.push_back(GetByte(3) ^ 0xFF);
	vchRet.push_back(GetByte(2) ^ 0xFF);
	return vchRet;
	}
	+ else if (IsTor())
	+ {
	+ nClass = NET_TOR;
	+ nStartByte = 6;
	+ nBits = 4;
	+ }
	+ else if (IsI2P())
	+ {
	+ nClass = NET_I2P;
	+ nStartByte = 6;
	+ nBits = 4;
	+ }
	// for he.net, use /36 groups
	else if (GetByte(15) == 0x20 && GetByte(14) == 0x11 && GetByte(13) == 0x04 && GetByte(12) == 0x70)
	nBits = 36;
	// for the rest of the IPv6 network, use /32 groups
	else
	nBits = 32;

	vchRet.push_back(nClass);
	while (nBits >= 8)
	{
	vchRet.push_back(GetByte(15 - nStartByte));
	nStartByte++;
	nBits -= 8;
	}
	if (nBits > 0)
	vchRet.push_back(GetByte(15 - nStartByte) \| ((1 << nBits) - 1));

	return vchRet;
	}

	uint64 CNetAddr::GetHash() const
	{
	uint256 hash = Hash(&ip[0], &ip[16]);
	uint64 nRet;
	memcpy(&nRet, &hash, sizeof(nRet));
	return nRet;
	}

	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
	+// for IPv6 partners: for unknown/Teredo partners: for IPv4 partners: for Tor partners: for I2P partners:
	+// 0 - unroutable // 0 - unroutable // 0 - unroutable // 0 - unroutable // 0 - unroutable
	+// 1 - teredo // 1 - teredo // 1 - ipv4 // 1 - the rest // 1 - the rest
	+// 2 - tunneled ipv6 // 2 - tunneled ipv6 // 2 - ip4 // 2 - I2P
	+// 3 - ipv4 // 3 - ipv6 // 3 - tor
	// 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 (paddrPartner && paddrPartner->IsTor()) {
	+ if (IsIPv4())
	+ return 2;
	+ if (IsTor())
	+ return 3;
	+ return 1;
	+ }
	+ if (paddrPartner && paddrPartner->IsI2P()) {
	+ if (IsI2P())
	+ return 2;
	+ return 1;
	+ }
	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;
	}

	CService::CService()
	{
	Init();
	}

	CService::CService(const CNetAddr& cip, unsigned short portIn) : CNetAddr(cip), port(portIn)
	{
	}

	CService::CService(const struct in_addr& ipv4Addr, unsigned short portIn) : CNetAddr(ipv4Addr), port(portIn)
	{
	}

	#ifdef USE_IPV6
	CService::CService(const struct in6_addr& ipv6Addr, unsigned short portIn) : CNetAddr(ipv6Addr), port(portIn)
	{
	}
	#endif

	CService::CService(const struct sockaddr_in& addr) : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port))
	{
	assert(addr.sin_family == AF_INET);
	}

	#ifdef USE_IPV6
	CService::CService(const struct sockaddr_in6 &addr) : CNetAddr(addr.sin6_addr), port(ntohs(addr.sin6_port))
	{
	assert(addr.sin6_family == AF_INET6);
	}
	#endif

	bool CService::SetSockAddr(const struct sockaddr *paddr)
	{
	switch (paddr->sa_family) {
	case AF_INET:
	this = CService((const struct sockaddr_in*)paddr);
	return true;
	#ifdef USE_IPV6
	case AF_INET6:
	this = CService((const struct sockaddr_in6*)paddr);
	return true;
	#endif
	default:
	return false;
	}
	}

	CService::CService(const char *pszIpPort, bool fAllowLookup)
	{
	Init();
	CService ip;
	if (Lookup(pszIpPort, ip, 0, fAllowLookup))
	*this = ip;
	}

	CService::CService(const char *pszIpPort, int portDefault, bool fAllowLookup)
	{
	Init();
	CService ip;
	if (Lookup(pszIpPort, ip, portDefault, fAllowLookup))
	*this = ip;
	}

	CService::CService(const std::string &strIpPort, bool fAllowLookup)
	{
	Init();
	CService ip;
	if (Lookup(strIpPort.c_str(), ip, 0, fAllowLookup))
	*this = ip;
	}

	CService::CService(const std::string &strIpPort, int portDefault, bool fAllowLookup)
	{
	Init();
	CService ip;
	if (Lookup(strIpPort.c_str(), ip, portDefault, fAllowLookup))
	*this = ip;
	}

	unsigned short CService::GetPort() const
	{
	return port;
	}

	bool operator==(const CService& a, const CService& b)
	{
	return (CNetAddr)a == (CNetAddr)b && a.port == b.port;
	}

	bool operator!=(const CService& a, const CService& b)
	{
	return (CNetAddr)a != (CNetAddr)b \|\| a.port != b.port;
	}

	bool operator<(const CService& a, const CService& b)
	{
	return (CNetAddr)a < (CNetAddr)b \|\| ((CNetAddr)a == (CNetAddr)b && a.port < b.port);
	}

	bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const
	{
	if (IsIPv4()) {
	if (*addrlen < (socklen_t)sizeof(struct sockaddr_in))
	return false;
	*addrlen = sizeof(struct sockaddr_in);
	struct sockaddr_in paddrin = (struct sockaddr_in)paddr;
	memset(paddrin, 0, *addrlen);
	if (!GetInAddr(&paddrin->sin_addr))
	return false;
	paddrin->sin_family = AF_INET;
	paddrin->sin_port = htons(port);
	return true;
	}
	#ifdef USE_IPV6
	if (IsIPv6()) {
	if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6))
	return false;
	*addrlen = sizeof(struct sockaddr_in6);
	struct sockaddr_in6 paddrin6 = (struct sockaddr_in6)paddr;
	memset(paddrin6, 0, *addrlen);
	if (!GetIn6Addr(&paddrin6->sin6_addr))
	return false;
	paddrin6->sin6_family = AF_INET6;
	paddrin6->sin6_port = htons(port);
	return true;
	}
	#endif
	return false;
	}

	std::vector<unsigned char> CService::GetKey() const
	{
	std::vector<unsigned char> vKey;
	vKey.resize(18);
	memcpy(&vKey[0], ip, 16);
	vKey[16] = port / 0x100;
	vKey[17] = port & 0x0FF;
	return vKey;
	}

	std::string CService::ToStringPort() const
	{
	return strprintf("%i", port);
	}

	std::string CService::ToStringIPPort() const
	{
	- if (IsIPv4()) {
	+ if (IsIPv4() \|\| IsTor() \|\| IsI2P()) {
	return ToStringIP() + ":" + ToStringPort();
	} else {
	return "[" + ToStringIP() + "]:" + ToStringPort();
	}
	}

	std::string CService::ToString() const
	{
	return ToStringIPPort();
	}

	void CService::print() const
	{
	printf("CService(%s)\n", ToString().c_str());
	}

	void CService::SetPort(unsigned short portIn)
	{
	port = portIn;
	}
	diff --git a/src/netbase.h b/src/netbase.h
	index 7a797e2fd..36f29b0b3 100644
	--- a/src/netbase.h
	+++ b/src/netbase.h
	@@ -1,150 +1,151 @@
	// Copyright (c) 2009-2012 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.
	#ifndef BITCOIN_NETBASE_H
	#define BITCOIN_NETBASE_H

	#include <string>
	#include <vector>

	#include "serialize.h"
	#include "compat.h"

	extern int nConnectTimeout;

	#ifdef WIN32
	// In MSVC, this is defined as a macro, undefine it to prevent a compile and link error
	#undef SetPort
	#endif

	enum Network
	{
	NET_UNROUTABLE,
	NET_IPV4,
	NET_IPV6,
	NET_TOR,
	NET_I2P,

	NET_MAX
	};

	extern int nConnectTimeout;
	extern bool fNameLookup;

	/** IP address (IPv6, or IPv4 using mapped IPv6 range (::FFFF:0:0/96)) */
	class CNetAddr
	{
	protected:
	unsigned char ip[16]; // in network byte order

	public:
	CNetAddr();
	CNetAddr(const struct in_addr& ipv4Addr);
	explicit CNetAddr(const char *pszIp, bool fAllowLookup = false);
	explicit CNetAddr(const std::string &strIp, bool fAllowLookup = false);
	void Init();
	void SetIP(const CNetAddr& ip);
	+ bool SetSpecial(const std::string &strName); // for Tor and I2P addresses
	bool IsIPv4() const; // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
	- bool IsIPv6() const; // IPv6 address (not IPv4)
	+ bool IsIPv6() const; // IPv6 address (not mapped IPv4, not Tor/I2P)
	bool IsRFC1918() const; // IPv4 private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
	bool IsRFC3849() const; // IPv6 documentation address (2001:0DB8::/32)
	bool IsRFC3927() const; // IPv4 autoconfig (169.254.0.0/16)
	bool IsRFC3964() const; // IPv6 6to4 tunneling (2002::/16)
	bool IsRFC4193() const; // IPv6 unique local (FC00::/15)
	bool IsRFC4380() const; // IPv6 Teredo tunneling (2001::/32)
	bool IsRFC4843() const; // IPv6 ORCHID (2001:10::/28)
	bool IsRFC4862() const; // IPv6 autoconfig (FE80::/64)
	bool IsRFC6052() const; // IPv6 well-known prefix (64:FF9B::/96)
	bool IsRFC6145() const; // IPv6 IPv4-translated address (::FFFF:0:0:0/96)
	- bool IsOnionCat() const;
	- bool IsGarliCat() const;
	+ bool IsTor() const;
	+ bool IsI2P() const;
	bool IsLocal() const;
	bool IsRoutable() const;
	bool IsValid() const;
	bool IsMulticast() const;
	enum Network GetNetwork() const;
	std::string ToString() const;
	std::string ToStringIP() const;
	int GetByte(int n) const;
	uint64 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
	CNetAddr(const struct in6_addr& pipv6Addr);
	bool GetIn6Addr(struct in6_addr* pipv6Addr) const;
	#endif

	friend bool operator==(const CNetAddr& a, const CNetAddr& b);
	friend bool operator!=(const CNetAddr& a, const CNetAddr& b);
	friend bool operator<(const CNetAddr& a, const CNetAddr& b);

	IMPLEMENT_SERIALIZE
	(
	READWRITE(FLATDATA(ip));
	)
	};

	/** A combination of a network address (CNetAddr) and a (TCP) port */
	class CService : public CNetAddr
	{
	protected:
	unsigned short port; // host order

	public:
	CService();
	CService(const CNetAddr& ip, unsigned short port);
	CService(const struct in_addr& ipv4Addr, unsigned short port);
	CService(const struct sockaddr_in& addr);
	explicit CService(const char *pszIpPort, int portDefault, bool fAllowLookup = false);
	explicit CService(const char *pszIpPort, bool fAllowLookup = false);
	explicit CService(const std::string& strIpPort, int portDefault, bool fAllowLookup = false);
	explicit CService(const std::string& strIpPort, bool fAllowLookup = false);
	void Init();
	void SetPort(unsigned short portIn);
	unsigned short GetPort() const;
	bool GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const;
	bool SetSockAddr(const struct sockaddr* paddr);
	friend bool operator==(const CService& a, const CService& b);
	friend bool operator!=(const CService& a, const CService& b);
	friend bool operator<(const CService& a, const CService& b);
	std::vector<unsigned char> GetKey() const;
	std::string ToString() const;
	std::string ToStringPort() const;
	std::string ToStringIPPort() const;
	void print() const;

	#ifdef USE_IPV6
	CService(const struct in6_addr& ipv6Addr, unsigned short port);
	CService(const struct sockaddr_in6& addr);
	#endif

	IMPLEMENT_SERIALIZE
	(
	CService* pthis = const_cast<CService*>(this);
	READWRITE(FLATDATA(ip));
	unsigned short portN = htons(port);
	READWRITE(portN);
	if (fRead)
	pthis->port = ntohs(portN);
	)
	};

	enum Network ParseNetwork(std::string net);
	void SplitHostPort(std::string in, int &portOut, std::string &hostOut);
	bool SetProxy(enum Network net, CService addrProxy, int nSocksVersion = 5);
	bool GetProxy(enum Network net, CService &addrProxy);
	bool IsProxy(const CNetAddr &addr);
	bool SetNameProxy(CService addrProxy, int nSocksVersion = 5);
	bool GetNameProxy();
	bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions = 0, bool fAllowLookup = true);
	bool LookupHostNumeric(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions = 0);
	bool Lookup(const char *pszName, CService& addr, int portDefault = 0, bool fAllowLookup = true);
	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);

	#endif
	diff --git a/src/test/base32_tests.cpp b/src/test/base32_tests.cpp
	index 756c72b94..fdf328591 100644
	--- a/src/test/base32_tests.cpp
	+++ b/src/test/base32_tests.cpp
	@@ -1,20 +1,20 @@
	#include <boost/test/unit_test.hpp>

	#include "util.h"

	BOOST_AUTO_TEST_SUITE(base32_tests)

	BOOST_AUTO_TEST_CASE(base32_testvectors)
	{
	static const std::string vstrIn[] = {"","f","fo","foo","foob","fooba","foobar"};
	- static const std::string vstrOut[] = {"","MY======","MZXQ====","MZXW6===","MZXW6YQ=","MZXW6YTB","MZXW6YTBOI======"};
	+ static const std::string vstrOut[] = {"","my======","mzxq====","mzxw6===","mzxw6yq=","mzxw6ytb","mzxw6ytboi======"};
	for (unsigned int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
	{
	std::string strEnc = EncodeBase32(vstrIn[i]);
	BOOST_CHECK(strEnc == vstrOut[i]);
	std::string strDec = DecodeBase32(vstrOut[i]);
	BOOST_CHECK(strDec == vstrIn[i]);
	}
	}

	BOOST_AUTO_TEST_SUITE_END()
	diff --git a/src/test/netbase_tests.cpp b/src/test/netbase_tests.cpp
	index f0828f39f..e5a7562d9 100644
	--- a/src/test/netbase_tests.cpp
	+++ b/src/test/netbase_tests.cpp
	@@ -1,91 +1,102 @@
	#include <boost/test/unit_test.hpp>

	#include <string>
	#include <vector>

	#include "netbase.h"

	using namespace std;

	BOOST_AUTO_TEST_SUITE(netbase_tests)

	BOOST_AUTO_TEST_CASE(netbase_networks)
	{
	BOOST_CHECK(CNetAddr("127.0.0.1").GetNetwork() == NET_UNROUTABLE);
	BOOST_CHECK(CNetAddr("::1").GetNetwork() == NET_UNROUTABLE);
	BOOST_CHECK(CNetAddr("8.8.8.8").GetNetwork() == NET_IPV4);
	BOOST_CHECK(CNetAddr("2001::8888").GetNetwork() == NET_IPV6);
	BOOST_CHECK(CNetAddr("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").GetNetwork() == NET_TOR);
	}

	BOOST_AUTO_TEST_CASE(netbase_properties)
	{
	BOOST_CHECK(CNetAddr("127.0.0.1").IsIPv4());
	BOOST_CHECK(CNetAddr("::FFFF:192.168.1.1").IsIPv4());
	BOOST_CHECK(CNetAddr("::1").IsIPv6());
	BOOST_CHECK(CNetAddr("10.0.0.1").IsRFC1918());
	BOOST_CHECK(CNetAddr("192.168.1.1").IsRFC1918());
	BOOST_CHECK(CNetAddr("172.31.255.255").IsRFC1918());
	BOOST_CHECK(CNetAddr("2001:0DB8::").IsRFC3849());
	BOOST_CHECK(CNetAddr("169.254.1.1").IsRFC3927());
	BOOST_CHECK(CNetAddr("2002::1").IsRFC3964());
	BOOST_CHECK(CNetAddr("FC00::").IsRFC4193());
	BOOST_CHECK(CNetAddr("2001::2").IsRFC4380());
	BOOST_CHECK(CNetAddr("2001:10::").IsRFC4843());
	BOOST_CHECK(CNetAddr("FE80::").IsRFC4862());
	BOOST_CHECK(CNetAddr("64:FF9B::").IsRFC6052());
	- BOOST_CHECK(CNetAddr("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").IsOnionCat());
	+ BOOST_CHECK(CNetAddr("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").IsTor());
	BOOST_CHECK(CNetAddr("127.0.0.1").IsLocal());
	BOOST_CHECK(CNetAddr("::1").IsLocal());
	BOOST_CHECK(CNetAddr("8.8.8.8").IsRoutable());
	BOOST_CHECK(CNetAddr("2001::1").IsRoutable());
	BOOST_CHECK(CNetAddr("127.0.0.1").IsValid());
	}

	bool static TestSplitHost(string test, string host, int port)
	{
	string hostOut;
	int portOut = -1;
	SplitHostPort(test, portOut, hostOut);
	return hostOut == host && port == portOut;
	}

	BOOST_AUTO_TEST_CASE(netbase_splithost)
	{
	BOOST_CHECK(TestSplitHost("www.bitcoin.org", "www.bitcoin.org", -1));
	BOOST_CHECK(TestSplitHost("[www.bitcoin.org]", "www.bitcoin.org", -1));
	BOOST_CHECK(TestSplitHost("www.bitcoin.org:80", "www.bitcoin.org", 80));
	BOOST_CHECK(TestSplitHost("[www.bitcoin.org]:80", "www.bitcoin.org", 80));
	BOOST_CHECK(TestSplitHost("127.0.0.1", "127.0.0.1", -1));
	BOOST_CHECK(TestSplitHost("127.0.0.1:8333", "127.0.0.1", 8333));
	BOOST_CHECK(TestSplitHost("[127.0.0.1]", "127.0.0.1", -1));
	BOOST_CHECK(TestSplitHost("[127.0.0.1]:8333", "127.0.0.1", 8333));
	BOOST_CHECK(TestSplitHost("::ffff:127.0.0.1", "::ffff:127.0.0.1", -1));
	BOOST_CHECK(TestSplitHost("[::ffff:127.0.0.1]:8333", "::ffff:127.0.0.1", 8333));
	BOOST_CHECK(TestSplitHost("[::]:8333", "::", 8333));
	BOOST_CHECK(TestSplitHost("::8333", "::8333", -1));
	BOOST_CHECK(TestSplitHost(":8333", "", 8333));
	BOOST_CHECK(TestSplitHost("[]:8333", "", 8333));
	BOOST_CHECK(TestSplitHost("", "", -1));
	}

	bool static TestParse(string src, string canon)
	{
	CService addr;
	if (!LookupNumeric(src.c_str(), addr, 65535))
	return canon == "";
	return canon == addr.ToString();
	}

	BOOST_AUTO_TEST_CASE(netbase_lookupnumeric)
	{
	BOOST_CHECK(TestParse("127.0.0.1", "127.0.0.1:65535"));
	BOOST_CHECK(TestParse("127.0.0.1:8333", "127.0.0.1:8333"));
	BOOST_CHECK(TestParse("::ffff:127.0.0.1", "127.0.0.1:65535"));
	BOOST_CHECK(TestParse("::", "[::]:65535"));
	BOOST_CHECK(TestParse("[::]:8333", "[::]:8333"));
	BOOST_CHECK(TestParse("[127.0.0.1]", "127.0.0.1:65535"));
	BOOST_CHECK(TestParse(":::", ""));
	}

	+BOOST_AUTO_TEST_CASE(onioncat_test)
	+{
	+ // values from http://www.cypherpunk.at/onioncat/wiki/OnionCat
	+ CNetAddr addr1("5wyqrzbvrdsumnok.onion");
	+ CNetAddr addr2("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca");
	+ BOOST_CHECK(addr1 == addr2);
	+ BOOST_CHECK(addr1.IsTor());
	+ BOOST_CHECK(addr1.ToStringIP() == "5wyqrzbvrdsumnok.onion");
	+ BOOST_CHECK(addr1.IsRoutable());
	+}
	+
	BOOST_AUTO_TEST_SUITE_END()
	diff --git a/src/util.cpp b/src/util.cpp
	index 931d27ba0..5fff27160 100644
	--- a/src/util.cpp
	+++ b/src/util.cpp
	@@ -1,1276 +1,1276 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2012 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "util.h"
	#include "sync.h"
	#include "strlcpy.h"
	#include "version.h"
	#include "ui_interface.h"
	#include <boost/algorithm/string/join.hpp>

	// Work around clang compilation problem in Boost 1.46:
	// /usr/include/boost/program_options/detail/config_file.hpp:163:17: error: call to function 'to_internal' that is neither visible in the template definition nor found by argument-dependent lookup
	// See also: http://stackoverflow.com/questions/10020179/compilation-fail-in-boost-librairies-program-options
	// http://clang.debian.net/status.php?version=3.0&key=CANNOT_FIND_FUNCTION
	namespace boost {
	namespace program_options {
	std::string to_internal(const std::string&);
	}
	}

	#include <boost/program_options/detail/config_file.hpp>
	#include <boost/program_options/parsers.hpp>
	#include <boost/filesystem.hpp>
	#include <boost/filesystem/fstream.hpp>
	#include <boost/foreach.hpp>
	#include <boost/thread.hpp>
	#include <openssl/crypto.h>
	#include <openssl/rand.h>
	#include <stdarg.h>

	#ifdef WIN32
	#ifdef _MSC_VER
	#pragma warning(disable:4786)
	#pragma warning(disable:4804)
	#pragma warning(disable:4805)
	#pragma warning(disable:4717)
	#endif
	#ifdef _WIN32_WINNT
	#undef _WIN32_WINNT
	#endif
	#define _WIN32_WINNT 0x0501
	#ifdef _WIN32_IE
	#undef _WIN32_IE
	#endif
	#define _WIN32_IE 0x0501
	#define WIN32_LEAN_AND_MEAN 1
	#ifndef NOMINMAX
	#define NOMINMAX
	#endif
	#include <io.h> /* for _commit */
	#include "shlobj.h"
	#endif

	using namespace std;

	map<string, string> mapArgs;
	map<string, vector<string> > mapMultiArgs;
	bool fDebug = false;
	bool fPrintToConsole = false;
	bool fPrintToDebugger = false;
	bool fRequestShutdown = false;
	bool fShutdown = false;
	bool fDaemon = false;
	bool fServer = false;
	bool fCommandLine = false;
	string strMiscWarning;
	bool fTestNet = false;
	bool fNoListen = false;
	bool fLogTimestamps = false;
	CMedianFilter<int64> vTimeOffsets(200,0);
	bool fReopenDebugLog = false;

	// Init openssl library multithreading support
	static CCriticalSection** ppmutexOpenSSL;
	void locking_callback(int mode, int i, const char* file, int line)
	{
	if (mode & CRYPTO_LOCK) {
	ENTER_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
	} else {
	LEAVE_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
	}
	}

	// Init
	class CInit
	{
	public:
	CInit()
	{
	// Init openssl library multithreading support
	ppmutexOpenSSL = (CCriticalSection*)OPENSSL_malloc(CRYPTO_num_locks() sizeof(CCriticalSection*));
	for (int i = 0; i < CRYPTO_num_locks(); i++)
	ppmutexOpenSSL[i] = new CCriticalSection();
	CRYPTO_set_locking_callback(locking_callback);

	#ifdef WIN32
	// Seed random number generator with screen scrape and other hardware sources
	RAND_screen();
	#endif

	// Seed random number generator with performance counter
	RandAddSeed();
	}
	~CInit()
	{
	// Shutdown openssl library multithreading support
	CRYPTO_set_locking_callback(NULL);
	for (int i = 0; i < CRYPTO_num_locks(); i++)
	delete ppmutexOpenSSL[i];
	OPENSSL_free(ppmutexOpenSSL);
	}
	}
	instance_of_cinit;








	void RandAddSeed()
	{
	// Seed with CPU performance counter
	int64 nCounter = GetPerformanceCounter();
	RAND_add(&nCounter, sizeof(nCounter), 1.5);
	memset(&nCounter, 0, sizeof(nCounter));
	}

	void RandAddSeedPerfmon()
	{
	RandAddSeed();

	// This can take up to 2 seconds, so only do it every 10 minutes
	static int64 nLastPerfmon;
	if (GetTime() < nLastPerfmon + 10 * 60)
	return;
	nLastPerfmon = GetTime();

	#ifdef WIN32
	// Don't need this on Linux, OpenSSL automatically uses /dev/urandom
	// Seed with the entire set of perfmon data
	unsigned char pdata[250000];
	memset(pdata, 0, sizeof(pdata));
	unsigned long nSize = sizeof(pdata);
	long ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, pdata, &nSize);
	RegCloseKey(HKEY_PERFORMANCE_DATA);
	if (ret == ERROR_SUCCESS)
	{
	RAND_add(pdata, nSize, nSize/100.0);
	memset(pdata, 0, nSize);
	printf("RandAddSeed() %d bytes\n", nSize);
	}
	#endif
	}

	uint64 GetRand(uint64 nMax)
	{
	if (nMax == 0)
	return 0;

	// The range of the random source must be a multiple of the modulus
	// to give every possible output value an equal possibility
	uint64 nRange = (std::numeric_limits<uint64>::max() / nMax) * nMax;
	uint64 nRand = 0;
	do
	RAND_bytes((unsigned char*)&nRand, sizeof(nRand));
	while (nRand >= nRange);
	return (nRand % nMax);
	}

	int GetRandInt(int nMax)
	{
	return GetRand(nMax);
	}

	uint256 GetRandHash()
	{
	uint256 hash;
	RAND_bytes((unsigned char*)&hash, sizeof(hash));
	return hash;
	}








	inline int OutputDebugStringF(const char* pszFormat, ...)
	{
	int ret = 0;
	if (fPrintToConsole)
	{
	// print to console
	va_list arg_ptr;
	va_start(arg_ptr, pszFormat);
	ret = vprintf(pszFormat, arg_ptr);
	va_end(arg_ptr);
	}
	else
	{
	// print to debug.log
	static FILE* fileout = NULL;

	if (!fileout)
	{
	boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
	fileout = fopen(pathDebug.string().c_str(), "a");
	if (fileout) setbuf(fileout, NULL); // unbuffered
	}
	if (fileout)
	{
	static bool fStartedNewLine = true;
	static boost::mutex mutexDebugLog;
	boost::mutex::scoped_lock scoped_lock(mutexDebugLog);

	// reopen the log file, if requested
	if (fReopenDebugLog) {
	fReopenDebugLog = false;
	boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
	if (freopen(pathDebug.string().c_str(),"a",fileout) != NULL)
	setbuf(fileout, NULL); // unbuffered
	}

	// Debug print useful for profiling
	if (fLogTimestamps && fStartedNewLine)
	fprintf(fileout, "%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
	if (pszFormat[strlen(pszFormat) - 1] == '\n')
	fStartedNewLine = true;
	else
	fStartedNewLine = false;

	va_list arg_ptr;
	va_start(arg_ptr, pszFormat);
	ret = vfprintf(fileout, pszFormat, arg_ptr);
	va_end(arg_ptr);
	}
	}

	#ifdef WIN32
	if (fPrintToDebugger)
	{
	static CCriticalSection cs_OutputDebugStringF;

	// accumulate and output a line at a time
	{
	LOCK(cs_OutputDebugStringF);
	static std::string buffer;

	va_list arg_ptr;
	va_start(arg_ptr, pszFormat);
	buffer += vstrprintf(pszFormat, arg_ptr);
	va_end(arg_ptr);

	int line_start = 0, line_end;
	while((line_end = buffer.find('\n', line_start)) != -1)
	{
	OutputDebugStringA(buffer.substr(line_start, line_end - line_start).c_str());
	line_start = line_end + 1;
	}
	buffer.erase(0, line_start);
	}
	}
	#endif
	return ret;
	}

	string vstrprintf(const std::string &format, va_list ap)
	{
	char buffer[50000];
	char* p = buffer;
	int limit = sizeof(buffer);
	int ret;
	loop
	{
	va_list arg_ptr;
	va_copy(arg_ptr, ap);
	ret = _vsnprintf(p, limit, format.c_str(), arg_ptr);
	va_end(arg_ptr);
	if (ret >= 0 && ret < limit)
	break;
	if (p != buffer)
	delete[] p;
	limit *= 2;
	p = new char[limit];
	if (p == NULL)
	throw std::bad_alloc();
	}
	string str(p, p+ret);
	if (p != buffer)
	delete[] p;
	return str;
	}

	string real_strprintf(const std::string &format, int dummy, ...)
	{
	va_list arg_ptr;
	va_start(arg_ptr, dummy);
	string str = vstrprintf(format, arg_ptr);
	va_end(arg_ptr);
	return str;
	}

	bool error(const char *format, ...)
	{
	va_list arg_ptr;
	va_start(arg_ptr, format);
	std::string str = vstrprintf(format, arg_ptr);
	va_end(arg_ptr);
	printf("ERROR: %s\n", str.c_str());
	return false;
	}


	void ParseString(const string& str, char c, vector<string>& v)
	{
	if (str.empty())
	return;
	string::size_type i1 = 0;
	string::size_type i2;
	loop
	{
	i2 = str.find(c, i1);
	if (i2 == str.npos)
	{
	v.push_back(str.substr(i1));
	return;
	}
	v.push_back(str.substr(i1, i2-i1));
	i1 = i2+1;
	}
	}


	string FormatMoney(int64 n, bool fPlus)
	{
	// Note: not using straight sprintf here because we do NOT want
	// localized number formatting.
	int64 n_abs = (n > 0 ? n : -n);
	int64 quotient = n_abs/COIN;
	int64 remainder = n_abs%COIN;
	string str = strprintf("%"PRI64d".%08"PRI64d, quotient, remainder);

	// Right-trim excess 0's before the decimal point:
	int nTrim = 0;
	for (int i = str.size()-1; (str[i] == '0' && isdigit(str[i-2])); --i)
	++nTrim;
	if (nTrim)
	str.erase(str.size()-nTrim, nTrim);

	if (n < 0)
	str.insert((unsigned int)0, 1, '-');
	else if (fPlus && n > 0)
	str.insert((unsigned int)0, 1, '+');
	return str;
	}


	bool ParseMoney(const string& str, int64& nRet)
	{
	return ParseMoney(str.c_str(), nRet);
	}

	bool ParseMoney(const char* pszIn, int64& nRet)
	{
	string strWhole;
	int64 nUnits = 0;
	const char* p = pszIn;
	while (isspace(*p))
	p++;
	for (; *p; p++)
	{
	if (*p == '.')
	{
	p++;
	int64 nMult = CENT*10;
	while (isdigit(*p) && (nMult > 0))
	{
	nUnits += nMult * (*p++ - '0');
	nMult /= 10;
	}
	break;
	}
	if (isspace(*p))
	break;
	if (!isdigit(*p))
	return false;
	strWhole.insert(strWhole.end(), *p);
	}
	for (; *p; p++)
	if (!isspace(*p))
	return false;
	if (strWhole.size() > 10) // guard against 63 bit overflow
	return false;
	if (nUnits < 0 \|\| nUnits > COIN)
	return false;
	int64 nWhole = atoi64(strWhole);
	int64 nValue = nWhole*COIN + nUnits;

	nRet = nValue;
	return true;
	}


	static signed char phexdigit[256] =
	{ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,
	-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, };

	bool IsHex(const string& str)
	{
	BOOST_FOREACH(unsigned char c, str)
	{
	if (phexdigit[c] < 0)
	return false;
	}
	return (str.size() > 0) && (str.size()%2 == 0);
	}

	vector<unsigned char> ParseHex(const char* psz)
	{
	// convert hex dump to vector
	vector<unsigned char> vch;
	loop
	{
	while (isspace(*psz))
	psz++;
	signed char c = phexdigit[(unsigned char)*psz++];
	if (c == (signed char)-1)
	break;
	unsigned char n = (c << 4);
	c = phexdigit[(unsigned char)*psz++];
	if (c == (signed char)-1)
	break;
	n \|= c;
	vch.push_back(n);
	}
	return vch;
	}

	vector<unsigned char> ParseHex(const string& str)
	{
	return ParseHex(str.c_str());
	}

	static void InterpretNegativeSetting(string name, map<string, string>& mapSettingsRet)
	{
	// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set
	if (name.find("-no") == 0)
	{
	std::string positive("-");
	positive.append(name.begin()+3, name.end());
	if (mapSettingsRet.count(positive) == 0)
	{
	bool value = !GetBoolArg(name);
	mapSettingsRet[positive] = (value ? "1" : "0");
	}
	}
	}

	void ParseParameters(int argc, const char* const argv[])
	{
	mapArgs.clear();
	mapMultiArgs.clear();
	for (int i = 1; i < argc; i++)
	{
	char psz[10000];
	strlcpy(psz, argv[i], sizeof(psz));
	char* pszValue = (char*)"";
	if (strchr(psz, '='))
	{
	pszValue = strchr(psz, '=');
	*pszValue++ = '\0';
	}
	#ifdef WIN32
	_strlwr(psz);
	if (psz[0] == '/')
	psz[0] = '-';
	#endif
	if (psz[0] != '-')
	break;

	mapArgs[psz] = pszValue;
	mapMultiArgs[psz].push_back(pszValue);
	}

	// New 0.6 features:
	BOOST_FOREACH(const PAIRTYPE(string,string)& entry, mapArgs)
	{
	string name = entry.first;

	// interpret --foo as -foo (as long as both are not set)
	if (name.find("--") == 0)
	{
	std::string singleDash(name.begin()+1, name.end());
	if (mapArgs.count(singleDash) == 0)
	mapArgs[singleDash] = entry.second;
	name = singleDash;
	}

	// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set
	InterpretNegativeSetting(name, mapArgs);
	}
	}

	std::string GetArg(const std::string& strArg, const std::string& strDefault)
	{
	if (mapArgs.count(strArg))
	return mapArgs[strArg];
	return strDefault;
	}

	int64 GetArg(const std::string& strArg, int64 nDefault)
	{
	if (mapArgs.count(strArg))
	return atoi64(mapArgs[strArg]);
	return nDefault;
	}

	bool GetBoolArg(const std::string& strArg, bool fDefault)
	{
	if (mapArgs.count(strArg))
	{
	if (mapArgs[strArg].empty())
	return true;
	return (atoi(mapArgs[strArg]) != 0);
	}
	return fDefault;
	}

	bool SoftSetArg(const std::string& strArg, const std::string& strValue)
	{
	if (mapArgs.count(strArg))
	return false;
	mapArgs[strArg] = strValue;
	return true;
	}

	bool SoftSetBoolArg(const std::string& strArg, bool fValue)
	{
	if (fValue)
	return SoftSetArg(strArg, std::string("1"));
	else
	return SoftSetArg(strArg, std::string("0"));
	}


	string EncodeBase64(const unsigned char* pch, size_t len)
	{
	static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

	string strRet="";
	strRet.reserve((len+2)/3*4);

	int mode=0, left=0;
	const unsigned char *pchEnd = pch+len;

	while (pch<pchEnd)
	{
	int enc = *(pch++);
	switch (mode)
	{
	case 0: // we have no bits
	strRet += pbase64[enc >> 2];
	left = (enc & 3) << 4;
	mode = 1;
	break;

	case 1: // we have two bits
	strRet += pbase64[left \| (enc >> 4)];
	left = (enc & 15) << 2;
	mode = 2;
	break;

	case 2: // we have four bits
	strRet += pbase64[left \| (enc >> 6)];
	strRet += pbase64[enc & 63];
	mode = 0;
	break;
	}
	}

	if (mode)
	{
	strRet += pbase64[left];
	strRet += '=';
	if (mode == 1)
	strRet += '=';
	}

	return strRet;
	}

	string EncodeBase64(const string& str)
	{
	return EncodeBase64((const unsigned char*)str.c_str(), str.size());
	}

	vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
	{
	static const int decode64_table[256] =
	{
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
	-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
	29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
	49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
	};

	if (pfInvalid)
	*pfInvalid = false;

	vector<unsigned char> vchRet;
	vchRet.reserve(strlen(p)*3/4);

	int mode = 0;
	int left = 0;

	while (1)
	{
	int dec = decode64_table[(unsigned char)*p];
	if (dec == -1) break;
	p++;
	switch (mode)
	{
	case 0: // we have no bits and get 6
	left = dec;
	mode = 1;
	break;

	case 1: // we have 6 bits and keep 4
	vchRet.push_back((left<<2) \| (dec>>4));
	left = dec & 15;
	mode = 2;
	break;

	case 2: // we have 4 bits and get 6, we keep 2
	vchRet.push_back((left<<4) \| (dec>>2));
	left = dec & 3;
	mode = 3;
	break;

	case 3: // we have 2 bits and get 6
	vchRet.push_back((left<<6) \| dec);
	mode = 0;
	break;
	}
	}

	if (pfInvalid)
	switch (mode)
	{
	case 0: // 4n base64 characters processed: ok
	break;

	case 1: // 4n+1 base64 character processed: impossible
	*pfInvalid = true;
	break;

	case 2: // 4n+2 base64 characters processed: require '=='
	if (left \|\| p[0] != '=' \|\| p[1] != '=' \|\| decode64_table[(unsigned char)p[2]] != -1)
	*pfInvalid = true;
	break;

	case 3: // 4n+3 base64 characters processed: require '='
	if (left \|\| p[0] != '=' \|\| decode64_table[(unsigned char)p[1]] != -1)
	*pfInvalid = true;
	break;
	}

	return vchRet;
	}

	string DecodeBase64(const string& str)
	{
	vector<unsigned char> vchRet = DecodeBase64(str.c_str());
	return string((const char*)&vchRet[0], vchRet.size());
	}

	string EncodeBase32(const unsigned char* pch, size_t len)
	{
	- static const char *pbase32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
	+ static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";

	string strRet="";
	strRet.reserve((len+4)/5*8);

	int mode=0, left=0;
	const unsigned char *pchEnd = pch+len;

	while (pch<pchEnd)
	{
	int enc = *(pch++);
	switch (mode)
	{
	case 0: // we have no bits
	strRet += pbase32[enc >> 3];
	left = (enc & 7) << 2;
	mode = 1;
	break;

	case 1: // we have three bits
	strRet += pbase32[left \| (enc >> 6)];
	strRet += pbase32[(enc >> 1) & 31];
	left = (enc & 1) << 4;
	mode = 2;
	break;

	case 2: // we have one bit
	strRet += pbase32[left \| (enc >> 4)];
	left = (enc & 15) << 1;
	mode = 3;
	break;

	case 3: // we have four bits
	strRet += pbase32[left \| (enc >> 7)];
	strRet += pbase32[(enc >> 2) & 31];
	left = (enc & 3) << 3;
	mode = 4;
	break;

	case 4: // we have two bits
	strRet += pbase32[left \| (enc >> 5)];
	strRet += pbase32[enc & 31];
	mode = 0;
	}
	}

	static const int nPadding[5] = {0, 6, 4, 3, 1};
	if (mode)
	{
	strRet += pbase32[left];
	for (int n=0; n<nPadding[mode]; n++)
	strRet += '=';
	}

	return strRet;
	}

	string EncodeBase32(const string& str)
	{
	return EncodeBase32((const unsigned char*)str.c_str(), str.size());
	}

	vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
	{
	static const int decode32_table[256] =
	{
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 0, 1, 2,
	3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
	23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
	};

	if (pfInvalid)
	*pfInvalid = false;

	vector<unsigned char> vchRet;
	vchRet.reserve((strlen(p))*5/8);

	int mode = 0;
	int left = 0;

	while (1)
	{
	int dec = decode32_table[(unsigned char)*p];
	if (dec == -1) break;
	p++;
	switch (mode)
	{
	case 0: // we have no bits and get 5
	left = dec;
	mode = 1;
	break;

	case 1: // we have 5 bits and keep 2
	vchRet.push_back((left<<3) \| (dec>>2));
	left = dec & 3;
	mode = 2;
	break;

	case 2: // we have 2 bits and keep 7
	left = left << 5 \| dec;
	mode = 3;
	break;

	case 3: // we have 7 bits and keep 4
	vchRet.push_back((left<<1) \| (dec>>4));
	left = dec & 15;
	mode = 4;
	break;

	case 4: // we have 4 bits, and keep 1
	vchRet.push_back((left<<4) \| (dec>>1));
	left = dec & 1;
	mode = 5;
	break;

	case 5: // we have 1 bit, and keep 6
	left = left << 5 \| dec;
	mode = 6;
	break;

	case 6: // we have 6 bits, and keep 3
	vchRet.push_back((left<<2) \| (dec>>3));
	left = dec & 7;
	mode = 7;
	break;

	case 7: // we have 3 bits, and keep 0
	vchRet.push_back((left<<5) \| dec);
	mode = 0;
	break;
	}
	}

	if (pfInvalid)
	switch (mode)
	{
	case 0: // 8n base32 characters processed: ok
	break;

	case 1: // 8n+1 base32 characters processed: impossible
	case 3: // +3
	case 6: // +6
	*pfInvalid = true;
	break;

	case 2: // 8n+2 base32 characters processed: require '======'
	if (left \|\| p[0] != '=' \|\| p[1] != '=' \|\| p[2] != '=' \|\| p[3] != '=' \|\| p[4] != '=' \|\| p[5] != '=' \|\| decode32_table[(unsigned char)p[6]] != -1)
	*pfInvalid = true;
	break;

	case 4: // 8n+4 base32 characters processed: require '===='
	if (left \|\| p[0] != '=' \|\| p[1] != '=' \|\| p[2] != '=' \|\| p[3] != '=' \|\| decode32_table[(unsigned char)p[4]] != -1)
	*pfInvalid = true;
	break;

	case 5: // 8n+5 base32 characters processed: require '==='
	if (left \|\| p[0] != '=' \|\| p[1] != '=' \|\| p[2] != '=' \|\| decode32_table[(unsigned char)p[3]] != -1)
	*pfInvalid = true;
	break;

	case 7: // 8n+7 base32 characters processed: require '='
	if (left \|\| p[0] != '=' \|\| decode32_table[(unsigned char)p[1]] != -1)
	*pfInvalid = true;
	break;
	}

	return vchRet;
	}

	string DecodeBase32(const string& str)
	{
	vector<unsigned char> vchRet = DecodeBase32(str.c_str());
	return string((const char*)&vchRet[0], vchRet.size());
	}


	bool WildcardMatch(const char* psz, const char* mask)
	{
	loop
	{
	switch (*mask)
	{
	case '\0':
	return (*psz == '\0');
	case '*':
	return WildcardMatch(psz, mask+1) \|\| (*psz && WildcardMatch(psz+1, mask));
	case '?':
	if (*psz == '\0')
	return false;
	break;
	default:
	if (psz != mask)
	return false;
	break;
	}
	psz++;
	mask++;
	}
	}

	bool WildcardMatch(const string& str, const string& mask)
	{
	return WildcardMatch(str.c_str(), mask.c_str());
	}








	static std::string FormatException(std::exception* pex, const char* pszThread)
	{
	#ifdef WIN32
	char pszModule[MAX_PATH] = "";
	GetModuleFileNameA(NULL, pszModule, sizeof(pszModule));
	#else
	const char* pszModule = "bitcoin";
	#endif
	if (pex)
	return strprintf(
	"EXCEPTION: %s \n%s \n%s in %s \n", typeid(*pex).name(), pex->what(), pszModule, pszThread);
	else
	return strprintf(
	"UNKNOWN EXCEPTION \n%s in %s \n", pszModule, pszThread);
	}

	void LogException(std::exception* pex, const char* pszThread)
	{
	std::string message = FormatException(pex, pszThread);
	printf("\n%s", message.c_str());
	}

	void PrintException(std::exception* pex, const char* pszThread)
	{
	std::string message = FormatException(pex, pszThread);
	printf("\n\n************************\n%s\n", message.c_str());
	fprintf(stderr, "\n\n************************\n%s\n", message.c_str());
	strMiscWarning = message;
	throw;
	}

	void PrintExceptionContinue(std::exception* pex, const char* pszThread)
	{
	std::string message = FormatException(pex, pszThread);
	printf("\n\n************************\n%s\n", message.c_str());
	fprintf(stderr, "\n\n************************\n%s\n", message.c_str());
	strMiscWarning = message;
	}

	boost::filesystem::path GetDefaultDataDir()
	{
	namespace fs = boost::filesystem;
	// Windows < Vista: C:\Documents and Settings\Username\Application Data\Bitcoin
	// Windows >= Vista: C:\Users\Username\AppData\Roaming\Bitcoin
	// Mac: ~/Library/Application Support/Bitcoin
	// Unix: ~/.bitcoin
	#ifdef WIN32
	// Windows
	return GetSpecialFolderPath(CSIDL_APPDATA) / "Bitcoin";
	#else
	fs::path pathRet;
	char* pszHome = getenv("HOME");
	if (pszHome == NULL \|\| strlen(pszHome) == 0)
	pathRet = fs::path("/");
	else
	pathRet = fs::path(pszHome);
	#ifdef MAC_OSX
	// Mac
	pathRet /= "Library/Application Support";
	fs::create_directory(pathRet);
	return pathRet / "Bitcoin";
	#else
	// Unix
	return pathRet / ".bitcoin";
	#endif
	#endif
	}

	const boost::filesystem::path &GetDataDir(bool fNetSpecific)
	{
	namespace fs = boost::filesystem;

	static fs::path pathCached[2];
	static CCriticalSection csPathCached;
	static bool cachedPath[2] = {false, false};

	fs::path &path = pathCached[fNetSpecific];

	// This can be called during exceptions by printf, so we cache the
	// value so we don't have to do memory allocations after that.
	if (cachedPath[fNetSpecific])
	return path;

	LOCK(csPathCached);

	if (mapArgs.count("-datadir")) {
	path = fs::system_complete(mapArgs["-datadir"]);
	if (!fs::is_directory(path)) {
	path = "";
	return path;
	}
	} else {
	path = GetDefaultDataDir();
	}
	if (fNetSpecific && GetBoolArg("-testnet", false))
	path /= "testnet3";

	fs::create_directory(path);

	cachedPath[fNetSpecific]=true;
	return path;
	}

	boost::filesystem::path GetConfigFile()
	{
	boost::filesystem::path pathConfigFile(GetArg("-conf", "bitcoin.conf"));
	if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir(false) / pathConfigFile;
	return pathConfigFile;
	}

	void ReadConfigFile(map<string, string>& mapSettingsRet,
	map<string, vector<string> >& mapMultiSettingsRet)
	{
	boost::filesystem::ifstream streamConfig(GetConfigFile());
	if (!streamConfig.good())
	return; // No bitcoin.conf file is OK

	set<string> setOptions;
	setOptions.insert("*");

	for (boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it)
	{
	// Don't overwrite existing settings so command line settings override bitcoin.conf
	string strKey = string("-") + it->string_key;
	if (mapSettingsRet.count(strKey) == 0)
	{
	mapSettingsRet[strKey] = it->value[0];
	// interpret nofoo=1 as foo=0 (and nofoo=0 as foo=1) as long as foo not set)
	InterpretNegativeSetting(strKey, mapSettingsRet);
	}
	mapMultiSettingsRet[strKey].push_back(it->value[0]);
	}
	}

	boost::filesystem::path GetPidFile()
	{
	boost::filesystem::path pathPidFile(GetArg("-pid", "bitcoind.pid"));
	if (!pathPidFile.is_complete()) pathPidFile = GetDataDir() / pathPidFile;
	return pathPidFile;
	}

	void CreatePidFile(const boost::filesystem::path &path, pid_t pid)
	{
	FILE* file = fopen(path.string().c_str(), "w");
	if (file)
	{
	fprintf(file, "%d\n", pid);
	fclose(file);
	}
	}

	bool RenameOver(boost::filesystem::path src, boost::filesystem::path dest)
	{
	#ifdef WIN32
	return MoveFileExA(src.string().c_str(), dest.string().c_str(),
	MOVEFILE_REPLACE_EXISTING);
	#else
	int rc = std::rename(src.string().c_str(), dest.string().c_str());
	return (rc == 0);
	#endif /* WIN32 */
	}

	void FileCommit(FILE *fileout)
	{
	fflush(fileout); // harmless if redundantly called
	#ifdef WIN32
	_commit(_fileno(fileout));
	#else
	fsync(fileno(fileout));
	#endif
	}

	int GetFilesize(FILE* file)
	{
	int nSavePos = ftell(file);
	int nFilesize = -1;
	if (fseek(file, 0, SEEK_END) == 0)
	nFilesize = ftell(file);
	fseek(file, nSavePos, SEEK_SET);
	return nFilesize;
	}

	void ShrinkDebugFile()
	{
	// Scroll debug.log if it's getting too big
	boost::filesystem::path pathLog = GetDataDir() / "debug.log";
	FILE* file = fopen(pathLog.string().c_str(), "r");
	if (file && GetFilesize(file) > 10 * 1000000)
	{
	// Restart the file with some of the end
	char pch[200000];
	fseek(file, -sizeof(pch), SEEK_END);
	int nBytes = fread(pch, 1, sizeof(pch), file);
	fclose(file);

	file = fopen(pathLog.string().c_str(), "w");
	if (file)
	{
	fwrite(pch, 1, nBytes, file);
	fclose(file);
	}
	}
	}








	//
	// "Never go to sea with two chronometers; take one or three."
	// Our three time sources are:
	// - System clock
	// - Median of other nodes's clocks
	// - The user (asking the user to fix the system clock if the first two disagree)
	//
	static int64 nMockTime = 0; // For unit testing

	int64 GetTime()
	{
	if (nMockTime) return nMockTime;

	return time(NULL);
	}

	void SetMockTime(int64 nMockTimeIn)
	{
	nMockTime = nMockTimeIn;
	}

	static int64 nTimeOffset = 0;

	int64 GetAdjustedTime()
	{
	return GetTime() + nTimeOffset;
	}

	void AddTimeData(const CNetAddr& ip, int64 nTime)
	{
	int64 nOffsetSample = nTime - GetTime();

	// Ignore duplicates
	static set<CNetAddr> setKnown;
	if (!setKnown.insert(ip).second)
	return;

	// Add data
	vTimeOffsets.input(nOffsetSample);
	printf("Added time data, samples %d, offset %+"PRI64d" (%+"PRI64d" minutes)\n", vTimeOffsets.size(), nOffsetSample, nOffsetSample/60);
	if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1)
	{
	int64 nMedian = vTimeOffsets.median();
	std::vector<int64> vSorted = vTimeOffsets.sorted();
	// Only let other nodes change our time by so much
	if (abs64(nMedian) < 70 * 60)
	{
	nTimeOffset = nMedian;
	}
	else
	{
	nTimeOffset = 0;

	static bool fDone;
	if (!fDone)
	{
	// If nobody has a time different than ours but within 5 minutes of ours, give a warning
	bool fMatch = false;
	BOOST_FOREACH(int64 nOffset, vSorted)
	if (nOffset != 0 && abs64(nOffset) < 5 * 60)
	fMatch = true;

	if (!fMatch)
	{
	fDone = true;
	string strMessage = _("Warning: Please check that your computer's date and time are correct. If your clock is wrong Bitcoin will not work properly.");
	strMiscWarning = strMessage;
	printf("*** %s\n", strMessage.c_str());
	uiInterface.ThreadSafeMessageBox(strMessage+" ", string("Bitcoin"), CClientUIInterface::OK \| CClientUIInterface::ICON_EXCLAMATION);
	}
	}
	}
	if (fDebug) {
	BOOST_FOREACH(int64 n, vSorted)
	printf("%+"PRI64d" ", n);
	printf("\| ");
	}
	printf("nTimeOffset = %+"PRI64d" (%+"PRI64d" minutes)\n", nTimeOffset, nTimeOffset/60);
	}
	}








	string FormatVersion(int nVersion)
	{
	if (nVersion%100 == 0)
	return strprintf("%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100);
	else
	return strprintf("%d.%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100, nVersion%100);
	}

	string FormatFullVersion()
	{
	return CLIENT_BUILD;
	}

	// Format the subversion field according to BIP 14 spec (https://en.bitcoin.it/wiki/BIP_0014)
	std::string FormatSubVersion(const std::string& name, int nClientVersion, const std::vector<std::string>& comments)
	{
	std::ostringstream ss;
	ss << "/";
	ss << name << ":" << FormatVersion(nClientVersion);
	if (!comments.empty())
	ss << "(" << boost::algorithm::join(comments, "; ") << ")";
	ss << "/";
	return ss.str();
	}

	#ifdef WIN32
	boost::filesystem::path GetSpecialFolderPath(int nFolder, bool fCreate)
	{
	namespace fs = boost::filesystem;

	char pszPath[MAX_PATH] = "";

	if(SHGetSpecialFolderPathA(NULL, pszPath, nFolder, fCreate))
	{
	return fs::path(pszPath);
	}

	printf("SHGetSpecialFolderPathA() failed, could not obtain requested path.\n");
	return fs::path("");
	}
	#endif

	void runCommand(std::string strCommand)
	{
	int nErr = ::system(strCommand.c_str());
	if (nErr)
	printf("runCommand error: system(%s) returned %d\n", strCommand.c_str(), nErr);
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 10:17 (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187321
Default Alt Text: (80 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions