No OneTemporary
Actions

Size

33 KB

Subscribers

None

View Options

	diff --git a/src/init.cpp b/src/init.cpp
	index 4e193ffe3..69f780f4d 100644
	--- a/src/init.cpp
	+++ b/src/init.cpp
	@@ -1,686 +1,696 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2012 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.
	#include "db.h"
	#include "walletdb.h"
	#include "bitcoinrpc.h"
	#include "net.h"
	#include "init.h"
	#include "util.h"
	#include "ui_interface.h"
	#include <boost/filesystem.hpp>
	#include <boost/filesystem/fstream.hpp>
	#include <boost/filesystem/convenience.hpp>
	#include <boost/interprocess/sync/file_lock.hpp>
	#include <boost/algorithm/string/predicate.hpp>

	#ifndef WIN32
	#include <signal.h>
	#endif

	using namespace std;
	using namespace boost;

	CWallet* pwalletMain;
	CClientUIInterface uiInterface;

	//////////////////////////////////////////////////////////////////////////////
	//
	// Shutdown
	//

	void ExitTimeout(void* parg)
	{
	#ifdef WIN32
	Sleep(5000);
	ExitProcess(0);
	#endif
	}

	void Shutdown(void* parg)
	{
	static CCriticalSection cs_Shutdown;
	static bool fTaken;
	bool fFirstThread = false;
	{
	TRY_LOCK(cs_Shutdown, lockShutdown);
	if (lockShutdown)
	{
	fFirstThread = !fTaken;
	fTaken = true;
	}
	}
	static bool fExit;
	if (fFirstThread)
	{
	fShutdown = true;
	nTransactionsUpdated++;
	DBFlush(false);
	StopNode();
	DBFlush(true);
	boost::filesystem::remove(GetPidFile());
	UnregisterWallet(pwalletMain);
	delete pwalletMain;
	CreateThread(ExitTimeout, NULL);
	Sleep(50);
	printf("Bitcoin exited\n\n");
	fExit = true;
	exit(0);
	}
	else
	{
	while (!fExit)
	Sleep(500);
	Sleep(100);
	ExitThread(0);
	}
	}

	void HandleSIGTERM(int)
	{
	fRequestShutdown = true;
	}






	//////////////////////////////////////////////////////////////////////////////
	//
	// Start
	//
	#if !defined(QT_GUI)
	bool AppInit(int argc, char* argv[])
	{
	bool fRet = false;
	try
	{
	//
	// Parameters
	//
	// If Qt is used, parameters/bitcoin.conf are parsed in qt/bitcoin.cpp's main()
	ParseParameters(argc, argv);
	if (!boost::filesystem::is_directory(GetDataDir(false)))
	{
	fprintf(stderr, "Error: Specified directory does not exist\n");
	Shutdown(NULL);
	}
	ReadConfigFile(mapArgs, mapMultiArgs);

	if (mapArgs.count("-?") \|\| mapArgs.count("--help"))
	{
	// First part of help message is specific to bitcoind / RPC client
	std::string strUsage = _("Bitcoin version") + " " + FormatFullVersion() + "\n\n" +
	_("Usage:") + "\n" +
	" bitcoind [options] " + "\n" +
	" bitcoind [options] <command> [params] " + _("Send command to -server or bitcoind") + "\n" +
	" bitcoind [options] help " + _("List commands") + "\n" +
	" bitcoind [options] help <command> " + _("Get help for a command") + "\n";

	strUsage += "\n" + HelpMessage();

	fprintf(stderr, "%s", strUsage.c_str());
	return false;
	}

	// Command-line RPC
	for (int i = 1; i < argc; i++)
	if (!IsSwitchChar(argv[i][0]) && !boost::algorithm::istarts_with(argv[i], "bitcoin:"))
	fCommandLine = true;

	if (fCommandLine)
	{
	int ret = CommandLineRPC(argc, argv);
	exit(ret);
	}

	fRet = AppInit2();
	}
	catch (std::exception& e) {
	PrintException(&e, "AppInit()");
	} catch (...) {
	PrintException(NULL, "AppInit()");
	}
	if (!fRet)
	Shutdown(NULL);
	return fRet;
	}

	extern void noui_connect();
	int main(int argc, char* argv[])
	{
	bool fRet = false;

	// Connect bitcoind signal handlers
	noui_connect();

	fRet = AppInit(argc, argv);

	if (fRet && fDaemon)
	return 0;

	return 1;
	}
	#endif

	bool static InitError(const std::string &str)
	{
	uiInterface.ThreadSafeMessageBox(str, _("Bitcoin"), CClientUIInterface::OK \| CClientUIInterface::MODAL);
	return false;
	}

	bool static InitWarning(const std::string &str)
	{
	uiInterface.ThreadSafeMessageBox(str, _("Bitcoin"), CClientUIInterface::OK \| CClientUIInterface::ICON_EXCLAMATION \| CClientUIInterface::MODAL);
	return true;
	}


	bool static Bind(const CService &addr) {
	if (IsLimited(addr))
	return false;
	std::string strError;
	if (!BindListenPort(addr, strError))
	return InitError(strError);
	return true;
	}

	// Core-specific options shared between UI and daemon
	std::string HelpMessage()
	{
	string strUsage = _("Options:") + "\n" +
	" -conf=<file> " + _("Specify configuration file (default: bitcoin.conf)") + "\n" +
	" -pid=<file> " + _("Specify pid file (default: bitcoind.pid)") + "\n" +
	" -gen " + _("Generate coins") + "\n" +
	" -gen=0 " + _("Don't generate coins") + "\n" +
	" -datadir=<dir> " + _("Specify data directory") + "\n" +
	" -dbcache=<n> " + _("Set database cache size in megabytes (default: 25)") + "\n" +
	" -dblogsize=<n> " + _("Set database disk log size in megabytes (default: 100)") + "\n" +
	" -timeout=<n> " + _("Specify connection timeout (in milliseconds)") + "\n" +
	" -proxy=<ip:port> " + _("Connect through socks proxy") + "\n" +
	" -socks=<n> " + _("Select the version of socks proxy to use (4 or 5, 5 is default)") + "\n" +
	" -noproxy=<net> " + _("Do not use proxy for connections to network <net> (IPv4 or IPv6)") + "\n" +
	" -dns " + _("Allow DNS lookups for -addnode, -seednode and -connect") + "\n" +
	" -proxydns " + _("Pass DNS requests to (SOCKS5) proxy") + "\n" +
	" -port=<port> " + _("Listen for connections on <port> (default: 8333 or testnet: 18333)") + "\n" +
	" -maxconnections=<n> " + _("Maintain at most <n> connections to peers (default: 125)") + "\n" +
	" -addnode=<ip> " + _("Add a node to connect to and attempt to keep the connection open") + "\n" +
	" -connect=<ip> " + _("Connect only to the specified node") + "\n" +
	" -seednode=<ip> " + _("Connect to a node to retrieve peer addresses, and disconnect") + "\n" +
	" -externalip=<ip> " + _("Specify your own public address") + "\n" +
	" -onlynet=<net> " + _("Only connect to nodes in network <net> (IPv4 or IPv6)") + "\n" +
	" -discover " + _("Try to discover public IP address (default: 1)") + "\n" +
	" -irc " + _("Find peers using internet relay chat (default: 0)") + "\n" +
	" -listen " + _("Accept connections from outside (default: 1)") + "\n" +
	" -bind=<addr> " + _("Bind to given address. Use [host]:port notation for IPv6") + "\n" +
	" -dnsseed " + _("Find peers using DNS lookup (default: 1)") + "\n" +
	" -banscore=<n> " + _("Threshold for disconnecting misbehaving peers (default: 100)") + "\n" +
	" -bantime=<n> " + _("Number of seconds to keep misbehaving peers from reconnecting (default: 86400)") + "\n" +
	" -maxreceivebuffer=<n> " + _("Maximum per-connection receive buffer, <n>*1000 bytes (default: 10000)") + "\n" +
	" -maxsendbuffer=<n> " + _("Maximum per-connection send buffer, <n>*1000 bytes (default: 10000)") + "\n" +
	#ifdef USE_UPNP
	#if USE_UPNP
	" -upnp " + _("Use Universal Plug and Play to map the listening port (default: 1)") + "\n" +
	#else
	" -upnp " + _("Use Universal Plug and Play to map the listening port (default: 0)") + "\n" +
	#endif
	#endif
	" -detachdb " + _("Detach block and address databases. Increases shutdown time (default: 0)") + "\n" +
	" -paytxfee=<amt> " + _("Fee per KB to add to transactions you send") + "\n" +
	#ifdef QT_GUI
	" -server " + _("Accept command line and JSON-RPC commands") + "\n" +
	#endif
	#if !defined(WIN32) && !defined(QT_GUI)
	" -daemon " + _("Run in the background as a daemon and accept commands") + "\n" +
	#endif
	" -testnet " + _("Use the test network") + "\n" +
	" -debug " + _("Output extra debugging information") + "\n" +
	" -logtimestamps " + _("Prepend debug output with timestamp") + "\n" +
	" -printtoconsole " + _("Send trace/debug info to console instead of debug.log file") + "\n" +
	#ifdef WIN32
	" -printtodebugger " + _("Send trace/debug info to debugger") + "\n" +
	#endif
	" -rpcuser=<user> " + _("Username for JSON-RPC connections") + "\n" +
	" -rpcpassword=<pw> " + _("Password for JSON-RPC connections") + "\n" +
	" -rpcport=<port> " + _("Listen for JSON-RPC connections on <port> (default: 8332)") + "\n" +
	" -rpcallowip=<ip> " + _("Allow JSON-RPC connections from specified IP address") + "\n" +
	" -rpcconnect=<ip> " + _("Send commands to node running on <ip> (default: 127.0.0.1)") + "\n" +
	" -blocknotify=<cmd> " + _("Execute command when the best block changes (%s in cmd is replaced by block hash)") + "\n" +
	" -upgradewallet " + _("Upgrade wallet to latest format") + "\n" +
	" -keypool=<n> " + _("Set key pool size to <n> (default: 100)") + "\n" +
	" -rescan " + _("Rescan the block chain for missing wallet transactions") + "\n" +
	" -checkblocks=<n> " + _("How many blocks to check at startup (default: 2500, 0 = all)") + "\n" +
	" -checklevel=<n> " + _("How thorough the block verification is (0-6, default: 1)") + "\n" +
	" -loadblock=<file> " + _("Imports blocks from external blk000?.dat file") + "\n" +
	" -? " + _("This help message") + "\n";

	strUsage += string() +
	_("\nSSL options: (see the Bitcoin Wiki for SSL setup instructions)") + "\n" +
	" -rpcssl " + _("Use OpenSSL (https) for JSON-RPC connections") + "\n" +
	" -rpcsslcertificatechainfile=<file.cert> " + _("Server certificate file (default: server.cert)") + "\n" +
	" -rpcsslprivatekeyfile=<file.pem> " + _("Server private key (default: server.pem)") + "\n" +
	" -rpcsslciphers=<ciphers> " + _("Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH)") + "\n";

	return strUsage;
	}

	/** Initialize bitcoin.
	* @pre Parameters should be parsed and config file should be read.
	*/
	bool AppInit2()
	{
	+ // ********************************************************* Step 1: setup
	#ifdef _MSC_VER
	// Turn off microsoft heap dump noise
	_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
	_CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0));
	#endif
	#if _MSC_VER >= 1400
	// Disable confusing "helpful" text message on abort, ctrl-c
	_set_abort_behavior(0, _WRITE_ABORT_MSG \| _CALL_REPORTFAULT);
	#endif
	#ifndef WIN32
	umask(077);
	#endif
	#ifndef WIN32
	// Clean shutdown on SIGTERM
	struct sigaction sa;
	sa.sa_handler = HandleSIGTERM;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;
	sigaction(SIGTERM, &sa, NULL);
	sigaction(SIGINT, &sa, NULL);
	sigaction(SIGHUP, &sa, NULL);
	#endif

	+ // ********************************************************* Step 2: parameter interactions
	+
	fTestNet = GetBoolArg("-testnet");
	if (fTestNet)
	{
	SoftSetBoolArg("-irc", true);
	}

	+ if (mapArgs.count("-connect"))
	+ SoftSetBoolArg("-dnsseed", false);
	+
	+ // even in Tor mode, if -bind is specified, you really want -listen
	+ if (mapArgs.count("-bind"))
	+ SoftSetBoolArg("-listen", true);
	+
	+ bool fTor = (fUseProxy && addrProxy.GetPort() == 9050);
	+ if (fTor)
	+ {
	+ // Use SoftSetBoolArg here so user can override any of these if they wish.
	+ // Note: the GetBoolArg() calls for all of these must happen later.
	+ SoftSetBoolArg("-listen", false);
	+ SoftSetBoolArg("-irc", false);
	+ SoftSetBoolArg("-proxydns", true);
	+ SoftSetBoolArg("-upnp", false);
	+ SoftSetBoolArg("-discover", false);
	+ }
	+
	+ // ********************************************************* Step 3: parameter-to-internal-flags
	+
	fDebug = GetBoolArg("-debug");
	fDetachDB = GetBoolArg("-detachdb", false);

	#if !defined(WIN32) && !defined(QT_GUI)
	fDaemon = GetBoolArg("-daemon");
	#else
	fDaemon = false;
	#endif

	if (fDaemon)
	fServer = true;
	else
	fServer = GetBoolArg("-server");

	/* force fServer when running without GUI */
	#if !defined(QT_GUI)
	fServer = true;
	#endif
	fPrintToConsole = GetBoolArg("-printtoconsole");
	fPrintToDebugger = GetBoolArg("-printtodebugger");
	fLogTimestamps = GetBoolArg("-logtimestamps");

	+ if (mapArgs.count("-timeout"))
	+ {
	+ int nNewTimeout = GetArg("-timeout", 5000);
	+ if (nNewTimeout > 0 && nNewTimeout < 600000)
	+ nConnectTimeout = nNewTimeout;
	+ }
	+
	+ // Continue to put "/P2SH/" in the coinbase to monitor
	+ // BIP16 support.
	+ // This can be removed eventually...
	+ const char* pszP2SH = "/P2SH/";
	+ COINBASE_FLAGS << std::vector<unsigned char>(pszP2SH, pszP2SH+strlen(pszP2SH));
	+
	+
	+ if (mapArgs.count("-paytxfee"))
	+ {
	+ if (!ParseMoney(mapArgs["-paytxfee"], nTransactionFee))
	+ return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s'"), mapArgs["-paytxfee"].c_str()));
	+ if (nTransactionFee > 0.25 * COIN)
	+ InitWarning(_("Warning: -paytxfee is set very high. This is the transaction fee you will pay if you send a transaction."));
	+ }
	+
	+ // ********************************************************* Step 4: application initialization: dir lock, daemonize, pidfile, debug log
	+
	+ // Make sure only a single Bitcoin process is using the data directory.
	+ boost::filesystem::path pathLockFile = GetDataDir() / ".lock";
	+ FILE* file = fopen(pathLockFile.string().c_str(), "a"); // empty lock file; created if it doesn't exist.
	+ if (file) fclose(file);
	+ static boost::interprocess::file_lock lock(pathLockFile.string().c_str());
	+ if (!lock.try_lock())
	+ return InitError(strprintf(_("Cannot obtain a lock on data directory %s. Bitcoin is probably already running."), GetDataDir().string().c_str()));
	+
	#if !defined(WIN32) && !defined(QT_GUI)
	if (fDaemon)
	{
	// Daemonize
	pid_t pid = fork();
	if (pid < 0)
	{
	fprintf(stderr, "Error: fork() returned %d errno %d\n", pid, errno);
	return false;
	}
	if (pid > 0)
	{
	CreatePidFile(GetPidFile(), pid);
	return true;
	}

	pid_t sid = setsid();
	if (sid < 0)
	fprintf(stderr, "Error: setsid() returned %d errno %d\n", sid, errno);
	}
	#endif

	if (!fDebug)
	ShrinkDebugFile();
	printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
	printf("Bitcoin version %s (%s)\n", FormatFullVersion().c_str(), CLIENT_DATE.c_str());
	printf("Default data directory %s\n", GetDefaultDataDir().string().c_str());
	+ std::ostringstream strErrors;

	- if (GetBoolArg("-loadblockindextest"))
	+ if (fDaemon)
	+ fprintf(stdout, "Bitcoin server starting\n");
	+
	+ int64 nStart;
	+
	+ // ********************************************************* Step 5: network initialization
	+
	+ if (mapArgs.count("-proxy"))
	{
	- CTxDB txdb("r");
	- txdb.LoadBlockIndex();
	- PrintBlockTree();
	- return false;
	+ fUseProxy = true;
	+ addrProxy = CService(mapArgs["-proxy"], 9050);
	+ if (!addrProxy.IsValid())
	+ return InitError(strprintf(_("Invalid -proxy address: '%s'"), mapArgs["-proxy"].c_str()));
	}

	- // Make sure only a single Bitcoin process is using the data directory.
	- boost::filesystem::path pathLockFile = GetDataDir() / ".lock";
	- FILE* file = fopen(pathLockFile.string().c_str(), "a"); // empty lock file; created if it doesn't exist.
	- if (file) fclose(file);
	- static boost::interprocess::file_lock lock(pathLockFile.string().c_str());
	- if (!lock.try_lock())
	- return InitError(strprintf(_("Cannot obtain a lock on data directory %s. Bitcoin is probably already running."), GetDataDir().string().c_str()));
	+ if (mapArgs.count("-noproxy"))
	+ {
	+ BOOST_FOREACH(std::string snet, mapMultiArgs["-noproxy"]) {
	+ enum Network net = ParseNetwork(snet);
	+ if (net == NET_UNROUTABLE)
	+ return InitError(strprintf(_("Unknown network specified in -noproxy: '%s'"), snet.c_str()));
	+ SetNoProxy(net);
	+ }
	+ }

	- std::ostringstream strErrors;
	- //
	- // Load data files
	- //
	- if (fDaemon)
	- fprintf(stdout, "Bitcoin server starting\n");
	- int64 nStart;
	+ fNameLookup = GetBoolArg("-dns");
	+ fProxyNameLookup = GetBoolArg("-proxydns");
	+ if (fProxyNameLookup)
	+ fNameLookup = true;
	+ fNoListen = !GetBoolArg("-listen", true);
	+ nSocksVersion = GetArg("-socks", 5);
	+ if (nSocksVersion != 4 && nSocksVersion != 5)
	+ return InitError(strprintf(_("Unknown -socks proxy version requested: %i"), nSocksVersion));

	- uiInterface.InitMessage(_("Loading addresses..."));
	- printf("Loading addresses...\n");
	- nStart = GetTimeMillis();
	+ if (mapArgs.count("-onlynet")) {
	+ std::set<enum Network> nets;
	+ BOOST_FOREACH(std::string snet, mapMultiArgs["-onlynet"]) {
	+ enum Network net = ParseNetwork(snet);
	+ if (net == NET_UNROUTABLE)
	+ return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet.c_str()));
	+ nets.insert(net);
	+ }
	+ for (int n = 0; n < NET_MAX; n++) {
	+ enum Network net = (enum Network)n;
	+ if (!nets.count(net))
	+ SetLimited(net);
	+ }
	+ }
	+
	+ BOOST_FOREACH(string strDest, mapMultiArgs["-seednode"])
	+ AddOneShot(strDest);

	+ bool fBound = false;
	+ if (!fNoListen)
	{
	- CAddrDB adb;
	- if (!adb.Read(addrman))
	- printf("Invalid or missing peers.dat; recreating\n");
	+ std::string strError;
	+ if (mapArgs.count("-bind")) {
	+ BOOST_FOREACH(std::string strBind, mapMultiArgs["-bind"]) {
	+ CService addrBind;
	+ if (!Lookup(strBind.c_str(), addrBind, GetListenPort(), false))
	+ return InitError(strprintf(_("Cannot resolve -bind address: '%s'"), strBind.c_str()));
	+ fBound \|= Bind(addrBind);
	+ }
	+ } else {
	+ struct in_addr inaddr_any;
	+ inaddr_any.s_addr = INADDR_ANY;
	+ if (!IsLimited(NET_IPV4))
	+ fBound \|= Bind(CService(inaddr_any, GetListenPort()));
	+#ifdef USE_IPV6
	+ if (!IsLimited(NET_IPV6))
	+ fBound \|= Bind(CService(in6addr_any, GetListenPort()));
	+#endif
	+ }
	+ if (!fBound)
	+ return InitError(_("Not listening on any port"));
	}

	- printf("Loaded %i addresses from peers.dat %"PRI64d"ms\n",
	- addrman.size(), GetTimeMillis() - nStart);
	+ if (mapArgs.count("-externalip"))
	+ {
	+ BOOST_FOREACH(string strAddr, mapMultiArgs["-externalip"]) {
	+ CService addrLocal(strAddr, GetListenPort(), fNameLookup);
	+ if (!addrLocal.IsValid())
	+ return InitError(strprintf(_("Cannot resolve -externalip address: '%s'"), strAddr.c_str()));
	+ AddLocal(CService(strAddr, GetListenPort(), fNameLookup), LOCAL_MANUAL);
	+ }
	+ }
	+
	+ // ********************************************************* Step 6: load blockchain
	+
	+ if (GetBoolArg("-loadblockindextest"))
	+ {
	+ CTxDB txdb("r");
	+ txdb.LoadBlockIndex();
	+ PrintBlockTree();
	+ return false;
	+ }

	uiInterface.InitMessage(_("Loading block index..."));
	printf("Loading block index...\n");
	nStart = GetTimeMillis();
	if (!LoadBlockIndex())
	strErrors << _("Error loading blkindex.dat") << "\n";

	// as LoadBlockIndex can take several minutes, it's possible the user
	// requested to kill bitcoin-qt during the last operation. If so, exit.
	// As the program has not fully started yet, Shutdown() is possibly overkill.
	if (fRequestShutdown)
	{
	printf("Shutdown requested. Exiting.\n");
	return false;
	}
	printf(" block index %15"PRI64d"ms\n", GetTimeMillis() - nStart);

	- if (mapArgs.count("-loadblock"))
	+ if (GetBoolArg("-printblockindex") \|\| GetBoolArg("-printblocktree"))
	{
	- BOOST_FOREACH(string strFile, mapMultiArgs["-loadblock"])
	+ PrintBlockTree();
	+ return false;
	+ }
	+
	+ if (mapArgs.count("-printblock"))
	+ {
	+ string strMatch = mapArgs["-printblock"];
	+ int nFound = 0;
	+ for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
	{
	- FILE *file = fopen(strFile.c_str(), "rb");
	- if (file)
	- LoadExternalBlockFile(file);
	+ uint256 hash = (*mi).first;
	+ if (strncmp(hash.ToString().c_str(), strMatch.c_str(), strMatch.size()) == 0)
	+ {
	+ CBlockIndex* pindex = (*mi).second;
	+ CBlock block;
	+ block.ReadFromDisk(pindex);
	+ block.BuildMerkleTree();
	+ block.print();
	+ printf("\n");
	+ nFound++;
	+ }
	}
	+ if (nFound == 0)
	+ printf("No blocks matching %s were found\n", strMatch.c_str());
	+ return false;
	}

	+ // ********************************************************* Step 7: load wallet
	+
	uiInterface.InitMessage(_("Loading wallet..."));
	printf("Loading wallet...\n");
	nStart = GetTimeMillis();
	bool fFirstRun;
	pwalletMain = new CWallet("wallet.dat");
	int nLoadWalletRet = pwalletMain->LoadWallet(fFirstRun);
	if (nLoadWalletRet != DB_LOAD_OK)
	{
	if (nLoadWalletRet == DB_CORRUPT)
	strErrors << _("Error loading wallet.dat: Wallet corrupted") << "\n";
	else if (nLoadWalletRet == DB_TOO_NEW)
	strErrors << _("Error loading wallet.dat: Wallet requires newer version of Bitcoin") << "\n";
	else if (nLoadWalletRet == DB_NEED_REWRITE)
	{
	strErrors << _("Wallet needed to be rewritten: restart Bitcoin to complete") << "\n";
	printf("%s", strErrors.str().c_str());
	return InitError(strErrors.str());
	}
	else
	strErrors << _("Error loading wallet.dat") << "\n";
	}

	if (GetBoolArg("-upgradewallet", fFirstRun))
	{
	int nMaxVersion = GetArg("-upgradewallet", 0);
	if (nMaxVersion == 0) // the -walletupgrade without argument case
	{
	printf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
	nMaxVersion = CLIENT_VERSION;
	pwalletMain->SetMinVersion(FEATURE_LATEST); // permanently upgrade the wallet immediately
	}
	else
	printf("Allowing wallet upgrade up to %i\n", nMaxVersion);
	if (nMaxVersion < pwalletMain->GetVersion())
	strErrors << _("Cannot downgrade wallet") << "\n";
	pwalletMain->SetMaxVersion(nMaxVersion);
	}

	if (fFirstRun)
	{
	// Create new keyUser and set as default key
	RandAddSeedPerfmon();

	std::vector<unsigned char> newDefaultKey;
	if (!pwalletMain->GetKeyFromPool(newDefaultKey, false))
	strErrors << _("Cannot initialize keypool") << "\n";
	pwalletMain->SetDefaultKey(newDefaultKey);
	if (!pwalletMain->SetAddressBookName(CBitcoinAddress(pwalletMain->vchDefaultKey), ""))
	strErrors << _("Cannot write default address") << "\n";
	}

	printf("%s", strErrors.str().c_str());
	printf(" wallet %15"PRI64d"ms\n", GetTimeMillis() - nStart);

	RegisterWallet(pwalletMain);

	CBlockIndex *pindexRescan = pindexBest;
	if (GetBoolArg("-rescan"))
	pindexRescan = pindexGenesisBlock;
	else
	{
	CWalletDB walletdb("wallet.dat");
	CBlockLocator locator;
	if (walletdb.ReadBestBlock(locator))
	pindexRescan = locator.GetBlockIndex();
	}
	if (pindexBest != pindexRescan)
	{
	uiInterface.InitMessage(_("Rescanning..."));
	printf("Rescanning last %i blocks (from block %i)...\n", pindexBest->nHeight - pindexRescan->nHeight, pindexRescan->nHeight);
	nStart = GetTimeMillis();
	pwalletMain->ScanForWalletTransactions(pindexRescan, true);
	printf(" rescan %15"PRI64d"ms\n", GetTimeMillis() - nStart);
	}

	- uiInterface.InitMessage(_("Done loading"));
	- printf("Done loading\n");
	-
	- //// debug print
	- printf("mapBlockIndex.size() = %d\n", mapBlockIndex.size());
	- printf("nBestHeight = %d\n", nBestHeight);
	- printf("setKeyPool.size() = %d\n", pwalletMain->setKeyPool.size());
	- printf("mapWallet.size() = %d\n", pwalletMain->mapWallet.size());
	- printf("mapAddressBook.size() = %d\n", pwalletMain->mapAddressBook.size());
	-
	- if (!strErrors.str().empty())
	- return InitError(strErrors.str());
	-
	- // Add wallet transactions that aren't already in a block to mapTransactions
	- pwalletMain->ReacceptWalletTransactions();
	-
	- // Note: Bitcoin-Qt stores several settings in the wallet, so we want
	- // to load the wallet BEFORE parsing command-line arguments, so
	- // the command-line/bitcoin.conf settings override GUI setting.
	+ // ********************************************************* Step 8: import blocks

	- //
	- // Parameters
	- //
	- if (GetBoolArg("-printblockindex") \|\| GetBoolArg("-printblocktree"))
	- {
	- PrintBlockTree();
	- return false;
	- }
	-
	- if (mapArgs.count("-timeout"))
	- {
	- int nNewTimeout = GetArg("-timeout", 5000);
	- if (nNewTimeout > 0 && nNewTimeout < 600000)
	- nConnectTimeout = nNewTimeout;
	- }
	-
	- if (mapArgs.count("-printblock"))
	+ if (mapArgs.count("-loadblock"))
	{
	- string strMatch = mapArgs["-printblock"];
	- int nFound = 0;
	- for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
	+ BOOST_FOREACH(string strFile, mapMultiArgs["-loadblock"])
	{
	- uint256 hash = (*mi).first;
	- if (strncmp(hash.ToString().c_str(), strMatch.c_str(), strMatch.size()) == 0)
	- {
	- CBlockIndex* pindex = (*mi).second;
	- CBlock block;
	- block.ReadFromDisk(pindex);
	- block.BuildMerkleTree();
	- block.print();
	- printf("\n");
	- nFound++;
	- }
	- }
	- if (nFound == 0)
	- printf("No blocks matching %s were found\n", strMatch.c_str());
	- return false;
	- }
	-
	- if (mapArgs.count("-proxy"))
	- {
	- fUseProxy = true;
	- addrProxy = CService(mapArgs["-proxy"], 9050);
	- if (!addrProxy.IsValid())
	- return InitError(strprintf(_("Invalid -proxy address: '%s'"), mapArgs["-proxy"].c_str()));
	- }
	-
	- if (mapArgs.count("-noproxy"))
	- {
	- BOOST_FOREACH(std::string snet, mapMultiArgs["-noproxy"]) {
	- enum Network net = ParseNetwork(snet);
	- if (net == NET_UNROUTABLE)
	- return InitError(strprintf(_("Unknown network specified in -noproxy: '%s'"), snet.c_str()));
	- SetNoProxy(net);
	- }
	- }
	-
	- if (mapArgs.count("-connect"))
	- SoftSetBoolArg("-dnsseed", false);
	-
	- // even in Tor mode, if -bind is specified, you really want -listen
	- if (mapArgs.count("-bind"))
	- SoftSetBoolArg("-listen", true);
	-
	- bool fTor = (fUseProxy && addrProxy.GetPort() == 9050);
	- if (fTor)
	- {
	- // Use SoftSetBoolArg here so user can override any of these if they wish.
	- // Note: the GetBoolArg() calls for all of these must happen later.
	- SoftSetBoolArg("-listen", false);
	- SoftSetBoolArg("-irc", false);
	- SoftSetBoolArg("-proxydns", true);
	- SoftSetBoolArg("-upnp", false);
	- SoftSetBoolArg("-discover", false);
	- }
	-
	- if (mapArgs.count("-onlynet")) {
	- std::set<enum Network> nets;
	- BOOST_FOREACH(std::string snet, mapMultiArgs["-onlynet"]) {
	- enum Network net = ParseNetwork(snet);
	- if (net == NET_UNROUTABLE)
	- return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet.c_str()));
	- nets.insert(net);
	- }
	- for (int n = 0; n < NET_MAX; n++) {
	- enum Network net = (enum Network)n;
	- if (!nets.count(net))
	- SetLimited(net);
	+ FILE *file = fopen(strFile.c_str(), "rb");
	+ if (file)
	+ LoadExternalBlockFile(file);
	}
	}

	- fNameLookup = GetBoolArg("-dns");
	- fProxyNameLookup = GetBoolArg("-proxydns");
	- if (fProxyNameLookup)
	- fNameLookup = true;
	- fNoListen = !GetBoolArg("-listen", true);
	- nSocksVersion = GetArg("-socks", 5);
	- if (nSocksVersion != 4 && nSocksVersion != 5)
	- return InitError(strprintf(_("Unknown -socks proxy version requested: %i"), nSocksVersion));
	+ // ********************************************************* Step 9: load peers

	- BOOST_FOREACH(string strDest, mapMultiArgs["-seednode"])
	- AddOneShot(strDest);
	-
	- // Continue to put "/P2SH/" in the coinbase to monitor
	- // BIP16 support.
	- // This can be removed eventually...
	- const char* pszP2SH = "/P2SH/";
	- COINBASE_FLAGS << std::vector<unsigned char>(pszP2SH, pszP2SH+strlen(pszP2SH));
	+ uiInterface.InitMessage(_("Loading addresses..."));
	+ printf("Loading addresses...\n");
	+ nStart = GetTimeMillis();

	- bool fBound = false;
	- if (!fNoListen)
	{
	- std::string strError;
	- if (mapArgs.count("-bind")) {
	- BOOST_FOREACH(std::string strBind, mapMultiArgs["-bind"]) {
	- CService addrBind;
	- if (!Lookup(strBind.c_str(), addrBind, GetListenPort(), false))
	- return InitError(strprintf(_("Cannot resolve -bind address: '%s'"), strBind.c_str()));
	- fBound \|= Bind(addrBind);
	- }
	- } else {
	- struct in_addr inaddr_any;
	- inaddr_any.s_addr = INADDR_ANY;
	- if (!IsLimited(NET_IPV4))
	- fBound \|= Bind(CService(inaddr_any, GetListenPort()));
	-#ifdef USE_IPV6
	- if (!IsLimited(NET_IPV6))
	- fBound \|= Bind(CService(in6addr_any, GetListenPort()));
	-#endif
	- }
	- if (!fBound)
	- return InitError(_("Not listening on any port"));
	+ CAddrDB adb;
	+ if (!adb.Read(addrman))
	+ printf("Invalid or missing peers.dat; recreating\n");
	}

	- if (mapArgs.count("-externalip"))
	- {
	- BOOST_FOREACH(string strAddr, mapMultiArgs["-externalip"]) {
	- CService addrLocal(strAddr, GetListenPort(), fNameLookup);
	- if (!addrLocal.IsValid())
	- return InitError(strprintf(_("Cannot resolve -externalip address: '%s'"), strAddr.c_str()));
	- AddLocal(CService(strAddr, GetListenPort(), fNameLookup), LOCAL_MANUAL);
	- }
	- }
	+ printf("Loaded %i addresses from peers.dat %"PRI64d"ms\n",
	+ addrman.size(), GetTimeMillis() - nStart);

	- if (mapArgs.count("-paytxfee"))
	- {
	- if (!ParseMoney(mapArgs["-paytxfee"], nTransactionFee))
	- return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s'"), mapArgs["-paytxfee"].c_str()));
	- if (nTransactionFee > 0.25 * COIN)
	- InitWarning(_("Warning: -paytxfee is set very high. This is the transaction fee you will pay if you send a transaction."));
	- }
	+ // ********************************************************* Step 10: start node

	- //
	- // Start the node
	- //
	if (!CheckDiskSpace())
	return false;

	RandAddSeedPerfmon();

	+ //// debug print
	+ printf("mapBlockIndex.size() = %d\n", mapBlockIndex.size());
	+ printf("nBestHeight = %d\n", nBestHeight);
	+ printf("setKeyPool.size() = %d\n", pwalletMain->setKeyPool.size());
	+ printf("mapWallet.size() = %d\n", pwalletMain->mapWallet.size());
	+ printf("mapAddressBook.size() = %d\n", pwalletMain->mapAddressBook.size());
	+
	if (!CreateThread(StartNode, NULL))
	InitError(_("Error: could not start node"));

	if (fServer)
	CreateThread(ThreadRPCServer, NULL);

	+ // ********************************************************* Step 11: finished
	+
	+ uiInterface.InitMessage(_("Done loading"));
	+ printf("Done loading\n");
	+
	+ if (!strErrors.str().empty())
	+ return InitError(strErrors.str());
	+
	+ // Add wallet transactions that aren't already in a block to mapTransactions
	+ pwalletMain->ReacceptWalletTransactions();
	+
	#if !defined(QT_GUI)
	// Loop until process is exit()ed from shutdown() function,
	// called from ThreadRPCServer thread when a "stop" command is received.
	while (1)
	Sleep(5000);
	#endif

	return true;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jan 29, 16:59 (11 h, 12 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5053350
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions