No OneTemporary
Actions

Size

54 KB

Subscribers

None

View Options

	diff --git a/src/Makefile.test.include b/src/Makefile.test.include
	index 6ef6a69a2c..0c4e47a147 100644
	--- a/src/Makefile.test.include
	+++ b/src/Makefile.test.include
	@@ -1,149 +1,151 @@
	TESTS += test/test_bitcoin
	bin_PROGRAMS += test/test_bitcoin
	TEST_SRCDIR = test
	TEST_BINARY=test/test_bitcoin$(EXEEXT)


	EXTRA_DIST += \
	test/bctest.py \
	test/bitcoin-util-test.py \
	test/data/bitcoin-util-test.json \
	test/data/blanktx.hex \
	test/data/tt-delin1-out.hex \
	test/data/tt-delout1-out.hex \
	test/data/tt-locktime317000-out.hex \
	test/data/tx394b54bb.hex \
	test/data/txcreate1.hex \
	test/data/txcreate2.hex \
	test/data/txcreatedata1.hex \
	test/data/txcreatedata2.hex \
	test/data/txcreatesign.hex

	JSON_TEST_FILES = \
	test/data/script_valid.json \
	test/data/base58_keys_valid.json \
	test/data/base58_encode_decode.json \
	test/data/base58_keys_invalid.json \
	test/data/script_invalid.json \
	test/data/tx_invalid.json \
	test/data/tx_valid.json \
	test/data/sighash.json

	RAW_TEST_FILES = test/data/alertTests.raw

	GENERATED_TEST_FILES = $(JSON_TEST_FILES:.json=.json.h) $(RAW_TEST_FILES:.raw=.raw.h)

	BITCOIN_TESTS =\
	test/arith_uint256_tests.cpp \
	test/scriptnum10.h \
	test/addrman_tests.cpp \
	test/alert_tests.cpp \
	test/allocator_tests.cpp \
	test/base32_tests.cpp \
	test/base58_tests.cpp \
	test/base64_tests.cpp \
	test/bip32_tests.cpp \
	test/bloom_tests.cpp \
	test/Checkpoints_tests.cpp \
	test/coins_tests.cpp \
	test/compress_tests.cpp \
	test/crypto_tests.cpp \
	test/DoS_tests.cpp \
	test/getarg_tests.cpp \
	test/hash_tests.cpp \
	test/key_tests.cpp \
	test/limitedmap_tests.cpp \
	test/dbwrapper_tests.cpp \
	test/main_tests.cpp \
	test/mempool_tests.cpp \
	test/merkle_tests.cpp \
	test/miner_tests.cpp \
	test/multisig_tests.cpp \
	test/netbase_tests.cpp \
	test/pmt_tests.cpp \
	test/policyestimator_tests.cpp \
	test/pow_tests.cpp \
	test/prevector_tests.cpp \
	test/reverselock_tests.cpp \
	test/rpc_tests.cpp \
	test/sanity_tests.cpp \
	test/scheduler_tests.cpp \
	test/script_P2SH_tests.cpp \
	test/script_tests.cpp \
	test/scriptnum_tests.cpp \
	test/serialize_tests.cpp \
	test/sighash_tests.cpp \
	test/sigopcount_tests.cpp \
	test/skiplist_tests.cpp \
	test/streams_tests.cpp \
	test/test_bitcoin.cpp \
	test/test_bitcoin.h \
	+ test/testutil.cpp \
	+ test/testutil.h \
	test/timedata_tests.cpp \
	test/transaction_tests.cpp \
	test/txvalidationcache_tests.cpp \
	test/uint256_tests.cpp \
	test/univalue_tests.cpp \
	test/util_tests.cpp

	if ENABLE_WALLET
	BITCOIN_TESTS += \
	test/accounting_tests.cpp \
	wallet/test/wallet_tests.cpp \
	test/rpc_wallet_tests.cpp
	endif

	test_test_bitcoin_SOURCES = $(BITCOIN_TESTS) $(JSON_TEST_FILES) $(RAW_TEST_FILES)
	test_test_bitcoin_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -I$(builddir)/test/ $(TESTDEFS)
	test_test_bitcoin_LDADD = $(LIBBITCOIN_SERVER) $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) $(LIBLEVELDB) $(LIBMEMENV) \
	$(BOOST_LIBS) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1)
	test_test_bitcoin_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
	if ENABLE_WALLET
	test_test_bitcoin_LDADD += $(LIBBITCOIN_WALLET)
	endif

	test_test_bitcoin_LDADD += $(LIBBITCOIN_CONSENSUS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS)
	test_test_bitcoin_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) -static

	if ENABLE_ZMQ
	test_test_bitcoin_LDADD += $(ZMQ_LIBS)
	endif

	nodist_test_test_bitcoin_SOURCES = $(GENERATED_TEST_FILES)

	$(BITCOIN_TESTS): $(GENERATED_TEST_FILES)

	CLEAN_BITCOIN_TEST = test/.gcda test/.gcno $(GENERATED_TEST_FILES)

	CLEANFILES += $(CLEAN_BITCOIN_TEST)

	bitcoin_test: $(TEST_BINARY)

	bitcoin_test_check: $(TEST_BINARY) FORCE
	$(MAKE) check-TESTS TESTS=$^

	bitcoin_test_clean : FORCE
	rm -f $(CLEAN_BITCOIN_TEST) $(test_test_bitcoin_OBJECTS) $(TEST_BINARY)

	check-local:
	@echo "Running test/bitcoin-util-test.py..."
	$(AM_V_at)srcdir=$(srcdir) PYTHONPATH=$(builddir)/test $(srcdir)/test/bitcoin-util-test.py
	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C secp256k1 check
	if EMBEDDED_UNIVALUE
	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C univalue check
	endif

	%.json.h: %.json
	@$(MKDIR_P) $(@D)
	@echo "namespace json_tests{" > $@
	@echo "static unsigned const char $(*F)[] = {" >> $@
	@$(HEXDUMP) -v -e '8/1 "0x%02x, "' -e '"\n"' $< \| $(SED) -e 's/0x ,//g' >> $@
	@echo "};};" >> $@
	@echo "Generated $@"

	%.raw.h: %.raw
	@$(MKDIR_P) $(@D)
	@echo "namespace alert_tests{" > $@
	@echo "static unsigned const char $(*F)[] = {" >> $@
	@$(HEXDUMP) -v -e '8/1 "0x%02x, "' -e '"\n"' $< \| $(SED) -e 's/0x ,//g' >> $@
	@echo "};};" >> $@
	@echo "Generated $@"
	diff --git a/src/test/alert_tests.cpp b/src/test/alert_tests.cpp
	index 0895ef3326..87d35be412 100644
	--- a/src/test/alert_tests.cpp
	+++ b/src/test/alert_tests.cpp
	@@ -1,256 +1,256 @@
	// Copyright (c) 2013-2015 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	// Unit tests for alert system

	#include "alert.h"
	#include "chain.h"
	#include "chainparams.h"
	#include "clientversion.h"
	#include "data/alertTests.raw.h"
	#include "main.h" // For PartitionCheck
	#include "serialize.h"
	#include "streams.h"
	-#include "util.h"
	#include "utilstrencodings.h"

	+#include "test/testutil.h"
	#include "test/test_bitcoin.h"

	#include <fstream>

	#include <boost/filesystem/operations.hpp>
	#include <boost/foreach.hpp>
	#include <boost/test/unit_test.hpp>

	#if 0
	//
	// alertTests contains 7 alerts, generated with this code:
	// (SignAndSave code not shown, alert signing key is secret)
	//
	{
	CAlert alert;
	alert.nRelayUntil = 60;
	alert.nExpiration = 24 * 60 * 60;
	alert.nID = 1;
	alert.nCancel = 0; // cancels previous messages up to this ID number
	alert.nMinVer = 0; // These versions are protocol versions
	alert.nMaxVer = 999001;
	alert.nPriority = 1;
	alert.strComment = "Alert comment";
	alert.strStatusBar = "Alert 1";

	SignAndSave(alert, "test/alertTests");

	alert.setSubVer.insert(std::string("/Satoshi:0.1.0/"));
	alert.strStatusBar = "Alert 1 for Satoshi 0.1.0";
	SignAndSave(alert, "test/alertTests");

	alert.setSubVer.insert(std::string("/Satoshi:0.2.0/"));
	alert.strStatusBar = "Alert 1 for Satoshi 0.1.0, 0.2.0";
	SignAndSave(alert, "test/alertTests");

	alert.setSubVer.clear();
	++alert.nID;
	alert.nCancel = 1;
	alert.nPriority = 100;
	alert.strStatusBar = "Alert 2, cancels 1";
	SignAndSave(alert, "test/alertTests");

	alert.nExpiration += 60;
	++alert.nID;
	SignAndSave(alert, "test/alertTests");

	++alert.nID;
	alert.nMinVer = 11;
	alert.nMaxVer = 22;
	SignAndSave(alert, "test/alertTests");

	++alert.nID;
	alert.strStatusBar = "Alert 2 for Satoshi 0.1.0";
	alert.setSubVer.insert(std::string("/Satoshi:0.1.0/"));
	SignAndSave(alert, "test/alertTests");

	++alert.nID;
	alert.nMinVer = 0;
	alert.nMaxVer = 999999;
	alert.strStatusBar = "Evil Alert'; /bin/ls; echo '";
	alert.setSubVer.clear();
	SignAndSave(alert, "test/alertTests");
	}
	#endif

	struct ReadAlerts : public TestingSetup
	{
	ReadAlerts()
	{
	std::vector<unsigned char> vch(alert_tests::alertTests, alert_tests::alertTests + sizeof(alert_tests::alertTests));
	CDataStream stream(vch, SER_DISK, CLIENT_VERSION);
	try {
	while (!stream.eof())
	{
	CAlert alert;
	stream >> alert;
	alerts.push_back(alert);
	}
	}
	catch (const std::exception&) { }
	}
	~ReadAlerts() { }

	static std::vector<std::string> read_lines(boost::filesystem::path filepath)
	{
	std::vector<std::string> result;

	std::ifstream f(filepath.string().c_str());
	std::string line;
	while (std::getline(f,line))
	result.push_back(line);

	return result;
	}

	std::vector<CAlert> alerts;
	};

	BOOST_FIXTURE_TEST_SUITE(Alert_tests, ReadAlerts)


	BOOST_AUTO_TEST_CASE(AlertApplies)
	{
	SetMockTime(11);
	const std::vector<unsigned char>& alertKey = Params(CBaseChainParams::MAIN).AlertKey();

	BOOST_FOREACH(const CAlert& alert, alerts)
	{
	BOOST_CHECK(alert.CheckSignature(alertKey));
	}

	BOOST_CHECK(alerts.size() >= 3);

	// Matches:
	BOOST_CHECK(alerts[0].AppliesTo(1, ""));
	BOOST_CHECK(alerts[0].AppliesTo(999001, ""));
	BOOST_CHECK(alerts[0].AppliesTo(1, "/Satoshi:11.11.11/"));

	BOOST_CHECK(alerts[1].AppliesTo(1, "/Satoshi:0.1.0/"));
	BOOST_CHECK(alerts[1].AppliesTo(999001, "/Satoshi:0.1.0/"));

	BOOST_CHECK(alerts[2].AppliesTo(1, "/Satoshi:0.1.0/"));
	BOOST_CHECK(alerts[2].AppliesTo(1, "/Satoshi:0.2.0/"));

	// Don't match:
	BOOST_CHECK(!alerts[0].AppliesTo(-1, ""));
	BOOST_CHECK(!alerts[0].AppliesTo(999002, ""));

	BOOST_CHECK(!alerts[1].AppliesTo(1, ""));
	BOOST_CHECK(!alerts[1].AppliesTo(1, "Satoshi:0.1.0"));
	BOOST_CHECK(!alerts[1].AppliesTo(1, "/Satoshi:0.1.0"));
	BOOST_CHECK(!alerts[1].AppliesTo(1, "Satoshi:0.1.0/"));
	BOOST_CHECK(!alerts[1].AppliesTo(-1, "/Satoshi:0.1.0/"));
	BOOST_CHECK(!alerts[1].AppliesTo(999002, "/Satoshi:0.1.0/"));
	BOOST_CHECK(!alerts[1].AppliesTo(1, "/Satoshi:0.2.0/"));

	BOOST_CHECK(!alerts[2].AppliesTo(1, "/Satoshi:0.3.0/"));

	SetMockTime(0);
	}


	BOOST_AUTO_TEST_CASE(AlertNotify)
	{
	SetMockTime(11);
	const std::vector<unsigned char>& alertKey = Params(CBaseChainParams::MAIN).AlertKey();

	boost::filesystem::path temp = GetTempPath() /
	boost::filesystem::unique_path("alertnotify-%%%%.txt");

	mapArgs["-alertnotify"] = std::string("echo %s >> ") + temp.string();

	BOOST_FOREACH(CAlert alert, alerts)
	alert.ProcessAlert(alertKey, false);

	std::vector<std::string> r = read_lines(temp);
	BOOST_CHECK_EQUAL(r.size(), 4u);

	// Windows built-in echo semantics are different than posixy shells. Quotes and
	// whitespace are printed literally.

	#ifndef WIN32
	BOOST_CHECK_EQUAL(r[0], "Alert 1");
	BOOST_CHECK_EQUAL(r[1], "Alert 2, cancels 1");
	BOOST_CHECK_EQUAL(r[2], "Alert 2, cancels 1");
	BOOST_CHECK_EQUAL(r[3], "Evil Alert; /bin/ls; echo "); // single-quotes should be removed
	#else
	BOOST_CHECK_EQUAL(r[0], "'Alert 1' ");
	BOOST_CHECK_EQUAL(r[1], "'Alert 2, cancels 1' ");
	BOOST_CHECK_EQUAL(r[2], "'Alert 2, cancels 1' ");
	BOOST_CHECK_EQUAL(r[3], "'Evil Alert; /bin/ls; echo ' ");
	#endif
	boost::filesystem::remove(temp);

	SetMockTime(0);
	}

	static bool falseFunc() { return false; }

	BOOST_AUTO_TEST_CASE(PartitionAlert)
	{
	// Test PartitionCheck
	CCriticalSection csDummy;
	CBlockIndex indexDummy[100];
	CChainParams& params = Params(CBaseChainParams::MAIN);
	int64_t nPowTargetSpacing = params.GetConsensus().nPowTargetSpacing;

	// Generate fake blockchain timestamps relative to
	// an arbitrary time:
	int64_t now = 1427379054;
	SetMockTime(now);
	for (int i = 0; i < 100; i++)
	{
	indexDummy[i].phashBlock = NULL;
	if (i == 0) indexDummy[i].pprev = NULL;
	else indexDummy[i].pprev = &indexDummy[i-1];
	indexDummy[i].nHeight = i;
	indexDummy[i].nTime = now - (100-i)*nPowTargetSpacing;
	// Other members don't matter, the partition check code doesn't
	// use them
	}

	strMiscWarning = "";

	// Test 1: chain with blocks every nPowTargetSpacing seconds,
	// as normal, no worries:
	PartitionCheck(falseFunc, csDummy, &indexDummy[99], nPowTargetSpacing);
	BOOST_CHECK_MESSAGE(strMiscWarning.empty(), strMiscWarning);

	// Test 2: go 3.5 hours without a block, expect a warning:
	now += 36060+30*60;
	SetMockTime(now);
	PartitionCheck(falseFunc, csDummy, &indexDummy[99], nPowTargetSpacing);
	BOOST_CHECK(!strMiscWarning.empty());
	BOOST_TEST_MESSAGE(std::string("Got alert text: ")+strMiscWarning);
	strMiscWarning = "";

	// Test 3: test the "partition alerts only go off once per day"
	// code:
	now += 60*10;
	SetMockTime(now);
	PartitionCheck(falseFunc, csDummy, &indexDummy[99], nPowTargetSpacing);
	BOOST_CHECK(strMiscWarning.empty());

	// Test 4: get 2.5 times as many blocks as expected:
	now += 606024; // Pretend it is a day later
	SetMockTime(now);
	int64_t quickSpacing = nPowTargetSpacing*2/5;
	for (int i = 0; i < 100; i++) // Tweak chain timestamps:
	indexDummy[i].nTime = now - (100-i)*quickSpacing;
	PartitionCheck(falseFunc, csDummy, &indexDummy[99], nPowTargetSpacing);
	BOOST_CHECK(!strMiscWarning.empty());
	BOOST_TEST_MESSAGE(std::string("Got alert text: ")+strMiscWarning);
	strMiscWarning = "";

	SetMockTime(0);
	}

	BOOST_AUTO_TEST_SUITE_END()
	diff --git a/src/test/test_bitcoin.cpp b/src/test/test_bitcoin.cpp
	index 0416d0c926..39586d7bb4 100644
	--- a/src/test/test_bitcoin.cpp
	+++ b/src/test/test_bitcoin.cpp
	@@ -1,170 +1,171 @@
	// Copyright (c) 2011-2015 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#define BOOST_TEST_MODULE Bitcoin Test Suite

	#include "test_bitcoin.h"

	#include "chainparams.h"
	#include "consensus/consensus.h"
	#include "consensus/validation.h"
	#include "key.h"
	#include "main.h"
	#include "miner.h"
	#include "pubkey.h"
	#include "random.h"
	#include "txdb.h"
	#include "txmempool.h"
	#include "ui_interface.h"
	-#include "util.h"
	#ifdef ENABLE_WALLET
	#include "wallet/db.h"
	#include "wallet/wallet.h"
	#endif

	+#include "test/testutil.h"
	+
	#include <boost/filesystem.hpp>
	#include <boost/test/unit_test.hpp>
	#include <boost/thread.hpp>

	CClientUIInterface uiInterface; // Declared but not defined in ui_interface.h
	CWallet* pwalletMain;

	extern bool fPrintToConsole;
	extern void noui_connect();

	BasicTestingSetup::BasicTestingSetup(const std::string& chainName)
	{
	ECC_Start();
	SetupEnvironment();
	SetupNetworking();
	fPrintToDebugLog = false; // don't want to write to debug.log file
	fCheckBlockIndex = true;
	SelectParams(chainName);
	noui_connect();
	}

	BasicTestingSetup::~BasicTestingSetup()
	{
	ECC_Stop();
	}

	TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(chainName)
	{
	const CChainParams& chainparams = Params();
	#ifdef ENABLE_WALLET
	bitdb.MakeMock();
	walletRegisterRPCCommands();
	#endif
	ClearDatadirCache();
	pathTemp = GetTempPath() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
	boost::filesystem::create_directories(pathTemp);
	mapArgs["-datadir"] = pathTemp.string();
	pblocktree = new CBlockTreeDB(1 << 20, true);
	pcoinsdbview = new CCoinsViewDB(1 << 23, true);
	pcoinsTip = new CCoinsViewCache(pcoinsdbview);
	InitBlockIndex(chainparams);
	#ifdef ENABLE_WALLET
	bool fFirstRun;
	pwalletMain = new CWallet("wallet.dat");
	pwalletMain->LoadWallet(fFirstRun);
	RegisterValidationInterface(pwalletMain);
	#endif
	nScriptCheckThreads = 3;
	for (int i=0; i < nScriptCheckThreads-1; i++)
	threadGroup.create_thread(&ThreadScriptCheck);
	RegisterNodeSignals(GetNodeSignals());
	}

	TestingSetup::~TestingSetup()
	{
	UnregisterNodeSignals(GetNodeSignals());
	threadGroup.interrupt_all();
	threadGroup.join_all();
	#ifdef ENABLE_WALLET
	UnregisterValidationInterface(pwalletMain);
	delete pwalletMain;
	pwalletMain = NULL;
	#endif
	UnloadBlockIndex();
	delete pcoinsTip;
	delete pcoinsdbview;
	delete pblocktree;
	#ifdef ENABLE_WALLET
	bitdb.Flush(true);
	bitdb.Reset();
	#endif
	boost::filesystem::remove_all(pathTemp);
	}

	TestChain100Setup::TestChain100Setup() : TestingSetup(CBaseChainParams::REGTEST)
	{
	// Generate a 100-block chain:
	coinbaseKey.MakeNewKey(true);
	CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
	for (int i = 0; i < COINBASE_MATURITY; i++)
	{
	std::vector<CMutableTransaction> noTxns;
	CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
	coinbaseTxns.push_back(b.vtx[0]);
	}
	}

	//
	// Create a new block with just given transactions, coinbase paying to
	// scriptPubKey, and try to add it to the current chain.
	//
	CBlock
	TestChain100Setup::CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns, const CScript& scriptPubKey)
	{
	const CChainParams& chainparams = Params();
	CBlockTemplate *pblocktemplate = CreateNewBlock(chainparams, scriptPubKey);
	CBlock& block = pblocktemplate->block;

	// Replace mempool-selected txns with just coinbase plus passed-in txns:
	block.vtx.resize(1);
	BOOST_FOREACH(const CMutableTransaction& tx, txns)
	block.vtx.push_back(tx);
	// IncrementExtraNonce creates a valid coinbase and merkleRoot
	unsigned int extraNonce = 0;
	IncrementExtraNonce(&block, chainActive.Tip(), extraNonce);

	while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;

	CValidationState state;
	ProcessNewBlock(state, chainparams, NULL, &block, true, NULL);

	CBlock result = block;
	delete pblocktemplate;
	return result;
	}

	TestChain100Setup::~TestChain100Setup()
	{
	}


	CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(CMutableTransaction &tx, CTxMemPool *pool) {
	CTransaction txn(tx);
	bool hasNoDependencies = pool ? pool->HasNoInputsOf(tx) : hadNoDependencies;
	// Hack to assume either its completely dependent on other mempool txs or not at all
	CAmount inChainValue = hasNoDependencies ? txn.GetValueOut() : 0;

	return CTxMemPoolEntry(txn, nFee, nTime, dPriority, nHeight,
	hasNoDependencies, inChainValue, spendsCoinbase, sigOpCount);
	}

	void Shutdown(void* parg)
	{
	exit(0);
	}

	void StartShutdown()
	{
	exit(0);
	}

	bool ShutdownRequested()
	{
	return false;
	}
	diff --git a/src/test/testutil.cpp b/src/test/testutil.cpp
	new file mode 100644
	index 0000000000..304cffb798
	--- /dev/null
	+++ b/src/test/testutil.cpp
	@@ -0,0 +1,33 @@
	+// Copyright (c) 2009-2016 The Bitcoin Core developers
	+// Distributed under the MIT software license, see the accompanying
	+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
	+
	+#include "testutil.h"
	+
	+#ifdef WIN32
	+#include <shlobj.h>
	+#endif
	+
	+#include <boost/filesystem.hpp>
	+
	+boost::filesystem::path GetTempPath() {
	+#if BOOST_FILESYSTEM_VERSION == 3
	+ return boost::filesystem::temp_directory_path();
	+#else
	+ // TODO: remove when we don't support filesystem v2 anymore
	+ boost::filesystem::path path;
	+#ifdef WIN32
	+ char pszPath[MAX_PATH] = "";
	+
	+ if (GetTempPathA(MAX_PATH, pszPath))
	+ path = boost::filesystem::path(pszPath);
	+#else
	+ path = boost::filesystem::path("/tmp");
	+#endif
	+ if (path.empty() \|\| !boost::filesystem::is_directory(path)) {
	+ LogPrintf("GetTempPath(): failed to find temp path\n");
	+ return boost::filesystem::path("");
	+ }
	+ return path;
	+#endif
	+}
	diff --git a/src/test/testutil.h b/src/test/testutil.h
	new file mode 100644
	index 0000000000..5875dc50e6
	--- /dev/null
	+++ b/src/test/testutil.h
	@@ -0,0 +1,15 @@
	+// Copyright (c) 2009-2016 The Bitcoin Core developers
	+// Distributed under the MIT software license, see the accompanying
	+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
	+
	+/**
	+ * Utility functions shared by unit tests
	+ */
	+#ifndef BITCOIN_TEST_TESTUTIL_H
	+#define BITCOIN_TEST_TESTUTIL_H
	+
	+#include <boost/filesystem/path.hpp>
	+
	+boost::filesystem::path GetTempPath();
	+
	+#endif // BITCOIN_TEST_TESTUTIL_H
	diff --git a/src/util.cpp b/src/util.cpp
	index 492697e12f..59f58f2c55 100644
	--- a/src/util.cpp
	+++ b/src/util.cpp
	@@ -1,849 +1,827 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2015 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#if defined(HAVE_CONFIG_H)
	#include "config/bitcoin-config.h"
	#endif

	#include "util.h"

	#include "chainparamsbase.h"
	#include "random.h"
	#include "serialize.h"
	#include "sync.h"
	#include "utilstrencodings.h"
	#include "utiltime.h"

	#include <stdarg.h>

	#if (defined(__FreeBSD__) \|\| defined(__OpenBSD__) \|\| defined(__DragonFly__))
	#include <pthread.h>
	#include <pthread_np.h>
	#endif

	#ifndef WIN32
	// for posix_fallocate
	#ifdef __linux__

	#ifdef _POSIX_C_SOURCE
	#undef _POSIX_C_SOURCE
	#endif

	#define _POSIX_C_SOURCE 200112L

	#endif // __linux__

	#include <algorithm>
	#include <fcntl.h>
	#include <sys/resource.h>
	#include <sys/stat.h>

	#else

	#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

	#ifdef HAVE_SYS_PRCTL_H
	#include <sys/prctl.h>
	#endif

	#include <boost/algorithm/string/case_conv.hpp> // for to_lower()
	#include <boost/algorithm/string/join.hpp>
	#include <boost/algorithm/string/predicate.hpp> // for startswith() and endswith()
	#include <boost/filesystem.hpp>
	#include <boost/filesystem/fstream.hpp>
	#include <boost/foreach.hpp>
	#include <boost/program_options/detail/config_file.hpp>
	#include <boost/program_options/parsers.hpp>
	#include <boost/thread.hpp>
	#include <openssl/crypto.h>
	#include <openssl/rand.h>
	#include <openssl/conf.h>

	// 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&);
	}

	} // namespace boost

	using namespace std;

	const char * const BITCOIN_CONF_FILENAME = "bitcoin.conf";
	const char * const BITCOIN_PID_FILENAME = "bitcoind.pid";

	map<string, string> mapArgs;
	map<string, vector<string> > mapMultiArgs;
	bool fDebug = false;
	bool fPrintToConsole = false;
	bool fPrintToDebugLog = true;
	bool fDaemon = false;
	bool fServer = false;
	string strMiscWarning;
	bool fLogTimestamps = DEFAULT_LOGTIMESTAMPS;
	bool fLogTimeMicros = DEFAULT_LOGTIMEMICROS;
	bool fLogIPs = DEFAULT_LOGIPS;
	volatile bool fReopenDebugLog = false;
	CTranslationInterface translationInterface;

	/** Init OpenSSL library multithreading support */
	static CCriticalSection** ppmutexOpenSSL;
	void locking_callback(int mode, int i, const char* file, int line) NO_THREAD_SAFETY_ANALYSIS
	{
	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);

	// OpenSSL can optionally load a config file which lists optional loadable modules and engines.
	// We don't use them so we don't require the config. However some of our libs may call functions
	// which attempt to load the config file, possibly resulting in an exit() or crash if it is missing
	// or corrupt. Explicitly tell OpenSSL not to try to load the file. The result for our libs will be
	// that the config appears to have been loaded and there are no modules/engines available.
	OPENSSL_no_config();

	#ifdef WIN32
	// Seed OpenSSL PRNG with current contents of the screen
	RAND_screen();
	#endif

	// Seed OpenSSL PRNG with performance counter
	RandAddSeed();
	}
	~CInit()
	{
	// Securely erase the memory used by the PRNG
	RAND_cleanup();
	// 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;

	/**
	* LogPrintf() has been broken a couple of times now
	* by well-meaning people adding mutexes in the most straightforward way.
	* It breaks because it may be called by global destructors during shutdown.
	* Since the order of destruction of static/global objects is undefined,
	* defining a mutex as a global object doesn't work (the mutex gets
	* destroyed, and then some later destructor calls OutputDebugStringF,
	* maybe indirectly, and you get a core dump at shutdown trying to lock
	* the mutex).
	*/

	static boost::once_flag debugPrintInitFlag = BOOST_ONCE_INIT;

	/**
	* We use boost::call_once() to make sure mutexDebugLog and
	* vMsgsBeforeOpenLog are initialized in a thread-safe manner.
	*
	* NOTE: fileout, mutexDebugLog and sometimes vMsgsBeforeOpenLog
	* are leaked on exit. This is ugly, but will be cleaned up by
	* the OS/libc. When the shutdown sequence is fully audited and
	* tested, explicit destruction of these objects can be implemented.
	*/
	static FILE* fileout = NULL;
	static boost::mutex* mutexDebugLog = NULL;
	static list<string> *vMsgsBeforeOpenLog;

	static int FileWriteStr(const std::string &str, FILE *fp)
	{
	return fwrite(str.data(), 1, str.size(), fp);
	}

	static void DebugPrintInit()
	{
	assert(mutexDebugLog == NULL);
	mutexDebugLog = new boost::mutex();
	vMsgsBeforeOpenLog = new list<string>;
	}

	void OpenDebugLog()
	{
	boost::call_once(&DebugPrintInit, debugPrintInitFlag);
	boost::mutex::scoped_lock scoped_lock(*mutexDebugLog);

	assert(fileout == NULL);
	assert(vMsgsBeforeOpenLog);
	boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
	fileout = fopen(pathDebug.string().c_str(), "a");
	if (fileout) setbuf(fileout, NULL); // unbuffered

	// dump buffered messages from before we opened the log
	while (!vMsgsBeforeOpenLog->empty()) {
	FileWriteStr(vMsgsBeforeOpenLog->front(), fileout);
	vMsgsBeforeOpenLog->pop_front();
	}

	delete vMsgsBeforeOpenLog;
	vMsgsBeforeOpenLog = NULL;
	}

	bool LogAcceptCategory(const char* category)
	{
	if (category != NULL)
	{
	if (!fDebug)
	return false;

	// Give each thread quick access to -debug settings.
	// This helps prevent issues debugging global destructors,
	// where mapMultiArgs might be deleted before another
	// global destructor calls LogPrint()
	static boost::thread_specific_ptr<set<string> > ptrCategory;
	if (ptrCategory.get() == NULL)
	{
	const vector<string>& categories = mapMultiArgs["-debug"];
	ptrCategory.reset(new set<string>(categories.begin(), categories.end()));
	// thread_specific_ptr automatically deletes the set when the thread ends.
	}
	const set<string>& setCategories = *ptrCategory.get();

	// if not debugging everything and not debugging specific category, LogPrint does nothing.
	if (setCategories.count(string("")) == 0 &&
	setCategories.count(string("1")) == 0 &&
	setCategories.count(string(category)) == 0)
	return false;
	}
	return true;
	}

	/**
	* fStartedNewLine is a state variable held by the calling context that will
	* suppress printing of the timestamp when multiple calls are made that don't
	* end in a newline. Initialize it to true, and hold it, in the calling context.
	*/
	static std::string LogTimestampStr(const std::string &str, bool *fStartedNewLine)
	{
	string strStamped;

	if (!fLogTimestamps)
	return str;

	if (*fStartedNewLine) {
	int64_t nTimeMicros = GetLogTimeMicros();
	strStamped = DateTimeStrFormat("%Y-%m-%d %H:%M:%S", nTimeMicros/1000000);
	if (fLogTimeMicros)
	strStamped += strprintf(".%06d", nTimeMicros%1000000);
	strStamped += ' ' + str;
	} else
	strStamped = str;

	if (!str.empty() && str[str.size()-1] == '\n')
	*fStartedNewLine = true;
	else
	*fStartedNewLine = false;

	return strStamped;
	}

	int LogPrintStr(const std::string &str)
	{
	int ret = 0; // Returns total number of characters written
	static bool fStartedNewLine = true;

	string strTimestamped = LogTimestampStr(str, &fStartedNewLine);

	if (fPrintToConsole)
	{
	// print to console
	ret = fwrite(strTimestamped.data(), 1, strTimestamped.size(), stdout);
	fflush(stdout);
	}
	else if (fPrintToDebugLog)
	{
	boost::call_once(&DebugPrintInit, debugPrintInitFlag);
	boost::mutex::scoped_lock scoped_lock(*mutexDebugLog);

	// buffer if we haven't opened the log yet
	if (fileout == NULL) {
	assert(vMsgsBeforeOpenLog);
	ret = strTimestamped.length();
	vMsgsBeforeOpenLog->push_back(strTimestamped);
	}
	else
	{
	// 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
	}

	ret = FileWriteStr(strTimestamped, fileout);
	}
	}
	return ret;
	}

	/** Interpret string as boolean, for argument parsing */
	static bool InterpretBool(const std::string& strValue)
	{
	if (strValue.empty())
	return true;
	return (atoi(strValue) != 0);
	}

	/** Turn -noX into -X=0 */
	static void InterpretNegativeSetting(std::string& strKey, std::string& strValue)
	{
	if (strKey.length()>3 && strKey[0]=='-' && strKey[1]=='n' && strKey[2]=='o')
	{
	strKey = "-" + strKey.substr(3);
	strValue = InterpretBool(strValue) ? "0" : "1";
	}
	}

	void ParseParameters(int argc, const char* const argv[])
	{
	mapArgs.clear();
	mapMultiArgs.clear();

	for (int i = 1; i < argc; i++)
	{
	std::string str(argv[i]);
	std::string strValue;
	size_t is_index = str.find('=');
	if (is_index != std::string::npos)
	{
	strValue = str.substr(is_index+1);
	str = str.substr(0, is_index);
	}
	#ifdef WIN32
	boost::to_lower(str);
	if (boost::algorithm::starts_with(str, "/"))
	str = "-" + str.substr(1);
	#endif

	if (str[0] != '-')
	break;

	// Interpret --foo as -foo.
	// If both --foo and -foo are set, the last takes effect.
	if (str.length() > 1 && str[1] == '-')
	str = str.substr(1);
	InterpretNegativeSetting(str, strValue);

	mapArgs[str] = strValue;
	mapMultiArgs[str].push_back(strValue);
	}
	}

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

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

	bool GetBoolArg(const std::string& strArg, bool fDefault)
	{
	if (mapArgs.count(strArg))
	return InterpretBool(mapArgs[strArg]);
	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"));
	}

	static const int screenWidth = 79;
	static const int optIndent = 2;
	static const int msgIndent = 7;

	std::string HelpMessageGroup(const std::string &message) {
	return std::string(message) + std::string("\n\n");
	}

	std::string HelpMessageOpt(const std::string &option, const std::string &message) {
	return std::string(optIndent,' ') + std::string(option) +
	std::string("\n") + std::string(msgIndent,' ') +
	FormatParagraph(message, screenWidth - msgIndent, msgIndent) +
	std::string("\n\n");
	}

	static std::string FormatException(const 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 PrintExceptionContinue(const std::exception* pex, const char* pszThread)
	{
	std::string message = FormatException(pex, pszThread);
	LogPrintf("\n\n************************\n%s\n", message);
	fprintf(stderr, "\n\n************************\n%s\n", message.c_str());
	}

	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";
	TryCreateDirectory(pathRet);
	return pathRet / "Bitcoin";
	#else
	// Unix
	return pathRet / ".bitcoin";
	#endif
	#endif
	}

	static boost::filesystem::path pathCached;
	static boost::filesystem::path pathCachedNetSpecific;
	static CCriticalSection csPathCached;

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

	LOCK(csPathCached);

	fs::path &path = fNetSpecific ? pathCachedNetSpecific : pathCached;

	// This can be called during exceptions by LogPrintf(), so we cache the
	// value so we don't have to do memory allocations after that.
	if (!path.empty())
	return path;

	if (mapArgs.count("-datadir")) {
	path = fs::system_complete(mapArgs["-datadir"]);
	if (!fs::is_directory(path)) {
	path = "";
	return path;
	}
	} else {
	path = GetDefaultDataDir();
	}
	if (fNetSpecific)
	path /= BaseParams().DataDir();

	fs::create_directories(path);

	return path;
	}

	void ClearDatadirCache()
	{
	pathCached = boost::filesystem::path();
	pathCachedNetSpecific = boost::filesystem::path();
	}

	boost::filesystem::path GetConfigFile()
	{
	boost::filesystem::path pathConfigFile(GetArg("-conf", BITCOIN_CONF_FILENAME));
	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;
	string strValue = it->value[0];
	InterpretNegativeSetting(strKey, strValue);
	if (mapSettingsRet.count(strKey) == 0)
	mapSettingsRet[strKey] = strValue;
	mapMultiSettingsRet[strKey].push_back(strValue);
	}
	// If datadir is changed in .conf file:
	ClearDatadirCache();
	}

	#ifndef WIN32
	boost::filesystem::path GetPidFile()
	{
	boost::filesystem::path pathPidFile(GetArg("-pid", BITCOIN_PID_FILENAME));
	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);
	}
	}
	#endif

	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) != 0;
	#else
	int rc = std::rename(src.string().c_str(), dest.string().c_str());
	return (rc == 0);
	#endif /* WIN32 */
	}

	/**
	* Ignores exceptions thrown by Boost's create_directory if the requested directory exists.
	* Specifically handles case where path p exists, but it wasn't possible for the user to
	* write to the parent directory.
	*/
	bool TryCreateDirectory(const boost::filesystem::path& p)
	{
	try
	{
	return boost::filesystem::create_directory(p);
	} catch (const boost::filesystem::filesystem_error&) {
	if (!boost::filesystem::exists(p) \|\| !boost::filesystem::is_directory(p))
	throw;
	}

	// create_directory didn't create the directory, it had to have existed already
	return false;
	}

	void FileCommit(FILE *fileout)
	{
	fflush(fileout); // harmless if redundantly called
	#ifdef WIN32
	HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(fileout));
	FlushFileBuffers(hFile);
	#else
	#if defined(__linux__) \|\| defined(__NetBSD__)
	fdatasync(fileno(fileout));
	#elif defined(__APPLE__) && defined(F_FULLFSYNC)
	fcntl(fileno(fileout), F_FULLFSYNC, 0);
	#else
	fsync(fileno(fileout));
	#endif
	#endif
	}

	bool TruncateFile(FILE *file, unsigned int length) {
	#if defined(WIN32)
	return _chsize(_fileno(file), length) == 0;
	#else
	return ftruncate(fileno(file), length) == 0;
	#endif
	}

	/**
	* this function tries to raise the file descriptor limit to the requested number.
	* It returns the actual file descriptor limit (which may be more or less than nMinFD)
	*/
	int RaiseFileDescriptorLimit(int nMinFD) {
	#if defined(WIN32)
	return 2048;
	#else
	struct rlimit limitFD;
	if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
	if (limitFD.rlim_cur < (rlim_t)nMinFD) {
	limitFD.rlim_cur = nMinFD;
	if (limitFD.rlim_cur > limitFD.rlim_max)
	limitFD.rlim_cur = limitFD.rlim_max;
	setrlimit(RLIMIT_NOFILE, &limitFD);
	getrlimit(RLIMIT_NOFILE, &limitFD);
	}
	return limitFD.rlim_cur;
	}
	return nMinFD; // getrlimit failed, assume it's fine
	#endif
	}

	/**
	* this function tries to make a particular range of a file allocated (corresponding to disk space)
	* it is advisory, and the range specified in the arguments will never contain live data
	*/
	void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length) {
	#if defined(WIN32)
	// Windows-specific version
	HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
	LARGE_INTEGER nFileSize;
	int64_t nEndPos = (int64_t)offset + length;
	nFileSize.u.LowPart = nEndPos & 0xFFFFFFFF;
	nFileSize.u.HighPart = nEndPos >> 32;
	SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
	SetEndOfFile(hFile);
	#elif defined(MAC_OSX)
	// OSX specific version
	fstore_t fst;
	fst.fst_flags = F_ALLOCATECONTIG;
	fst.fst_posmode = F_PEOFPOSMODE;
	fst.fst_offset = 0;
	fst.fst_length = (off_t)offset + length;
	fst.fst_bytesalloc = 0;
	if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
	fst.fst_flags = F_ALLOCATEALL;
	fcntl(fileno(file), F_PREALLOCATE, &fst);
	}
	ftruncate(fileno(file), fst.fst_length);
	#elif defined(__linux__)
	// Version using posix_fallocate
	off_t nEndPos = (off_t)offset + length;
	posix_fallocate(fileno(file), 0, nEndPos);
	#else
	// Fallback version
	// TODO: just write one byte per block
	static const char buf[65536] = {};
	fseek(file, offset, SEEK_SET);
	while (length > 0) {
	unsigned int now = 65536;
	if (length < now)
	now = length;
	fwrite(buf, 1, now, file); // allowed to fail; this function is advisory anyway
	length -= now;
	}
	#endif
	}

	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 && boost::filesystem::file_size(pathLog) > 10 * 1000000)
	{
	// Restart the file with some of the end
	std::vector <char> vch(200000,0);
	fseek(file, -((long)vch.size()), SEEK_END);
	int nBytes = fread(begin_ptr(vch), 1, vch.size(), file);
	fclose(file);

	file = fopen(pathLog.string().c_str(), "w");
	if (file)
	{
	fwrite(begin_ptr(vch), 1, nBytes, file);
	fclose(file);
	}
	}
	else if (file != NULL)
	fclose(file);
	}

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

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

	-boost::filesystem::path GetTempPath() {
	-#if BOOST_FILESYSTEM_VERSION == 3
	- return boost::filesystem::temp_directory_path();
	-#else
	- // TODO: remove when we don't support filesystem v2 anymore
	- boost::filesystem::path path;
	-#ifdef WIN32
	- char pszPath[MAX_PATH] = "";
	-
	- if (GetTempPathA(MAX_PATH, pszPath))
	- path = boost::filesystem::path(pszPath);
	-#else
	- path = boost::filesystem::path("/tmp");
	-#endif
	- if (path.empty() \|\| !boost::filesystem::is_directory(path)) {
	- LogPrintf("GetTempPath(): failed to find temp path\n");
	- return boost::filesystem::path("");
	- }
	- return path;
	-#endif
	-}
	-
	void runCommand(const std::string& strCommand)
	{
	int nErr = ::system(strCommand.c_str());
	if (nErr)
	LogPrintf("runCommand error: system(%s) returned %d\n", strCommand, nErr);
	}

	void RenameThread(const char* name)
	{
	#if defined(PR_SET_NAME)
	// Only the first 15 characters are used (16 - NUL terminator)
	::prctl(PR_SET_NAME, name, 0, 0, 0);
	#elif (defined(__FreeBSD__) \|\| defined(__OpenBSD__) \|\| defined(__DragonFly__))
	pthread_set_name_np(pthread_self(), name);

	#elif defined(MAC_OSX)
	pthread_setname_np(name);
	#else
	// Prevent warnings for unused parameters...
	(void)name;
	#endif
	}

	void SetupEnvironment()
	{
	// On most POSIX systems (e.g. Linux, but not BSD) the environment's locale
	// may be invalid, in which case the "C" locale is used as fallback.
	#if !defined(WIN32) && !defined(MAC_OSX) && !defined(__FreeBSD__) && !defined(__OpenBSD__)
	try {
	std::locale(""); // Raises a runtime error if current locale is invalid
	} catch (const std::runtime_error&) {
	setenv("LC_ALL", "C", 1);
	}
	#endif
	// The path locale is lazy initialized and to avoid deinitialization errors
	// in multithreading environments, it is set explicitly by the main thread.
	// A dummy locale is used to extract the internal default locale, used by
	// boost::filesystem::path, which is then used to explicitly imbue the path.
	std::locale loc = boost::filesystem::path::imbue(std::locale::classic());
	boost::filesystem::path::imbue(loc);
	}

	bool SetupNetworking()
	{
	#ifdef WIN32
	// Initialize Windows Sockets
	WSADATA wsadata;
	int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
	if (ret != NO_ERROR \|\| LOBYTE(wsadata.wVersion ) != 2 \|\| HIBYTE(wsadata.wVersion) != 2)
	return false;
	#endif
	return true;
	}

	void SetThreadPriority(int nPriority)
	{
	#ifdef WIN32
	SetThreadPriority(GetCurrentThread(), nPriority);
	#else // WIN32
	#ifdef PRIO_THREAD
	setpriority(PRIO_THREAD, 0, nPriority);
	#else // PRIO_THREAD
	setpriority(PRIO_PROCESS, 0, nPriority);
	#endif // PRIO_THREAD
	#endif // WIN32
	}

	int GetNumCores()
	{
	#if BOOST_VERSION >= 105600
	return boost::thread::physical_concurrency();
	#else // Must fall back to hardware_concurrency, which unfortunately counts virtual cores
	return boost::thread::hardware_concurrency();
	#endif
	}

	std::string CopyrightHolders(const std::string& strPrefix)
	{
	std::string strCopyrightHolders = strPrefix + _(COPYRIGHT_HOLDERS);
	if (strCopyrightHolders.find("%s") != strCopyrightHolders.npos) {
	strCopyrightHolders = strprintf(strCopyrightHolders, _(COPYRIGHT_HOLDERS_SUBSTITUTION));
	}
	if (strCopyrightHolders.find("Bitcoin Core developers") == strCopyrightHolders.npos) {
	strCopyrightHolders += "\n" + strPrefix + "The Bitcoin Core developers";
	}
	return strCopyrightHolders;
	}
	diff --git a/src/util.h b/src/util.h
	index 9da8fdf87a..ac099f1184 100644
	--- a/src/util.h
	+++ b/src/util.h
	@@ -1,252 +1,251 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2015 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	/**
	* Server/client environment: argument handling, config file parsing,
	* logging, thread wrappers
	*/
	#ifndef BITCOIN_UTIL_H
	#define BITCOIN_UTIL_H

	#if defined(HAVE_CONFIG_H)
	#include "config/bitcoin-config.h"
	#endif

	#include "compat.h"
	#include "tinyformat.h"
	#include "utiltime.h"

	#include <exception>
	#include <map>
	#include <stdint.h>
	#include <string>
	#include <vector>

	#include <boost/filesystem/path.hpp>
	#include <boost/signals2/signal.hpp>
	#include <boost/thread/exceptions.hpp>

	static const bool DEFAULT_LOGTIMEMICROS = false;
	static const bool DEFAULT_LOGIPS = false;
	static const bool DEFAULT_LOGTIMESTAMPS = true;

	/** Signals for translation. */
	class CTranslationInterface
	{
	public:
	/** Translate a message to the native language of the user. */
	boost::signals2::signal<std::string (const char* psz)> Translate;
	};

	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 fPrintToDebugLog;
	extern bool fServer;
	extern std::string strMiscWarning;
	extern bool fLogTimestamps;
	extern bool fLogTimeMicros;
	extern bool fLogIPs;
	extern volatile bool fReopenDebugLog;
	extern CTranslationInterface translationInterface;

	extern const char * const BITCOIN_CONF_FILENAME;
	extern const char * const BITCOIN_PID_FILENAME;

	/**
	* Translation function: Call Translate signal on UI interface, which returns a boost::optional result.
	* If no translation slot is registered, nothing is returned, and simply return the input.
	*/
	inline std::string _(const char* psz)
	{
	boost::optional<std::string> rv = translationInterface.Translate(psz);
	return rv ? (*rv) : psz;
	}

	void SetupEnvironment();
	bool SetupNetworking();

	/** Return true if log accepts specified category */
	bool LogAcceptCategory(const char* category);
	/** Send a string to the log output */
	int LogPrintStr(const std::string &str);

	#define LogPrintf(...) LogPrint(NULL, __VA_ARGS__)

	/**
	* When we switch to C++11, this can be switched to variadic templates instead
	* of this macro-based construction (see tinyformat.h).
	*/
	#define MAKE_ERROR_AND_LOG_FUNC(n) \
	/** Print to debug.log if -debug=category switch is given OR category is NULL. */ \
	template<TINYFORMAT_ARGTYPES(n)> \
	static inline int LogPrint(const char* category, const char* format, TINYFORMAT_VARARGS(n)) \
	{ \
	if(!LogAcceptCategory(category)) return 0; \
	return LogPrintStr(tfm::format(format, TINYFORMAT_PASSARGS(n))); \
	} \
	/** Log error and return false */ \
	template<TINYFORMAT_ARGTYPES(n)> \
	static inline bool error(const char* format, TINYFORMAT_VARARGS(n)) \
	{ \
	LogPrintStr("ERROR: " + tfm::format(format, TINYFORMAT_PASSARGS(n)) + "\n"); \
	return false; \
	}

	TINYFORMAT_FOREACH_ARGNUM(MAKE_ERROR_AND_LOG_FUNC)

	/**
	* Zero-arg versions of logging and error, these are not covered by
	* TINYFORMAT_FOREACH_ARGNUM
	*/
	static inline int LogPrint(const char* category, const char* format)
	{
	if(!LogAcceptCategory(category)) return 0;
	return LogPrintStr(format);
	}
	static inline bool error(const char* format)
	{
	LogPrintStr(std::string("ERROR: ") + format + "\n");
	return false;
	}

	void PrintExceptionContinue(const std::exception pex, const char pszThread);
	void ParseParameters(int argc, const char*const argv[]);
	void FileCommit(FILE *fileout);
	bool TruncateFile(FILE *file, unsigned int length);
	int RaiseFileDescriptorLimit(int nMinFD);
	void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length);
	bool RenameOver(boost::filesystem::path src, boost::filesystem::path dest);
	bool TryCreateDirectory(const boost::filesystem::path& p);
	boost::filesystem::path GetDefaultDataDir();
	const boost::filesystem::path &GetDataDir(bool fNetSpecific = true);
	void ClearDatadirCache();
	boost::filesystem::path GetConfigFile();
	#ifndef WIN32
	boost::filesystem::path GetPidFile();
	void CreatePidFile(const boost::filesystem::path &path, pid_t pid);
	#endif
	void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet, std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
	#ifdef WIN32
	boost::filesystem::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
	#endif
	-boost::filesystem::path GetTempPath();
	void OpenDebugLog();
	void ShrinkDebugFile();
	void runCommand(const std::string& strCommand);

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

	/**
	* Return string argument or default value
	*
	* @param strArg Argument to get (e.g. "-foo")
	* @param default (e.g. "1")
	* @return command-line argument or default value
	*/
	std::string GetArg(const std::string& strArg, const std::string& strDefault);

	/**
	* Return integer argument or default value
	*
	* @param strArg Argument to get (e.g. "-foo")
	* @param default (e.g. 1)
	* @return command-line argument (0 if invalid number) or default value
	*/
	int64_t GetArg(const std::string& strArg, int64_t nDefault);

	/**
	* Return boolean argument or default value
	*
	* @param strArg Argument to get (e.g. "-foo")
	* @param default (true or false)
	* @return command-line argument or default value
	*/
	bool GetBoolArg(const std::string& strArg, bool fDefault);

	/**
	* Set an argument if it doesn't already have a value
	*
	* @param strArg Argument to set (e.g. "-foo")
	* @param strValue Value (e.g. "1")
	* @return true if argument gets set, false if it already had a value
	*/
	bool SoftSetArg(const std::string& strArg, const std::string& strValue);

	/**
	* Set a boolean argument if it doesn't already have a value
	*
	* @param strArg Argument to set (e.g. "-foo")
	* @param fValue Value (e.g. false)
	* @return true if argument gets set, false if it already had a value
	*/
	bool SoftSetBoolArg(const std::string& strArg, bool fValue);

	/**
	* Format a string to be used as group of options in help messages
	*
	* @param message Group name (e.g. "RPC server options:")
	* @return the formatted string
	*/
	std::string HelpMessageGroup(const std::string& message);

	/**
	* Format a string to be used as option description in help messages
	*
	* @param option Option message (e.g. "-rpcuser=<user>")
	* @param message Option description (e.g. "Username for JSON-RPC connections")
	* @return the formatted string
	*/
	std::string HelpMessageOpt(const std::string& option, const std::string& message);

	/**
	* Return the number of physical cores available on the current system.
	* @note This does not count virtual cores, such as those provided by HyperThreading
	* when boost is newer than 1.56.
	*/
	int GetNumCores();

	void SetThreadPriority(int nPriority);
	void RenameThread(const char* name);

	/**
	* .. and a wrapper that just calls func once
	*/
	template <typename Callable> void TraceThread(const char* name, Callable func)
	{
	std::string s = strprintf("bitcoin-%s", name);
	RenameThread(s.c_str());
	try
	{
	LogPrintf("%s thread start\n", name);
	func();
	LogPrintf("%s thread exit\n", name);
	}
	catch (const boost::thread_interrupted&)
	{
	LogPrintf("%s thread interrupt\n", name);
	throw;
	}
	catch (const std::exception& e) {
	PrintExceptionContinue(&e, name);
	throw;
	}
	catch (...) {
	PrintExceptionContinue(NULL, name);
	throw;
	}
	}

	std::string CopyrightHolders(const std::string& strPrefix);

	#endif // BITCOIN_UTIL_H

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 09:20 (1 d, 24 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187186
Default Alt Text: (54 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions