mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-02-09 10:43:19 -05:00
0e4b317555
The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
992 lines
40 KiB
C++
992 lines
40 KiB
C++
// 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 "init.h"
|
|
#include "main.h"
|
|
#include "core.h"
|
|
#include "chainparams.h"
|
|
#include "txdb.h"
|
|
#include "walletdb.h"
|
|
#include "bitcoinrpc.h"
|
|
#include "net.h"
|
|
#include "util.h"
|
|
#include "ui_interface.h"
|
|
#include "checkpoints.h"
|
|
#include "chainparams.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>
|
|
#include <openssl/crypto.h>
|
|
|
|
#ifndef WIN32
|
|
#include <signal.h>
|
|
#endif
|
|
|
|
using namespace std;
|
|
using namespace boost;
|
|
|
|
CWallet* pwalletMain;
|
|
CClientUIInterface uiInterface;
|
|
|
|
#ifdef WIN32
|
|
// Win32 LevelDB doesn't use filedescriptors, and the ones used for
|
|
// accessing block files, don't count towards to fd_set size limit
|
|
// anyway.
|
|
#define MIN_CORE_FILEDESCRIPTORS 0
|
|
#else
|
|
#define MIN_CORE_FILEDESCRIPTORS 150
|
|
#endif
|
|
|
|
// Used to pass flags to the Bind() function
|
|
enum BindFlags {
|
|
BF_NONE = 0,
|
|
BF_EXPLICIT = (1U << 0),
|
|
BF_REPORT_ERROR = (1U << 1)
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Shutdown
|
|
//
|
|
|
|
//
|
|
// Thread management and startup/shutdown:
|
|
//
|
|
// The network-processing threads are all part of a thread group
|
|
// created by AppInit() or the Qt main() function.
|
|
//
|
|
// A clean exit happens when StartShutdown() or the SIGTERM
|
|
// signal handler sets fRequestShutdown, which triggers
|
|
// the DetectShutdownThread(), which interrupts the main thread group.
|
|
// DetectShutdownThread() then exits, which causes AppInit() to
|
|
// continue (it .joins the shutdown thread).
|
|
// Shutdown() is then
|
|
// called to clean up database connections, and stop other
|
|
// threads that should only be stopped after the main network-processing
|
|
// threads have exited.
|
|
//
|
|
// Note that if running -daemon the parent process returns from AppInit2
|
|
// before adding any threads to the threadGroup, so .join_all() returns
|
|
// immediately and the parent exits from main().
|
|
//
|
|
// Shutdown for Qt is very similar, only it uses a QTimer to detect
|
|
// fRequestShutdown getting set, and then does the normal Qt
|
|
// shutdown thing.
|
|
//
|
|
|
|
volatile bool fRequestShutdown = false;
|
|
|
|
void StartShutdown()
|
|
{
|
|
fRequestShutdown = true;
|
|
}
|
|
bool ShutdownRequested()
|
|
{
|
|
return fRequestShutdown;
|
|
}
|
|
|
|
static CCoinsViewDB *pcoinsdbview;
|
|
|
|
void Shutdown()
|
|
{
|
|
static CCriticalSection cs_Shutdown;
|
|
TRY_LOCK(cs_Shutdown, lockShutdown);
|
|
if (!lockShutdown) return;
|
|
|
|
RenameThread("bitcoin-shutoff");
|
|
nTransactionsUpdated++;
|
|
StopRPCThreads();
|
|
ShutdownRPCMining();
|
|
bitdb.Flush(false);
|
|
GenerateBitcoins(false, NULL);
|
|
StopNode();
|
|
{
|
|
LOCK(cs_main);
|
|
if (pwalletMain)
|
|
pwalletMain->SetBestChain(CBlockLocator(pindexBest));
|
|
if (pblocktree)
|
|
pblocktree->Flush();
|
|
if (pcoinsTip)
|
|
pcoinsTip->Flush();
|
|
delete pcoinsTip; pcoinsTip = NULL;
|
|
delete pcoinsdbview; pcoinsdbview = NULL;
|
|
delete pblocktree; pblocktree = NULL;
|
|
}
|
|
bitdb.Flush(true);
|
|
boost::filesystem::remove(GetPidFile());
|
|
UnregisterWallet(pwalletMain);
|
|
delete pwalletMain;
|
|
}
|
|
|
|
//
|
|
// Signal handlers are very limited in what they are allowed to do, so:
|
|
//
|
|
void HandleSIGTERM(int)
|
|
{
|
|
fRequestShutdown = true;
|
|
}
|
|
|
|
void HandleSIGHUP(int)
|
|
{
|
|
fReopenDebugLog = true;
|
|
}
|
|
|
|
bool static InitError(const std::string &str)
|
|
{
|
|
uiInterface.ThreadSafeMessageBox(str, "", CClientUIInterface::MSG_ERROR);
|
|
return false;
|
|
}
|
|
|
|
bool static InitWarning(const std::string &str)
|
|
{
|
|
uiInterface.ThreadSafeMessageBox(str, "", CClientUIInterface::MSG_WARNING);
|
|
return true;
|
|
}
|
|
|
|
bool static Bind(const CService &addr, unsigned int flags) {
|
|
if (!(flags & BF_EXPLICIT) && IsLimited(addr))
|
|
return false;
|
|
std::string strError;
|
|
if (!BindListenPort(addr, strError)) {
|
|
if (flags & BF_REPORT_ERROR)
|
|
return InitError(strError);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Core-specific options shared between UI and daemon
|
|
std::string HelpMessage()
|
|
{
|
|
string strUsage = _("Options:") + "\n";
|
|
strUsage += " -? " + _("This help message") + "\n";
|
|
strUsage += " -conf=<file> " + _("Specify configuration file (default: bitcoin.conf)") + "\n";
|
|
strUsage += " -pid=<file> " + _("Specify pid file (default: bitcoind.pid)") + "\n";
|
|
strUsage += " -gen " + _("Generate coins (default: 0)") + "\n";
|
|
strUsage += " -datadir=<dir> " + _("Specify data directory") + "\n";
|
|
strUsage += " -dbcache=<n> " + _("Set database cache size in megabytes (default: 25)") + "\n";
|
|
strUsage += " -timeout=<n> " + _("Specify connection timeout in milliseconds (default: 5000)") + "\n";
|
|
strUsage += " -proxy=<ip:port> " + _("Connect through socks proxy") + "\n";
|
|
strUsage += " -socks=<n> " + _("Select the version of socks proxy to use (4-5, default: 5)") + "\n";
|
|
strUsage += " -tor=<ip:port> " + _("Use proxy to reach tor hidden services (default: same as -proxy)") + "\n";
|
|
strUsage += " -dns " + _("Allow DNS lookups for -addnode, -seednode and -connect") + "\n";
|
|
strUsage += " -port=<port> " + _("Listen for connections on <port> (default: 8333 or testnet: 18333)") + "\n";
|
|
strUsage += " -maxconnections=<n> " + _("Maintain at most <n> connections to peers (default: 125)") + "\n";
|
|
strUsage += " -addnode=<ip> " + _("Add a node to connect to and attempt to keep the connection open") + "\n";
|
|
strUsage += " -connect=<ip> " + _("Connect only to the specified node(s)") + "\n";
|
|
strUsage += " -seednode=<ip> " + _("Connect to a node to retrieve peer addresses, and disconnect") + "\n";
|
|
strUsage += " -externalip=<ip> " + _("Specify your own public address") + "\n";
|
|
strUsage += " -onlynet=<net> " + _("Only connect to nodes in network <net> (IPv4, IPv6 or Tor)") + "\n";
|
|
strUsage += " -discover " + _("Discover own IP address (default: 1 when listening and no -externalip)") + "\n";
|
|
strUsage += " -checkpoints " + _("Only accept block chain matching built-in checkpoints (default: 1)") + "\n";
|
|
strUsage += " -listen " + _("Accept connections from outside (default: 1 if no -proxy or -connect)") + "\n";
|
|
strUsage += " -bind=<addr> " + _("Bind to given address and always listen on it. Use [host]:port notation for IPv6") + "\n";
|
|
strUsage += " -dnsseed " + _("Find peers using DNS lookup (default: 1 unless -connect)") + "\n";
|
|
strUsage += " -banscore=<n> " + _("Threshold for disconnecting misbehaving peers (default: 100)") + "\n";
|
|
strUsage += " -bantime=<n> " + _("Number of seconds to keep misbehaving peers from reconnecting (default: 86400)") + "\n";
|
|
strUsage += " -maxreceivebuffer=<n> " + _("Maximum per-connection receive buffer, <n>*1000 bytes (default: 5000)") + "\n";
|
|
strUsage += " -maxsendbuffer=<n> " + _("Maximum per-connection send buffer, <n>*1000 bytes (default: 1000)") + "\n";
|
|
#ifdef USE_UPNP
|
|
#if USE_UPNP
|
|
strUsage += " -upnp " + _("Use UPnP to map the listening port (default: 1 when listening)") + "\n";
|
|
#else
|
|
strUsage += " -upnp " + _("Use UPnP to map the listening port (default: 0)") + "\n";
|
|
#endif
|
|
#endif
|
|
strUsage += " -paytxfee=<amt> " + _("Fee per KB to add to transactions you send") + "\n";
|
|
if (fHaveGUI)
|
|
strUsage += " -server " + _("Accept command line and JSON-RPC commands") + "\n";
|
|
#if !defined(WIN32)
|
|
if (fHaveGUI)
|
|
strUsage += " -daemon " + _("Run in the background as a daemon and accept commands") + "\n";
|
|
#endif
|
|
strUsage += " -testnet " + _("Use the test network") + "\n";
|
|
strUsage += " -debug " + _("Output extra debugging information. Implies all other -debug* options") + "\n";
|
|
strUsage += " -debugnet " + _("Output extra network debugging information") + "\n";
|
|
strUsage += " -logtimestamps " + _("Prepend debug output with timestamp") + "\n";
|
|
strUsage += " -shrinkdebugfile " + _("Shrink debug.log file on client startup (default: 1 when no -debug)") + "\n";
|
|
strUsage += " -printtoconsole " + _("Send trace/debug info to console instead of debug.log file") + "\n";
|
|
strUsage += " -regtest " + _("Enter regression test mode, which uses a special chain in which blocks can be "
|
|
"solved instantly. This is intended for regression testing tools and app development.") + "\n";
|
|
#ifdef WIN32
|
|
strUsage += " -printtodebugger " + _("Send trace/debug info to debugger") + "\n";
|
|
#endif
|
|
strUsage += " -rpcuser=<user> " + _("Username for JSON-RPC connections") + "\n";
|
|
strUsage += " -rpcpassword=<pw> " + _("Password for JSON-RPC connections") + "\n";
|
|
strUsage += " -rpcport=<port> " + _("Listen for JSON-RPC connections on <port> (default: 8332 or testnet: 18332)") + "\n";
|
|
strUsage += " -rpcallowip=<ip> " + _("Allow JSON-RPC connections from specified IP address") + "\n";
|
|
if (!fHaveGUI)
|
|
strUsage += " -rpcconnect=<ip> " + _("Send commands to node running on <ip> (default: 127.0.0.1)") + "\n";
|
|
strUsage += " -rpcthreads=<n> " + _("Set the number of threads to service RPC calls (default: 4)") + "\n";
|
|
strUsage += " -blocknotify=<cmd> " + _("Execute command when the best block changes (%s in cmd is replaced by block hash)") + "\n";
|
|
strUsage += " -walletnotify=<cmd> " + _("Execute command when a wallet transaction changes (%s in cmd is replaced by TxID)") + "\n";
|
|
strUsage += " -alertnotify=<cmd> " + _("Execute command when a relevant alert is received (%s in cmd is replaced by message)") + "\n";
|
|
strUsage += " -upgradewallet " + _("Upgrade wallet to latest format") + "\n";
|
|
strUsage += " -keypool=<n> " + _("Set key pool size to <n> (default: 100)") + "\n";
|
|
strUsage += " -rescan " + _("Rescan the block chain for missing wallet transactions") + "\n";
|
|
strUsage += " -salvagewallet " + _("Attempt to recover private keys from a corrupt wallet.dat") + "\n";
|
|
strUsage += " -checkblocks=<n> " + _("How many blocks to check at startup (default: 288, 0 = all)") + "\n";
|
|
strUsage += " -checklevel=<n> " + _("How thorough the block verification is (0-4, default: 3)") + "\n";
|
|
strUsage += " -txindex " + _("Maintain a full transaction index (default: 0)") + "\n";
|
|
strUsage += " -loadblock=<file> " + _("Imports blocks from external blk000??.dat file") + "\n";
|
|
strUsage += " -reindex " + _("Rebuild block chain index from current blk000??.dat files") + "\n";
|
|
strUsage += " -par=<n> " + _("Set the number of script verification threads (up to 16, 0 = auto, <0 = leave that many cores free, default: 0)") + "\n";
|
|
|
|
strUsage += "\n"; _("Block creation options:") + "\n";
|
|
strUsage += " -blockminsize=<n> " + _("Set minimum block size in bytes (default: 0)") + "\n";
|
|
strUsage += " -blockmaxsize=<n> " + _("Set maximum block size in bytes (default: 250000)") + "\n";
|
|
strUsage += " -blockprioritysize=<n> " + _("Set maximum size of high-priority/low-fee transactions in bytes (default: 27000)") + "\n";
|
|
|
|
strUsage += "\n"; _("SSL options: (see the Bitcoin Wiki for SSL setup instructions)") + "\n";
|
|
strUsage += " -rpcssl " + _("Use OpenSSL (https) for JSON-RPC connections") + "\n";
|
|
strUsage += " -rpcsslcertificatechainfile=<file.cert> " + _("Server certificate file (default: server.cert)") + "\n";
|
|
strUsage += " -rpcsslprivatekeyfile=<file.pem> " + _("Server private key (default: server.pem)") + "\n";
|
|
strUsage += " -rpcsslciphers=<ciphers> " + _("Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH)") + "\n";
|
|
|
|
return strUsage;
|
|
}
|
|
|
|
struct CImportingNow
|
|
{
|
|
CImportingNow() {
|
|
assert(fImporting == false);
|
|
fImporting = true;
|
|
}
|
|
|
|
~CImportingNow() {
|
|
assert(fImporting == true);
|
|
fImporting = false;
|
|
}
|
|
};
|
|
|
|
void ThreadImport(std::vector<boost::filesystem::path> vImportFiles)
|
|
{
|
|
RenameThread("bitcoin-loadblk");
|
|
|
|
// -reindex
|
|
if (fReindex) {
|
|
CImportingNow imp;
|
|
int nFile = 0;
|
|
while (true) {
|
|
CDiskBlockPos pos(nFile, 0);
|
|
FILE *file = OpenBlockFile(pos, true);
|
|
if (!file)
|
|
break;
|
|
printf("Reindexing block file blk%05u.dat...\n", (unsigned int)nFile);
|
|
LoadExternalBlockFile(file, &pos);
|
|
nFile++;
|
|
}
|
|
pblocktree->WriteReindexing(false);
|
|
fReindex = false;
|
|
printf("Reindexing finished\n");
|
|
// To avoid ending up in a situation without genesis block, re-try initializing (no-op if reindexing worked):
|
|
InitBlockIndex();
|
|
}
|
|
|
|
// hardcoded $DATADIR/bootstrap.dat
|
|
filesystem::path pathBootstrap = GetDataDir() / "bootstrap.dat";
|
|
if (filesystem::exists(pathBootstrap)) {
|
|
FILE *file = fopen(pathBootstrap.string().c_str(), "rb");
|
|
if (file) {
|
|
CImportingNow imp;
|
|
filesystem::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
|
|
printf("Importing bootstrap.dat...\n");
|
|
LoadExternalBlockFile(file);
|
|
RenameOver(pathBootstrap, pathBootstrapOld);
|
|
}
|
|
}
|
|
|
|
// -loadblock=
|
|
BOOST_FOREACH(boost::filesystem::path &path, vImportFiles) {
|
|
FILE *file = fopen(path.string().c_str(), "rb");
|
|
if (file) {
|
|
CImportingNow imp;
|
|
printf("Importing %s...\n", path.string().c_str());
|
|
LoadExternalBlockFile(file);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Initialize bitcoin.
|
|
* @pre Parameters should be parsed and config file should be read.
|
|
*/
|
|
bool AppInit2(boost::thread_group& threadGroup)
|
|
{
|
|
// ********************************************************* 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
|
|
#ifdef WIN32
|
|
// Enable Data Execution Prevention (DEP)
|
|
// Minimum supported OS versions: WinXP SP3, WinVista >= SP1, Win Server 2008
|
|
// A failure is non-critical and needs no further attention!
|
|
#ifndef PROCESS_DEP_ENABLE
|
|
// We define this here, because GCCs winbase.h limits this to _WIN32_WINNT >= 0x0601 (Windows 7),
|
|
// which is not correct. Can be removed, when GCCs winbase.h is fixed!
|
|
#define PROCESS_DEP_ENABLE 0x00000001
|
|
#endif
|
|
typedef BOOL (WINAPI *PSETPROCDEPPOL)(DWORD);
|
|
PSETPROCDEPPOL setProcDEPPol = (PSETPROCDEPPOL)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "SetProcessDEPPolicy");
|
|
if (setProcDEPPol != NULL) setProcDEPPol(PROCESS_DEP_ENABLE);
|
|
|
|
// 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 InitError(strprintf("Error: Winsock library failed to start (WSAStartup returned error %d)", ret));
|
|
}
|
|
#endif
|
|
#ifndef WIN32
|
|
umask(077);
|
|
|
|
// 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);
|
|
|
|
// Reopen debug.log on SIGHUP
|
|
struct sigaction sa_hup;
|
|
sa_hup.sa_handler = HandleSIGHUP;
|
|
sigemptyset(&sa_hup.sa_mask);
|
|
sa_hup.sa_flags = 0;
|
|
sigaction(SIGHUP, &sa_hup, NULL);
|
|
#endif
|
|
|
|
// ********************************************************* Step 2: parameter interactions
|
|
|
|
Checkpoints::fEnabled = GetBoolArg("-checkpoints", true);
|
|
if (!SelectParamsFromCommandLine()) {
|
|
return InitError("Invalid combination of -testnet and -regtest.");
|
|
}
|
|
|
|
if (mapArgs.count("-bind")) {
|
|
// when specifying an explicit binding address, you want to listen on it
|
|
// even when -connect or -proxy is specified
|
|
SoftSetBoolArg("-listen", true);
|
|
}
|
|
|
|
if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0) {
|
|
// when only connecting to trusted nodes, do not seed via DNS, or listen by default
|
|
SoftSetBoolArg("-dnsseed", false);
|
|
SoftSetBoolArg("-listen", false);
|
|
}
|
|
|
|
if (mapArgs.count("-proxy")) {
|
|
// to protect privacy, do not listen by default if a proxy server is specified
|
|
SoftSetBoolArg("-listen", false);
|
|
}
|
|
|
|
if (!GetBoolArg("-listen", true)) {
|
|
// do not map ports or try to retrieve public IP when not listening (pointless)
|
|
SoftSetBoolArg("-upnp", false);
|
|
SoftSetBoolArg("-discover", false);
|
|
}
|
|
|
|
if (mapArgs.count("-externalip")) {
|
|
// if an explicit public IP is specified, do not try to find others
|
|
SoftSetBoolArg("-discover", false);
|
|
}
|
|
|
|
if (GetBoolArg("-salvagewallet", false)) {
|
|
// Rewrite just private keys: rescan to find transactions
|
|
SoftSetBoolArg("-rescan", true);
|
|
}
|
|
|
|
// Make sure enough file descriptors are available
|
|
int nBind = std::max((int)mapArgs.count("-bind"), 1);
|
|
nMaxConnections = GetArg("-maxconnections", 125);
|
|
nMaxConnections = std::max(std::min(nMaxConnections, (int)(FD_SETSIZE - nBind - MIN_CORE_FILEDESCRIPTORS)), 0);
|
|
int nFD = RaiseFileDescriptorLimit(nMaxConnections + MIN_CORE_FILEDESCRIPTORS);
|
|
if (nFD < MIN_CORE_FILEDESCRIPTORS)
|
|
return InitError(_("Not enough file descriptors available."));
|
|
if (nFD - MIN_CORE_FILEDESCRIPTORS < nMaxConnections)
|
|
nMaxConnections = nFD - MIN_CORE_FILEDESCRIPTORS;
|
|
|
|
// ********************************************************* Step 3: parameter-to-internal-flags
|
|
|
|
fDebug = GetBoolArg("-debug", false);
|
|
fBenchmark = GetBoolArg("-benchmark", false);
|
|
|
|
// -par=0 means autodetect, but nScriptCheckThreads==0 means no concurrency
|
|
nScriptCheckThreads = GetArg("-par", 0);
|
|
if (nScriptCheckThreads <= 0)
|
|
nScriptCheckThreads += boost::thread::hardware_concurrency();
|
|
if (nScriptCheckThreads <= 1)
|
|
nScriptCheckThreads = 0;
|
|
else if (nScriptCheckThreads > MAX_SCRIPTCHECK_THREADS)
|
|
nScriptCheckThreads = MAX_SCRIPTCHECK_THREADS;
|
|
|
|
// -debug implies fDebug*
|
|
if (fDebug)
|
|
fDebugNet = true;
|
|
else
|
|
fDebugNet = GetBoolArg("-debugnet", false);
|
|
|
|
if (fDaemon)
|
|
fServer = true;
|
|
else
|
|
fServer = GetBoolArg("-server", false);
|
|
|
|
/* force fServer when running without GUI */
|
|
if (!fHaveGUI)
|
|
fServer = true;
|
|
fPrintToConsole = GetBoolArg("-printtoconsole", false);
|
|
fPrintToDebugger = GetBoolArg("-printtodebugger", false);
|
|
fLogTimestamps = GetBoolArg("-logtimestamps", false);
|
|
|
|
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));
|
|
|
|
// Fee-per-kilobyte amount considered the same as "free"
|
|
// If you are mining, be careful setting this:
|
|
// if you set it to zero then
|
|
// a transaction spammer can cheaply fill blocks using
|
|
// 1-satoshi-fee transactions. It should be set above the real
|
|
// cost to you of processing a transaction.
|
|
if (mapArgs.count("-mintxfee"))
|
|
{
|
|
int64 n = 0;
|
|
if (ParseMoney(mapArgs["-mintxfee"], n) && n > 0)
|
|
CTransaction::nMinTxFee = n;
|
|
else
|
|
return InitError(strprintf(_("Invalid amount for -mintxfee=<amount>: '%s'"), mapArgs["-mintxfee"].c_str()));
|
|
}
|
|
if (mapArgs.count("-minrelaytxfee"))
|
|
{
|
|
int64 n = 0;
|
|
if (ParseMoney(mapArgs["-minrelaytxfee"], n) && n > 0)
|
|
CTransaction::nMinRelayTxFee = n;
|
|
else
|
|
return InitError(strprintf(_("Invalid amount for -minrelaytxfee=<amount>: '%s'"), mapArgs["-minrelaytxfee"].c_str()));
|
|
}
|
|
|
|
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
|
|
|
|
std::string strDataDir = GetDataDir().string();
|
|
|
|
// 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."), strDataDir.c_str()));
|
|
|
|
if (GetBoolArg("-shrinkdebugfile", !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("Using OpenSSL version %s\n", SSLeay_version(SSLEAY_VERSION));
|
|
if (!fLogTimestamps)
|
|
printf("Startup time: %s\n", DateTimeStrFormat("%Y-%m-%d %H:%M:%S", GetTime()).c_str());
|
|
printf("Default data directory %s\n", GetDefaultDataDir().string().c_str());
|
|
printf("Using data directory %s\n", strDataDir.c_str());
|
|
printf("Using at most %i connections (%i file descriptors available)\n", nMaxConnections, nFD);
|
|
std::ostringstream strErrors;
|
|
|
|
if (fDaemon)
|
|
fprintf(stdout, "Bitcoin server starting\n");
|
|
|
|
if (nScriptCheckThreads) {
|
|
printf("Using %u threads for script verification\n", nScriptCheckThreads);
|
|
for (int i=0; i<nScriptCheckThreads-1; i++)
|
|
threadGroup.create_thread(&ThreadScriptCheck);
|
|
}
|
|
|
|
int64 nStart;
|
|
|
|
// ********************************************************* Step 5: verify wallet database integrity
|
|
|
|
uiInterface.InitMessage(_("Verifying wallet..."));
|
|
|
|
if (!bitdb.Open(GetDataDir()))
|
|
{
|
|
// try moving the database env out of the way
|
|
boost::filesystem::path pathDatabase = GetDataDir() / "database";
|
|
boost::filesystem::path pathDatabaseBak = GetDataDir() / strprintf("database.%"PRI64d".bak", GetTime());
|
|
try {
|
|
boost::filesystem::rename(pathDatabase, pathDatabaseBak);
|
|
printf("Moved old %s to %s. Retrying.\n", pathDatabase.string().c_str(), pathDatabaseBak.string().c_str());
|
|
} catch(boost::filesystem::filesystem_error &error) {
|
|
// failure is ok (well, not really, but it's not worse than what we started with)
|
|
}
|
|
|
|
// try again
|
|
if (!bitdb.Open(GetDataDir())) {
|
|
// if it still fails, it probably means we can't even create the database env
|
|
string msg = strprintf(_("Error initializing wallet database environment %s!"), strDataDir.c_str());
|
|
return InitError(msg);
|
|
}
|
|
}
|
|
|
|
if (GetBoolArg("-salvagewallet", false))
|
|
{
|
|
// Recover readable keypairs:
|
|
if (!CWalletDB::Recover(bitdb, "wallet.dat", true))
|
|
return false;
|
|
}
|
|
|
|
if (filesystem::exists(GetDataDir() / "wallet.dat"))
|
|
{
|
|
CDBEnv::VerifyResult r = bitdb.Verify("wallet.dat", CWalletDB::Recover);
|
|
if (r == CDBEnv::RECOVER_OK)
|
|
{
|
|
string msg = strprintf(_("Warning: wallet.dat corrupt, data salvaged!"
|
|
" Original wallet.dat saved as wallet.{timestamp}.bak in %s; if"
|
|
" your balance or transactions are incorrect you should"
|
|
" restore from a backup."), strDataDir.c_str());
|
|
InitWarning(msg);
|
|
}
|
|
if (r == CDBEnv::RECOVER_FAIL)
|
|
return InitError(_("wallet.dat corrupt, salvage failed"));
|
|
}
|
|
|
|
// ********************************************************* Step 6: network initialization
|
|
|
|
RegisterNodeSignals(GetNodeSignals());
|
|
|
|
int nSocksVersion = GetArg("-socks", 5);
|
|
if (nSocksVersion != 4 && nSocksVersion != 5)
|
|
return InitError(strprintf(_("Unknown -socks proxy version requested: %i"), nSocksVersion));
|
|
|
|
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);
|
|
}
|
|
}
|
|
#if defined(USE_IPV6)
|
|
#if ! USE_IPV6
|
|
else
|
|
SetLimited(NET_IPV6);
|
|
#endif
|
|
#endif
|
|
|
|
CService addrProxy;
|
|
bool fProxy = false;
|
|
if (mapArgs.count("-proxy")) {
|
|
addrProxy = CService(mapArgs["-proxy"], 9050);
|
|
if (!addrProxy.IsValid())
|
|
return InitError(strprintf(_("Invalid -proxy address: '%s'"), mapArgs["-proxy"].c_str()));
|
|
|
|
if (!IsLimited(NET_IPV4))
|
|
SetProxy(NET_IPV4, addrProxy, nSocksVersion);
|
|
if (nSocksVersion > 4) {
|
|
#ifdef USE_IPV6
|
|
if (!IsLimited(NET_IPV6))
|
|
SetProxy(NET_IPV6, addrProxy, nSocksVersion);
|
|
#endif
|
|
SetNameProxy(addrProxy, nSocksVersion);
|
|
}
|
|
fProxy = true;
|
|
}
|
|
|
|
// -tor can override normal proxy, -notor disables tor entirely
|
|
if (!(mapArgs.count("-tor") && mapArgs["-tor"] == "0") && (fProxy || mapArgs.count("-tor"))) {
|
|
CService addrOnion;
|
|
if (!mapArgs.count("-tor"))
|
|
addrOnion = addrProxy;
|
|
else
|
|
addrOnion = CService(mapArgs["-tor"], 9050);
|
|
if (!addrOnion.IsValid())
|
|
return InitError(strprintf(_("Invalid -tor address: '%s'"), mapArgs["-tor"].c_str()));
|
|
SetProxy(NET_TOR, addrOnion, 5);
|
|
SetReachable(NET_TOR);
|
|
}
|
|
|
|
// see Step 2: parameter interactions for more information about these
|
|
fNoListen = !GetBoolArg("-listen", true);
|
|
fDiscover = GetBoolArg("-discover", true);
|
|
fNameLookup = GetBoolArg("-dns", true);
|
|
|
|
bool fBound = false;
|
|
if (!fNoListen) {
|
|
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, (BF_EXPLICIT | BF_REPORT_ERROR));
|
|
}
|
|
}
|
|
else {
|
|
struct in_addr inaddr_any;
|
|
inaddr_any.s_addr = INADDR_ANY;
|
|
#ifdef USE_IPV6
|
|
fBound |= Bind(CService(in6addr_any, GetListenPort()), BF_NONE);
|
|
#endif
|
|
fBound |= Bind(CService(inaddr_any, GetListenPort()), !fBound ? BF_REPORT_ERROR : BF_NONE);
|
|
}
|
|
if (!fBound)
|
|
return InitError(_("Failed to listen on any port. Use -listen=0 if you want this."));
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
BOOST_FOREACH(string strDest, mapMultiArgs["-seednode"])
|
|
AddOneShot(strDest);
|
|
|
|
// ********************************************************* Step 7: load block chain
|
|
|
|
fReindex = GetBoolArg("-reindex", false);
|
|
|
|
// Upgrading to 0.8; hard-link the old blknnnn.dat files into /blocks/
|
|
filesystem::path blocksDir = GetDataDir() / "blocks";
|
|
if (!filesystem::exists(blocksDir))
|
|
{
|
|
filesystem::create_directories(blocksDir);
|
|
bool linked = false;
|
|
for (unsigned int i = 1; i < 10000; i++) {
|
|
filesystem::path source = GetDataDir() / strprintf("blk%04u.dat", i);
|
|
if (!filesystem::exists(source)) break;
|
|
filesystem::path dest = blocksDir / strprintf("blk%05u.dat", i-1);
|
|
try {
|
|
filesystem::create_hard_link(source, dest);
|
|
printf("Hardlinked %s -> %s\n", source.string().c_str(), dest.string().c_str());
|
|
linked = true;
|
|
} catch (filesystem::filesystem_error & e) {
|
|
// Note: hardlink creation failing is not a disaster, it just means
|
|
// blocks will get re-downloaded from peers.
|
|
printf("Error hardlinking blk%04u.dat : %s\n", i, e.what());
|
|
break;
|
|
}
|
|
}
|
|
if (linked)
|
|
{
|
|
fReindex = true;
|
|
}
|
|
}
|
|
|
|
// cache size calculations
|
|
size_t nTotalCache = GetArg("-dbcache", 25) << 20;
|
|
if (nTotalCache < (1 << 22))
|
|
nTotalCache = (1 << 22); // total cache cannot be less than 4 MiB
|
|
size_t nBlockTreeDBCache = nTotalCache / 8;
|
|
if (nBlockTreeDBCache > (1 << 21) && !GetBoolArg("-txindex", false))
|
|
nBlockTreeDBCache = (1 << 21); // block tree db cache shouldn't be larger than 2 MiB
|
|
nTotalCache -= nBlockTreeDBCache;
|
|
size_t nCoinDBCache = nTotalCache / 2; // use half of the remaining cache for coindb cache
|
|
nTotalCache -= nCoinDBCache;
|
|
nCoinCacheSize = nTotalCache / 300; // coins in memory require around 300 bytes
|
|
|
|
bool fLoaded = false;
|
|
while (!fLoaded) {
|
|
bool fReset = fReindex;
|
|
std::string strLoadError;
|
|
|
|
uiInterface.InitMessage(_("Loading block index..."));
|
|
|
|
nStart = GetTimeMillis();
|
|
do {
|
|
try {
|
|
UnloadBlockIndex();
|
|
delete pcoinsTip;
|
|
delete pcoinsdbview;
|
|
delete pblocktree;
|
|
|
|
pblocktree = new CBlockTreeDB(nBlockTreeDBCache, false, fReindex);
|
|
pcoinsdbview = new CCoinsViewDB(nCoinDBCache, false, fReindex);
|
|
pcoinsTip = new CCoinsViewCache(*pcoinsdbview);
|
|
|
|
if (fReindex)
|
|
pblocktree->WriteReindexing(true);
|
|
|
|
if (!LoadBlockIndex()) {
|
|
strLoadError = _("Error loading block database");
|
|
break;
|
|
}
|
|
|
|
// If the loaded chain has a wrong genesis, bail out immediately
|
|
// (we're likely using a testnet datadir, or the other way around).
|
|
if (!mapBlockIndex.empty() && pindexGenesisBlock == NULL)
|
|
return InitError(_("Incorrect or no genesis block found. Wrong datadir for network?"));
|
|
|
|
// Check for changed -txindex state (only necessary if we are not reindexing anyway)
|
|
if (!fReindex && fTxIndex != GetBoolArg("-txindex", false)) {
|
|
strLoadError = _("You need to rebuild the database using -reindex to change -txindex");
|
|
break;
|
|
}
|
|
|
|
// Initialize the block index (no-op if non-empty database was already loaded)
|
|
if (!InitBlockIndex()) {
|
|
strLoadError = _("Error initializing block database");
|
|
break;
|
|
}
|
|
|
|
uiInterface.InitMessage(_("Verifying blocks..."));
|
|
if (!VerifyDB()) {
|
|
strLoadError = _("Corrupted block database detected");
|
|
break;
|
|
}
|
|
} catch(std::exception &e) {
|
|
strLoadError = _("Error opening block database");
|
|
break;
|
|
}
|
|
|
|
fLoaded = true;
|
|
} while(false);
|
|
|
|
if (!fLoaded) {
|
|
// first suggest a reindex
|
|
if (!fReset) {
|
|
bool fRet = uiInterface.ThreadSafeMessageBox(
|
|
strLoadError + ".\n\n" + _("Do you want to rebuild the block database now?"),
|
|
"", CClientUIInterface::MSG_ERROR | CClientUIInterface::BTN_ABORT);
|
|
if (fRet) {
|
|
fReindex = true;
|
|
fRequestShutdown = false;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return InitError(strLoadError);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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 (GetBoolArg("-printblockindex", false) || GetBoolArg("-printblocktree", false))
|
|
{
|
|
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)
|
|
{
|
|
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 8: load wallet
|
|
|
|
uiInterface.InitMessage(_("Loading wallet..."));
|
|
|
|
nStart = GetTimeMillis();
|
|
bool fFirstRun = true;
|
|
pwalletMain = new CWallet("wallet.dat");
|
|
DBErrors 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_NONCRITICAL_ERROR)
|
|
{
|
|
string msg(_("Warning: error reading wallet.dat! All keys read correctly, but transaction data"
|
|
" or address book entries might be missing or incorrect."));
|
|
InitWarning(msg);
|
|
}
|
|
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 -upgradewallet 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();
|
|
|
|
CPubKey newDefaultKey;
|
|
if (pwalletMain->GetKeyFromPool(newDefaultKey, false)) {
|
|
pwalletMain->SetDefaultKey(newDefaultKey);
|
|
if (!pwalletMain->SetAddressBookName(pwalletMain->vchDefaultKey.GetID(), ""))
|
|
strErrors << _("Cannot write default address") << "\n";
|
|
}
|
|
|
|
pwalletMain->SetBestChain(CBlockLocator(pindexBest));
|
|
}
|
|
|
|
printf("%s", strErrors.str().c_str());
|
|
printf(" wallet %15"PRI64d"ms\n", GetTimeMillis() - nStart);
|
|
|
|
RegisterWallet(pwalletMain);
|
|
|
|
CBlockIndex *pindexRescan = pindexBest;
|
|
if (GetBoolArg("-rescan", false))
|
|
pindexRescan = pindexGenesisBlock;
|
|
else
|
|
{
|
|
CWalletDB walletdb("wallet.dat");
|
|
CBlockLocator locator;
|
|
if (walletdb.ReadBestBlock(locator))
|
|
pindexRescan = locator.GetBlockIndex();
|
|
else
|
|
pindexRescan = pindexGenesisBlock;
|
|
}
|
|
if (pindexBest && 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);
|
|
pwalletMain->SetBestChain(CBlockLocator(pindexBest));
|
|
nWalletDBUpdated++;
|
|
}
|
|
|
|
// ********************************************************* Step 9: import blocks
|
|
|
|
// scan for better chains in the block chain database, that are not yet connected in the active best chain
|
|
CValidationState state;
|
|
if (!ConnectBestBlock(state))
|
|
strErrors << "Failed to connect best block";
|
|
|
|
std::vector<boost::filesystem::path> vImportFiles;
|
|
if (mapArgs.count("-loadblock"))
|
|
{
|
|
BOOST_FOREACH(string strFile, mapMultiArgs["-loadblock"])
|
|
vImportFiles.push_back(strFile);
|
|
}
|
|
threadGroup.create_thread(boost::bind(&ThreadImport, vImportFiles));
|
|
|
|
// ********************************************************* Step 10: load peers
|
|
|
|
uiInterface.InitMessage(_("Loading addresses..."));
|
|
|
|
nStart = GetTimeMillis();
|
|
|
|
{
|
|
CAddrDB adb;
|
|
if (!adb.Read(addrman))
|
|
printf("Invalid or missing peers.dat; recreating\n");
|
|
}
|
|
|
|
printf("Loaded %i addresses from peers.dat %"PRI64d"ms\n",
|
|
addrman.size(), GetTimeMillis() - nStart);
|
|
|
|
// ********************************************************* Step 11: start node
|
|
|
|
if (!CheckDiskSpace())
|
|
return false;
|
|
|
|
if (!strErrors.str().empty())
|
|
return InitError(strErrors.str());
|
|
|
|
RandAddSeedPerfmon();
|
|
|
|
//// debug print
|
|
printf("mapBlockIndex.size() = %"PRIszu"\n", mapBlockIndex.size());
|
|
printf("nBestHeight = %d\n", nBestHeight);
|
|
printf("setKeyPool.size() = %"PRIszu"\n", pwalletMain->setKeyPool.size());
|
|
printf("mapWallet.size() = %"PRIszu"\n", pwalletMain->mapWallet.size());
|
|
printf("mapAddressBook.size() = %"PRIszu"\n", pwalletMain->mapAddressBook.size());
|
|
|
|
StartNode(threadGroup);
|
|
|
|
// InitRPCMining is needed here so getwork/getblocktemplate in the GUI debug console works properly.
|
|
InitRPCMining();
|
|
if (fServer)
|
|
StartRPCThreads();
|
|
|
|
// Generate coins in the background
|
|
GenerateBitcoins(GetBoolArg("-gen", false), pwalletMain);
|
|
|
|
// ********************************************************* Step 12: finished
|
|
|
|
uiInterface.InitMessage(_("Done loading"));
|
|
|
|
// Add wallet transactions that aren't already in a block to mapTransactions
|
|
pwalletMain->ReacceptWalletTransactions();
|
|
|
|
// Run a thread to flush wallet periodically
|
|
threadGroup.create_thread(boost::bind(&ThreadFlushWalletDB, boost::ref(pwalletMain->strWalletFile)));
|
|
|
|
return !fRequestShutdown;
|
|
}
|