No OneTemporary
Actions

Size

47 KB

Subscribers

None

View Options

	diff --git a/src/util.cpp b/src/util.cpp
	index 76a2700271..14ca87b62e 100644
	--- a/src/util.cpp
	+++ b/src/util.cpp
	@@ -1,1048 +1,1057 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2011 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file license.txt or http://www.opensource.org/licenses/mit-license.php.
	#include "headers.h"
	#include "strlcpy.h"
	#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/interprocess/sync/interprocess_mutex.hpp>
	#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
	#include <boost/foreach.hpp>

	using namespace std;
	using namespace boost;

	map<string, string> mapArgs;
	map<string, vector<string> > mapMultiArgs;
	bool fDebug = false;
	bool fPrintToConsole = false;
	bool fPrintToDebugger = false;
	char pszSetDataDir[MAX_PATH] = "";
	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;




	// Workaround for "multiple definition of `_tls_used'"
	// http://svn.boost.org/trac/boost/ticket/4258
	extern "C" void tss_cleanup_implemented() { }





	// Init openssl library multithreading support
	static boost::interprocess::interprocess_mutex** ppmutexOpenSSL;
	void locking_callback(int mode, int i, const char* file, int line)
	{
	if (mode & CRYPTO_LOCK)
	ppmutexOpenSSL[i]->lock();
	else
	ppmutexOpenSSL[i]->unlock();
	}

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

	#ifdef __WXMSW__
	// 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 __WXMSW__
	// 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("%s RandAddSeed() %d bytes\n", DateTimeStrFormat("%x %H:%M", GetTime()).c_str(), 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 = (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);
	}











	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)
	{
	char pszFile[MAX_PATH+100];
	GetDataDir(pszFile);
	strlcat(pszFile, "/debug.log", sizeof(pszFile));
	fileout = fopen(pszFile, "a");
	if (fileout) setbuf(fileout, NULL); // unbuffered
	}
	if (fileout)
	{
	static bool fStartedNewLine = true;

	// 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 __WXMSW__
	if (fPrintToDebugger)
	{
	static CCriticalSection cs_OutputDebugStringF;

	// accumulate a line at a time
	CRITICAL_BLOCK(cs_OutputDebugStringF)
	{
	static char pszBuffer[50000];
	static char* pend;
	if (pend == NULL)
	pend = pszBuffer;
	va_list arg_ptr;
	va_start(arg_ptr, pszFormat);
	int limit = END(pszBuffer) - pend - 2;
	int ret = _vsnprintf(pend, limit, pszFormat, arg_ptr);
	va_end(arg_ptr);
	if (ret < 0 \|\| ret >= limit)
	{
	pend = END(pszBuffer) - 2;
	*pend++ = '\n';
	}
	else
	pend += ret;
	*pend = '\0';
	char* p1 = pszBuffer;
	char* p2;
	while (p2 = strchr(p1, '\n'))
	{
	p2++;
	char c = *p2;
	*p2 = '\0';
	OutputDebugStringA(p1);
	*p2 = c;
	p1 = p2;
	}
	if (p1 != pszBuffer)
	memmove(pszBuffer, p1, pend - p1 + 1);
	pend -= (p1 - pszBuffer);
	}
	}
	#endif
	return ret;
	}


	// Safer snprintf
	// - prints up to limit-1 characters
	// - output string is always null terminated even if limit reached
	// - return value is the number of characters actually printed
	int my_snprintf(char* buffer, size_t limit, const char* format, ...)
	{
	if (limit == 0)
	return 0;
	va_list arg_ptr;
	va_start(arg_ptr, format);
	int ret = _vsnprintf(buffer, limit, format, arg_ptr);
	va_end(arg_ptr);
	if (ret < 0 \|\| ret >= limit)
	{
	ret = limit - 1;
	buffer[limit-1] = 0;
	}
	return ret;
	}


	string strprintf(const char* format, ...)
	{
	char buffer[50000];
	char* p = buffer;
	int limit = sizeof(buffer);
	int ret;
	loop
	{
	va_list arg_ptr;
	va_start(arg_ptr, format);
	ret = _vsnprintf(p, limit, format, 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;
	}


	bool error(const char* format, ...)
	{
	char buffer[50000];
	int limit = sizeof(buffer);
	va_list arg_ptr;
	va_start(arg_ptr, format);
	int ret = _vsnprintf(buffer, limit, format, arg_ptr);
	va_end(arg_ptr);
	if (ret < 0 \|\| ret >= limit)
	{
	ret = limit - 1;
	buffer[limit-1] = 0;
	}
	printf("ERROR: %s\n", buffer);
	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() > 14)
	return false;
	if (nUnits < 0 \|\| nUnits > COIN)
	return false;
	int64 nWhole = atoi64(strWhole);
	int64 nValue = nWhole*COIN + nUnits;

	nRet = nValue;
	return true;
	}


	vector<unsigned char> ParseHex(const char* psz)
	{
	static 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, };

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

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


	void ParseParameters(int argc, char* 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 __WXMSW__
	_strlwr(psz);
	if (psz[0] == '/')
	psz[0] = '-';
	#endif
	if (psz[0] != '-')
	break;
	mapArgs[psz] = pszValue;
	mapMultiArgs[psz].push_back(pszValue);
	}
	}


	const char* wxGetTranslation(const char* pszEnglish)
	{
	#ifdef GUI
	// Wrapper of wxGetTranslation returning the same const char* type as was passed in
	static CCriticalSection cs;
	CRITICAL_BLOCK(cs)
	{
	// Look in cache
	static map<string, char*> mapCache;
	map<string, char*>::iterator mi = mapCache.find(pszEnglish);
	if (mi != mapCache.end())
	return (*mi).second;

	// wxWidgets translation
	wxString strTranslated = wxGetTranslation(wxString(pszEnglish, wxConvUTF8));

	// We don't cache unknown strings because caller might be passing in a
	// dynamic string and we would keep allocating memory for each variation.
	if (strcmp(pszEnglish, strTranslated.utf8_str()) == 0)
	return pszEnglish;

	// Add to cache, memory doesn't need to be freed. We only cache because
	// we must pass back a pointer to permanently allocated memory.
	char* pszCached = new char[strlen(strTranslated.utf8_str())+1];
	strcpy(pszCached, strTranslated.utf8_str());
	mapCache[pszEnglish] = pszCached;
	return pszCached;
	}
	return NULL;
	#else
	return pszEnglish;
	#endif
	}


	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());
	}








	void FormatException(char* pszMessage, std::exception* pex, const char* pszThread)
	{
	#ifdef __WXMSW__
	char pszModule[MAX_PATH];
	pszModule[0] = '\0';
	GetModuleFileNameA(NULL, pszModule, sizeof(pszModule));
	#else
	const char* pszModule = "bitcoin";
	#endif
	if (pex)
	snprintf(pszMessage, 1000,
	"EXCEPTION: %s \n%s \n%s in %s \n", typeid(*pex).name(), pex->what(), pszModule, pszThread);
	else
	snprintf(pszMessage, 1000,
	"UNKNOWN EXCEPTION \n%s in %s \n", pszModule, pszThread);
	}

	void LogException(std::exception* pex, const char* pszThread)
	{
	char pszMessage[10000];
	FormatException(pszMessage, pex, pszThread);
	printf("\n%s", pszMessage);
	}

	void PrintException(std::exception* pex, const char* pszThread)
	{
	char pszMessage[10000];
	FormatException(pszMessage, pex, pszThread);
	printf("\n\n************************\n%s\n", pszMessage);
	fprintf(stderr, "\n\n************************\n%s\n", pszMessage);
	strMiscWarning = pszMessage;
	#ifdef GUI
	if (wxTheApp && !fDaemon)
	MyMessageBox(pszMessage, "Bitcoin", wxOK \| wxICON_ERROR);
	#endif
	throw;
	}

	void ThreadOneMessageBox(string strMessage)
	{
	// Skip message boxes if one is already open
	static bool fMessageBoxOpen;
	if (fMessageBoxOpen)
	return;
	fMessageBoxOpen = true;
	ThreadSafeMessageBox(strMessage, "Bitcoin", wxOK \| wxICON_EXCLAMATION);
	fMessageBoxOpen = false;
	}

	void PrintExceptionContinue(std::exception* pex, const char* pszThread)
	{
	char pszMessage[10000];
	FormatException(pszMessage, pex, pszThread);
	printf("\n\n************************\n%s\n", pszMessage);
	fprintf(stderr, "\n\n************************\n%s\n", pszMessage);
	strMiscWarning = pszMessage;
	#ifdef GUI
	if (wxTheApp && !fDaemon)
	boost::thread(boost::bind(ThreadOneMessageBox, string(pszMessage)));
	#endif
	}








	#ifdef __WXMSW__
	typedef WINSHELLAPI BOOL (WINAPI *PSHGETSPECIALFOLDERPATHA)(HWND hwndOwner, LPSTR lpszPath, int nFolder, BOOL fCreate);

	string MyGetSpecialFolderPath(int nFolder, bool fCreate)
	{
	char pszPath[MAX_PATH+100] = "";

	// SHGetSpecialFolderPath isn't always available on old Windows versions
	HMODULE hShell32 = LoadLibraryA("shell32.dll");
	if (hShell32)
	{
	PSHGETSPECIALFOLDERPATHA pSHGetSpecialFolderPath =
	(PSHGETSPECIALFOLDERPATHA)GetProcAddress(hShell32, "SHGetSpecialFolderPathA");
	if (pSHGetSpecialFolderPath)
	(*pSHGetSpecialFolderPath)(NULL, pszPath, nFolder, fCreate);
	FreeModule(hShell32);
	}

	// Backup option
	if (pszPath[0] == '\0')
	{
	if (nFolder == CSIDL_STARTUP)
	{
	strcpy(pszPath, getenv("USERPROFILE"));
	strcat(pszPath, "\\Start Menu\\Programs\\Startup");
	}
	else if (nFolder == CSIDL_APPDATA)
	{
	strcpy(pszPath, getenv("APPDATA"));
	}
	}

	return pszPath;
	}
	#endif

	string GetDefaultDataDir()
	{
	// Windows: C:\Documents and Settings\username\Application Data\Bitcoin
	// Mac: ~/Library/Application Support/Bitcoin
	// Unix: ~/.bitcoin
	#ifdef __WXMSW__
	// Windows
	return MyGetSpecialFolderPath(CSIDL_APPDATA, true) + "\\Bitcoin";
	#else
	char* pszHome = getenv("HOME");
	if (pszHome == NULL \|\| strlen(pszHome) == 0)
	pszHome = (char*)"/";
	string strHome = pszHome;
	if (strHome[strHome.size()-1] != '/')
	strHome += '/';
	#ifdef __WXMAC_OSX__
	// Mac
	strHome += "Library/Application Support/";
	filesystem::create_directory(strHome.c_str());
	return strHome + "Bitcoin";
	#else
	// Unix
	return strHome + ".bitcoin";
	#endif
	#endif
	}

	void GetDataDir(char* pszDir)
	{
	// pszDir must be at least MAX_PATH length.
	int nVariation;
	if (pszSetDataDir[0] != 0)
	{
	strlcpy(pszDir, pszSetDataDir, MAX_PATH);
	nVariation = 0;
	}
	else
	{
	// This can be called during exceptions by printf, so we cache the
	// value so we don't have to do memory allocations after that.
	static char pszCachedDir[MAX_PATH];
	if (pszCachedDir[0] == 0)
	strlcpy(pszCachedDir, GetDefaultDataDir().c_str(), sizeof(pszCachedDir));
	strlcpy(pszDir, pszCachedDir, MAX_PATH);
	nVariation = 1;
	}
	if (fTestNet)
	{
	char* p = pszDir + strlen(pszDir);
	if (p > pszDir && p[-1] != '/' && p[-1] != '\\')
	*p++ = '/';
	strcpy(p, "testnet");
	nVariation += 2;
	}
	static bool pfMkdir[4];
	if (!pfMkdir[nVariation])
	{
	pfMkdir[nVariation] = true;
	boost::filesystem::create_directory(pszDir);
	}
	}

	string GetDataDir()
	{
	char pszDir[MAX_PATH];
	GetDataDir(pszDir);
	return pszDir;
	}

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

	void ReadConfigFile(map<string, string>& mapSettingsRet,
	map<string, vector<string> >& mapMultiSettingsRet)
	{
	namespace fs = boost::filesystem;
	namespace pod = boost::program_options::detail;

	fs::ifstream streamConfig(GetConfigFile());
	if (!streamConfig.good())
	return;

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

	for (pod::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];
	mapMultiSettingsRet[strKey].push_back(it->value[0]);
	}
	}

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

	void CreatePidFile(string pidFile, pid_t pid)
	{
	FILE* file = fopen(pidFile.c_str(), "w");
	if (file)
	{
	fprintf(file, "%d\n", pid);
	fclose(file);
	}
	}

	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
	string strFile = GetDataDir() + "/debug.log";
	FILE* file = fopen(strFile.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(strFile.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(unsigned int ip, int64 nTime)
	{
	int64 nOffsetSample = nTime - GetTime();

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

	// Add data
	static vector<int64> vTimeOffsets;
	if (vTimeOffsets.empty())
	vTimeOffsets.push_back(0);
	vTimeOffsets.push_back(nOffsetSample);
	printf("Added time data, samples %d, offset %+"PRI64d" (%+"PRI64d" minutes)\n", vTimeOffsets.size(), vTimeOffsets.back(), vTimeOffsets.back()/60);
	if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1)
	{
	sort(vTimeOffsets.begin(), vTimeOffsets.end());
	int64 nMedian = vTimeOffsets[vTimeOffsets.size()/2];
	// 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, vTimeOffsets)
	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());
	boost::thread(boost::bind(ThreadSafeMessageBox, strMessage+" ", string("Bitcoin"), wxOK \| wxICON_EXCLAMATION, (wxWindow*)NULL, -1, -1));
	}
	}
	}
	BOOST_FOREACH(int64 n, vTimeOffsets)
	printf("%+"PRI64d" ", n);
	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()
	{
	string s = FormatVersion(VERSION) + pszSubVer;
	if (VERSION_IS_BETA) {
	s += "-";
	s += _("beta");
	}
	return s;
	}




	#ifdef DEBUG_LOCKORDER
	//
	// Early deadlock detection.
	// Problem being solved:
	// Thread 1 locks A, then B, then C
	// Thread 2 locks D, then C, then A
	// --> may result in deadlock between the two threads, depending on when they run.
	// Solution implemented here:
	// Keep track of pairs of locks: (A before B), (A before C), etc.
	// Complain if any thread trys to lock in a different order.
	//

	struct CLockLocation
	{
	CLockLocation(const char* pszName, const char* pszFile, int nLine)
	{
	mutexName = pszName;
	sourceFile = pszFile;
	sourceLine = nLine;
	}

	std::string ToString() const
	{
	return mutexName+" "+sourceFile+":"+itostr(sourceLine);
	}

	private:
	std::string mutexName;
	std::string sourceFile;
	int sourceLine;
	};

	typedef std::vector< std::pair<CCriticalSection*, CLockLocation> > LockStack;

	static boost::interprocess::interprocess_mutex dd_mutex;
	static std::map<std::pair<CCriticalSection, CCriticalSection>, LockStack> lockorders;
	static boost::thread_specific_ptr<LockStack> lockstack;


	static void potential_deadlock_detected(const std::pair<CCriticalSection, CCriticalSection>& mismatch, const LockStack& s1, const LockStack& s2)
	{
	printf("POTENTIAL DEADLOCK DETECTED\n");
	printf("Previous lock order was:\n");
	BOOST_FOREACH(const PAIRTYPE(CCriticalSection*, CLockLocation)& i, s2)
	{
	if (i.first == mismatch.first) printf(" (1)");
	if (i.first == mismatch.second) printf(" (2)");
	printf(" %s\n", i.second.ToString().c_str());
	}
	printf("Current lock order is:\n");
	BOOST_FOREACH(const PAIRTYPE(CCriticalSection*, CLockLocation)& i, s1)
	{
	if (i.first == mismatch.first) printf(" (1)");
	if (i.first == mismatch.second) printf(" (2)");
	printf(" %s\n", i.second.ToString().c_str());
	}
	}

	static void push_lock(CCriticalSection* c, const CLockLocation& locklocation)
	{
	bool fOrderOK = true;
	if (lockstack.get() == NULL)
	lockstack.reset(new LockStack);

	if (fDebug) printf("Locking: %s\n", locklocation.ToString().c_str());
	dd_mutex.lock();

	(*lockstack).push_back(std::make_pair(c, locklocation));

	BOOST_FOREACH(const PAIRTYPE(CCriticalSection, CLockLocation)& i, (lockstack))
	{
	if (i.first == c) break;

	std::pair<CCriticalSection, CCriticalSection> p1 = std::make_pair(i.first, c);
	if (lockorders.count(p1))
	continue;
	lockorders[p1] = (*lockstack);

	std::pair<CCriticalSection, CCriticalSection> p2 = std::make_pair(c, i.first);
	if (lockorders.count(p2))
	{
	potential_deadlock_detected(p1, lockorders[p2], lockorders[p1]);
	break;
	}
	}
	dd_mutex.unlock();
	}

	static void pop_lock()
	{
	if (fDebug)
	{
	const CLockLocation& locklocation = (*lockstack).rbegin()->second;
	printf("Unlocked: %s\n", locklocation.ToString().c_str());
	}
	dd_mutex.lock();
	(*lockstack).pop_back();
	dd_mutex.unlock();
	}

	void CCriticalSection::Enter(const char* pszName, const char* pszFile, int nLine)
	{
	push_lock(this, CLockLocation(pszName, pszFile, nLine));
	mutex.lock();
	}
	void CCriticalSection::Leave()
	{
	mutex.unlock();
	pop_lock();
	}
	bool CCriticalSection::TryEnter(const char* pszName, const char* pszFile, int nLine)
	{
	push_lock(this, CLockLocation(pszName, pszFile, nLine));
	bool result = mutex.try_lock();
	if (!result) pop_lock();
	return result;
	}

	#else

	void CCriticalSection::Enter(const char, const char, int)
	{
	mutex.lock();
	}

	void CCriticalSection::Leave()
	{
	mutex.unlock();
	}

	bool CCriticalSection::TryEnter(const char, const char, int)
	{
	bool result = mutex.try_lock();
	return result;
	}

	#endif /* DEBUG_LOCKORDER */
	diff --git a/src/util.h b/src/util.h
	index 3d7ef108b4..658d10e1eb 100644
	--- a/src/util.h
	+++ b/src/util.h
	@@ -1,681 +1,682 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2011 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file license.txt or http://www.opensource.org/licenses/mit-license.php.
	#ifndef BITCOIN_UTIL_H
	#define BITCOIN_UTIL_H

	#include "uint256.h"

	#ifndef __WXMSW__
	#include <sys/types.h>
	#include <sys/time.h>
	#include <sys/resource.h>
	#endif
	#include <map>
	#include <vector>
	#include <string>

	#include <boost/thread.hpp>
	#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
	#include <boost/date_time/gregorian/gregorian_types.hpp>
	#include <boost/date_time/posix_time/posix_time_types.hpp>

	#include <openssl/sha.h>
	#include <openssl/ripemd.h>


	#if defined(_MSC_VER) \|\| defined(__BORLANDC__)
	typedef __int64 int64;
	typedef unsigned __int64 uint64;
	#else
	typedef long long int64;
	typedef unsigned long long uint64;
	#endif
	#if defined(_MSC_VER) && _MSC_VER < 1300
	#define for if (false) ; else for
	#endif
	#ifndef _MSC_VER
	#define __forceinline inline
	#endif

	#define loop for (;;)
	#define BEGIN(a) ((char*)&(a))
	#define END(a) ((char*)&((&(a))[1]))
	#define UBEGIN(a) ((unsigned char*)&(a))
	#define UEND(a) ((unsigned char*)&((&(a))[1]))
	#define ARRAYLEN(array) (sizeof(array)/sizeof((array)[0]))
	#define printf OutputDebugStringF

	#ifdef snprintf
	#undef snprintf
	#endif
	#define snprintf my_snprintf

	#ifndef PRI64d
	#if defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(__MSVCRT__)
	#define PRI64d "I64d"
	#define PRI64u "I64u"
	#define PRI64x "I64x"
	#else
	#define PRI64d "lld"
	#define PRI64u "llu"
	#define PRI64x "llx"
	#endif
	#endif

	// This is needed because the foreach macro can't get over the comma in pair<t1, t2>
	#define PAIRTYPE(t1, t2) pair<t1, t2>

	// Align by increasing pointer, must have extra space at end of buffer
	template <size_t nBytes, typename T>
	T* alignup(T* p)
	{
	union
	{
	T* ptr;
	size_t n;
	} u;
	u.ptr = p;
	u.n = (u.n + (nBytes-1)) & ~(nBytes-1);
	return u.ptr;
	}

	#ifdef __WXMSW__
	#define MSG_NOSIGNAL 0
	#define MSG_DONTWAIT 0
	#ifndef UINT64_MAX
	#define UINT64_MAX _UI64_MAX
	#define INT64_MAX _I64_MAX
	#define INT64_MIN _I64_MIN
	#endif
	#ifndef S_IRUSR
	#define S_IRUSR 0400
	#define S_IWUSR 0200
	#endif
	#define unlink _unlink
	typedef int socklen_t;
	#else
	#define WSAGetLastError() errno
	#define WSAEINVAL EINVAL
	#define WSAEALREADY EALREADY
	#define WSAEWOULDBLOCK EWOULDBLOCK
	#define WSAEMSGSIZE EMSGSIZE
	#define WSAEINTR EINTR
	#define WSAEINPROGRESS EINPROGRESS
	#define WSAEADDRINUSE EADDRINUSE
	#define WSAENOTSOCK EBADF
	#define INVALID_SOCKET (SOCKET)(~0)
	#define SOCKET_ERROR -1
	typedef u_int SOCKET;
	#define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d)
	#define strlwr(psz) to_lower(psz)
	#define _strlwr(psz) to_lower(psz)
	#define MAX_PATH 1024
	#define Beep(n1,n2) (0)
	inline void Sleep(int64 n)
	{
	boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(n));
	}
	#endif

	inline int myclosesocket(SOCKET& hSocket)
	{
	if (hSocket == INVALID_SOCKET)
	return WSAENOTSOCK;
	#ifdef __WXMSW__
	int ret = closesocket(hSocket);
	#else
	int ret = close(hSocket);
	#endif
	hSocket = INVALID_SOCKET;
	return ret;
	}
	#define closesocket(s) myclosesocket(s)

	#ifndef GUI
	inline const char* _(const char* psz)
	{
	return psz;
	}
	#endif










	extern std::map<std::string, std::string> mapArgs;
	extern std::map<std::string, std::vector<std::string> > mapMultiArgs;
	extern bool fDebug;
	extern bool fPrintToConsole;
	extern bool fPrintToDebugger;
	extern char pszSetDataDir[MAX_PATH];
	extern bool fRequestShutdown;
	extern bool fShutdown;
	extern bool fDaemon;
	extern bool fServer;
	extern bool fCommandLine;
	extern std::string strMiscWarning;
	extern bool fTestNet;
	extern bool fNoListen;
	extern bool fLogTimestamps;

	void RandAddSeed();
	void RandAddSeedPerfmon();
	int OutputDebugStringF(const char* pszFormat, ...);
	int my_snprintf(char* buffer, size_t limit, const char* format, ...);
	std::string strprintf(const char* format, ...);
	bool error(const char* format, ...);
	void LogException(std::exception* pex, const char* pszThread);
	void PrintException(std::exception* pex, const char* pszThread);
	void PrintExceptionContinue(std::exception* pex, const char* pszThread);
	void ParseString(const std::string& str, char c, std::vector<std::string>& v);
	std::string FormatMoney(int64 n, bool fPlus=false);
	bool ParseMoney(const std::string& str, int64& nRet);
	bool ParseMoney(const char* pszIn, int64& nRet);
	std::vector<unsigned char> ParseHex(const char* psz);
	std::vector<unsigned char> ParseHex(const std::string& str);
	void ParseParameters(int argc, char* argv[]);
	const char* wxGetTranslation(const char* psz);
	bool WildcardMatch(const char* psz, const char* mask);
	bool WildcardMatch(const std::string& str, const std::string& mask);
	int GetFilesize(FILE* file);
	void GetDataDir(char* pszDirRet);
	std::string GetConfigFile();
	std::string GetPidFile();
	void CreatePidFile(std::string pidFile, pid_t pid);
	void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet, std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
	#ifdef __WXMSW__
	std::string MyGetSpecialFolderPath(int nFolder, bool fCreate);
	#endif
	std::string GetDefaultDataDir();
	std::string GetDataDir();
	void ShrinkDebugFile();
	int GetRandInt(int nMax);
	uint64 GetRand(uint64 nMax);
	int64 GetTime();
	+void SetMockTime(int64 nMockTimeIn);
	int64 GetAdjustedTime();
	void AddTimeData(unsigned int ip, int64 nTime);
	std::string FormatFullVersion();













	// Wrapper to automatically initialize mutex
	class CCriticalSection
	{
	protected:
	boost::interprocess::interprocess_recursive_mutex mutex;
	public:
	explicit CCriticalSection() { }
	~CCriticalSection() { }
	void Enter(const char* pszName, const char* pszFile, int nLine);
	void Leave();
	bool TryEnter(const char* pszName, const char* pszFile, int nLine);
	};

	// Automatically leave critical section when leaving block, needed for exception safety
	class CCriticalBlock
	{
	protected:
	CCriticalSection* pcs;

	public:
	CCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
	{
	pcs = &csIn;
	pcs->Enter(pszName, pszFile, nLine);
	}
	~CCriticalBlock()
	{
	pcs->Leave();
	}
	};

	// WARNING: This will catch continue and break!
	// break is caught with an assertion, but there's no way to detect continue.
	// I'd rather be careful than suffer the other more error prone syntax.
	// The compiler will optimise away all this loop junk.
	#define CRITICAL_BLOCK(cs) \
	for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by CRITICAL_BLOCK!" && !fcriticalblockonce)), fcriticalblockonce=false) \
	for (CCriticalBlock criticalblock(cs, #cs, __FILE__, __LINE__); fcriticalblockonce; fcriticalblockonce=false)

	class CTryCriticalBlock
	{
	protected:
	CCriticalSection* pcs;

	public:
	CTryCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
	{
	pcs = (csIn.TryEnter(pszName, pszFile, nLine) ? &csIn : NULL);
	}
	~CTryCriticalBlock()
	{
	if (pcs)
	{
	pcs->Leave();
	}
	}
	bool Entered() { return pcs != NULL; }
	};

	#define TRY_CRITICAL_BLOCK(cs) \
	for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by TRY_CRITICAL_BLOCK!" && !fcriticalblockonce)), fcriticalblockonce=false) \
	for (CTryCriticalBlock criticalblock(cs, #cs, __FILE__, __LINE__); fcriticalblockonce && (fcriticalblockonce = criticalblock.Entered()); fcriticalblockonce=false)










	inline std::string i64tostr(int64 n)
	{
	return strprintf("%"PRI64d, n);
	}

	inline std::string itostr(int n)
	{
	return strprintf("%d", n);
	}

	inline int64 atoi64(const char* psz)
	{
	#ifdef _MSC_VER
	return _atoi64(psz);
	#else
	return strtoll(psz, NULL, 10);
	#endif
	}

	inline int64 atoi64(const std::string& str)
	{
	#ifdef _MSC_VER
	return _atoi64(str.c_str());
	#else
	return strtoll(str.c_str(), NULL, 10);
	#endif
	}

	inline int atoi(const std::string& str)
	{
	return atoi(str.c_str());
	}

	inline int roundint(double d)
	{
	return (int)(d > 0 ? d + 0.5 : d - 0.5);
	}

	inline int64 roundint64(double d)
	{
	return (int64)(d > 0 ? d + 0.5 : d - 0.5);
	}

	inline int64 abs64(int64 n)
	{
	return (n >= 0 ? n : -n);
	}

	template<typename T>
	std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
	{
	if (itbegin == itend)
	return "";
	const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
	const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
	std::string str;
	str.reserve((pend-pbegin) * (fSpaces ? 3 : 2));
	for (const unsigned char* p = pbegin; p != pend; p++)
	str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p);
	return str;
	}

	inline std::string HexStr(const std::vector<unsigned char>& vch, bool fSpaces=false)
	{
	return HexStr(vch.begin(), vch.end(), fSpaces);
	}

	template<typename T>
	std::string HexNumStr(const T itbegin, const T itend, bool f0x=true)
	{
	if (itbegin == itend)
	return "";
	const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
	const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
	std::string str = (f0x ? "0x" : "");
	str.reserve(str.size() + (pend-pbegin) * 2);
	for (const unsigned char* p = pend-1; p >= pbegin; p--)
	str += strprintf("%02x", *p);
	return str;
	}

	inline std::string HexNumStr(const std::vector<unsigned char>& vch, bool f0x=true)
	{
	return HexNumStr(vch.begin(), vch.end(), f0x);
	}

	template<typename T>
	void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)
	{
	printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());
	}

	inline void PrintHex(const std::vector<unsigned char>& vch, const char* pszFormat="%s", bool fSpaces=true)
	{
	printf(pszFormat, HexStr(vch, fSpaces).c_str());
	}

	inline int64 GetPerformanceCounter()
	{
	int64 nCounter = 0;
	#ifdef __WXMSW__
	QueryPerformanceCounter((LARGE_INTEGER*)&nCounter);
	#else
	timeval t;
	gettimeofday(&t, NULL);
	nCounter = t.tv_sec * 1000000 + t.tv_usec;
	#endif
	return nCounter;
	}

	inline int64 GetTimeMillis()
	{
	return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) -
	boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds();
	}

	inline std::string DateTimeStrFormat(const char* pszFormat, int64 nTime)
	{
	time_t n = nTime;
	struct tm* ptmTime = gmtime(&n);
	char pszTime[200];
	strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime);
	return pszTime;
	}

	template<typename T>
	void skipspaces(T& it)
	{
	while (isspace(*it))
	++it;
	}

	inline bool IsSwitchChar(char c)
	{
	#ifdef __WXMSW__
	return c == '-' \|\| c == '/';
	#else
	return c == '-';
	#endif
	}

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

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

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










	inline void heapchk()
	{
	#ifdef __WXMSW__
	/// for debugging
	//if (_heapchk() != _HEAPOK)
	// DebugBreak();
	#endif
	}

	// Randomize the stack to help protect against buffer overrun exploits
	#define IMPLEMENT_RANDOMIZE_STACK(ThreadFn) \
	{ \
	static char nLoops; \
	if (nLoops <= 0) \
	nLoops = GetRand(20) + 1; \
	if (nLoops-- > 1) \
	{ \
	ThreadFn; \
	return; \
	} \
	}

	#define CATCH_PRINT_EXCEPTION(pszFn) \
	catch (std::exception& e) { \
	PrintException(&e, (pszFn)); \
	} catch (...) { \
	PrintException(NULL, (pszFn)); \
	}










	template<typename T1>
	inline uint256 Hash(const T1 pbegin, const T1 pend)
	{
	static unsigned char pblank[1];
	uint256 hash1;
	SHA256((pbegin == pend ? pblank : (unsigned char)&pbegin[0]), (pend - pbegin) sizeof(pbegin[0]), (unsigned char*)&hash1);
	uint256 hash2;
	SHA256((unsigned char)&hash1, sizeof(hash1), (unsigned char)&hash2);
	return hash2;
	}

	template<typename T1, typename T2>
	inline uint256 Hash(const T1 p1begin, const T1 p1end,
	const T2 p2begin, const T2 p2end)
	{
	static unsigned char pblank[1];
	uint256 hash1;
	SHA256_CTX ctx;
	SHA256_Init(&ctx);
	SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char)&p1begin[0]), (p1end - p1begin) sizeof(p1begin[0]));
	SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char)&p2begin[0]), (p2end - p2begin) sizeof(p2begin[0]));
	SHA256_Final((unsigned char*)&hash1, &ctx);
	uint256 hash2;
	SHA256((unsigned char)&hash1, sizeof(hash1), (unsigned char)&hash2);
	return hash2;
	}

	template<typename T1, typename T2, typename T3>
	inline uint256 Hash(const T1 p1begin, const T1 p1end,
	const T2 p2begin, const T2 p2end,
	const T3 p3begin, const T3 p3end)
	{
	static unsigned char pblank[1];
	uint256 hash1;
	SHA256_CTX ctx;
	SHA256_Init(&ctx);
	SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char)&p1begin[0]), (p1end - p1begin) sizeof(p1begin[0]));
	SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char)&p2begin[0]), (p2end - p2begin) sizeof(p2begin[0]));
	SHA256_Update(&ctx, (p3begin == p3end ? pblank : (unsigned char)&p3begin[0]), (p3end - p3begin) sizeof(p3begin[0]));
	SHA256_Final((unsigned char*)&hash1, &ctx);
	uint256 hash2;
	SHA256((unsigned char)&hash1, sizeof(hash1), (unsigned char)&hash2);
	return hash2;
	}

	template<typename T>
	uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION)
	{
	// Most of the time is spent allocating and deallocating CDataStream's
	// buffer. If this ever needs to be optimized further, make a CStaticStream
	// class with its buffer on the stack.
	CDataStream ss(nType, nVersion);
	ss.reserve(10000);
	ss << obj;
	return Hash(ss.begin(), ss.end());
	}

	inline uint160 Hash160(const std::vector<unsigned char>& vch)
	{
	uint256 hash1;
	SHA256(&vch[0], vch.size(), (unsigned char*)&hash1);
	uint160 hash2;
	RIPEMD160((unsigned char)&hash1, sizeof(hash1), (unsigned char)&hash2);
	return hash2;
	}











	// Note: It turns out we might have been able to use boost::thread
	// by using TerminateThread(boost::thread.native_handle(), 0);
	#ifdef __WXMSW__
	typedef HANDLE pthread_t;

	inline pthread_t CreateThread(void(pfn)(void), void* parg, bool fWantHandle=false)
	{
	DWORD nUnused = 0;
	HANDLE hthread =
	CreateThread(
	NULL, // default security
	0, // inherit stack size from parent
	(LPTHREAD_START_ROUTINE)pfn, // function pointer
	parg, // argument
	0, // creation option, start immediately
	&nUnused); // thread identifier
	if (hthread == NULL)
	{
	printf("Error: CreateThread() returned %d\n", GetLastError());
	return (pthread_t)0;
	}
	if (!fWantHandle)
	{
	CloseHandle(hthread);
	return (pthread_t)-1;
	}
	return hthread;
	}

	inline void SetThreadPriority(int nPriority)
	{
	SetThreadPriority(GetCurrentThread(), nPriority);
	}
	#else
	inline pthread_t CreateThread(void(pfn)(void), void* parg, bool fWantHandle=false)
	{
	pthread_t hthread = 0;
	int ret = pthread_create(&hthread, NULL, (void()(void*))pfn, parg);
	if (ret != 0)
	{
	printf("Error: pthread_create() returned %d\n", ret);
	return (pthread_t)0;
	}
	if (!fWantHandle)
	{
	pthread_detach(hthread);
	return (pthread_t)-1;
	}
	return hthread;
	}

	#define THREAD_PRIORITY_LOWEST PRIO_MAX
	#define THREAD_PRIORITY_BELOW_NORMAL 2
	#define THREAD_PRIORITY_NORMAL 0
	#define THREAD_PRIORITY_ABOVE_NORMAL 0

	inline void SetThreadPriority(int nPriority)
	{
	// It's unclear if it's even possible to change thread priorities on Linux,
	// but we really and truly need it for the generation threads.
	#ifdef PRIO_THREAD
	setpriority(PRIO_THREAD, 0, nPriority);
	#else
	setpriority(PRIO_PROCESS, 0, nPriority);
	#endif
	}

	inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode)
	{
	return (pthread_cancel(hthread) == 0);
	}

	inline void ExitThread(size_t nExitCode)
	{
	pthread_exit((void*)nExitCode);
	}
	#endif





	inline bool AffinityBugWorkaround(void(pfn)(void))
	{
	#ifdef __WXMSW__
	// Sometimes after a few hours affinity gets stuck on one processor
	DWORD dwProcessAffinityMask = -1;
	DWORD dwSystemAffinityMask = -1;
	GetProcessAffinityMask(GetCurrentProcess(), &dwProcessAffinityMask, &dwSystemAffinityMask);
	DWORD dwPrev1 = SetThreadAffinityMask(GetCurrentThread(), dwProcessAffinityMask);
	DWORD dwPrev2 = SetThreadAffinityMask(GetCurrentThread(), dwProcessAffinityMask);
	if (dwPrev2 != dwProcessAffinityMask)
	{
	printf("AffinityBugWorkaround() : SetThreadAffinityMask=%d, ProcessAffinityMask=%d, restarting thread\n", dwPrev2, dwProcessAffinityMask);
	if (!CreateThread(pfn, NULL))
	printf("Error: CreateThread() failed\n");
	return true;
	}
	#endif
	return false;
	}

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 10:07 (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187296
Default Alt Text: (47 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions