#if defined(HAVE_CONFIG_H)

#include "config/bitblocks-config.h"

#endif

#include "init.h"

#include "activemasternode.h"

#include "addrman.h"

#include "amount.h"

#include "checkpoints.h"

#include "compat/sanity.h"

#include "key.h"

#include "main.h"

#include "masternode-budget.h"

#include "masternode-payments.h"

#include "masternodeconfig.h"

#include "masternodeman.h"

#include "miner.h"

#include "net.h"

#include "rpcserver.h"

#include "script/standard.h"

#include "spork.h"

#include "txdb.h"

#include "ui_interface.h"

#include "util.h"

#include "utilmoneystr.h"

#include "validationinterface.h"

#ifdef ENABLE_WALLET

#include "db.h"

#include "wallet.h"

#include "walletdb.h"

#endif

#include <fstream>

#include <stdint.h>

#include <stdio.h>

#ifndef WIN32

#include <signal.h>

#endif

#include <boost/algorithm/string/predicate.hpp>

#include <boost/algorithm/string/replace.hpp>

#include <boost/filesystem.hpp>

#include <boost/interprocess/sync/file_lock.hpp>

#include <boost/thread.hpp>

#include <openssl/crypto.h>

#if ENABLE_ZMQ

#include "zmq/zmqnotificationinterface.h"

#endif

using namespace boost;

using namespace std;

#ifdef ENABLE_WALLET

CWallet* pwalletMain = NULL;

int nWalletBackups = 10;

#endif

bool fFeeEstimatesInitialized = false;

bool fRestartRequested = false; // true: restart false: shutdown

#if ENABLE_ZMQ

static CZMQNotificationInterface* pzmqNotificationInterface = NULL;

#endif

#ifdef WIN32

#define MIN_CORE_FILEDESCRIPTORS 0

#else

#define MIN_CORE_FILEDESCRIPTORS 150

#endif

enum BindFlags {

};

static const char* FEE_ESTIMATES_FILENAME = "fee_estimates.dat";

CClientUIInterface uiInterface;

volatile bool fRequestShutdown = false;

void StartShutdown()

{

fRequestShutdown = true;

}

bool ShutdownRequested()

{

return fRequestShutdown || fRestartRequested;

}

class CCoinsViewErrorCatcher : public CCoinsViewBacked

};

static CCoinsViewDB* pcoinsdbview = NULL;

static CCoinsViewErrorCatcher* pcoinscatcher = NULL;

void PrepareShutdown()

}

void Shutdown()

}

void HandleSIGTERM(int)

{

fRequestShutdown = true;

}

void HandleSIGHUP(int)

{

fReopenDebugLog = true;

}

bool static InitError(const std::string& str)

}

bool static InitWarning(const std::string& str)

}

bool static Bind(const CService& addr, unsigned int flags)

}

std::string HelpMessage(HelpMessageMode mode)

}

std::string LicenseInfo()

}

static void BlockNotifyCallback(const uint256& hashNewTip)

}

struct CImportingNow {

};

void ThreadImport(std::vector<boost::filesystem::path> vImportFiles)

}

bool InitSanityCheck(void)

}

bool AppInit2(boost::thread_group& threadGroup)

{

#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

#ifndef PROCESS_DEP_ENABLE

#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

if (GetBoolArg("-sysperms", false)) {

#ifdef ENABLE_WALLET

if (!GetBoolArg("-disablewallet", false))

return InitError("Error: -sysperms is not allowed in combination with enabled wallet functionality");

#endif

} else {

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

#if defined(__SVR4) && defined(__sun)

// ignore SIGPIPE on Solaris

signal(SIGPIPE, SIG_IGN);

#endif

#endif

// ********************************************************* Step 2: parameter interactions

// Set this early so that parameter interactions go to console

fPrintToConsole = GetBoolArg("-printtoconsole", false);

fLogTimestamps = GetBoolArg("-logtimestamps", true);

fLogIPs = GetBoolArg("-logips", false);

if (mapArgs.count("-bind") || mapArgs.count("-whitebind")) {

// when specifying an explicit binding address, you want to listen on it

// even when -connect or -proxy is specified

if (SoftSetBoolArg("-listen", true))

LogPrintf("AppInit2 : parameter interaction: -bind or -whitebind set -> setting -listen=1\n");

}

if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0) {

// when only connecting to trusted nodes, do not seed via DNS, or listen by default

if (SoftSetBoolArg("-dnsseed", false))

LogPrintf("AppInit2 : parameter interaction: -connect set -> setting -dnsseed=0\n");

if (SoftSetBoolArg("-listen", false))

LogPrintf("AppInit2 : parameter interaction: -connect set -> setting -listen=0\n");

}

if (mapArgs.count("-proxy")) {

// to protect privacy, do not listen by default if a default proxy server is specified

if (SoftSetBoolArg("-listen", false))

LogPrintf("%s: parameter interaction: -proxy set -> setting -listen=0\n", __func__);

// to protect privacy, do not use UPNP when a proxy is set. The user may still specify -listen=1

// to listen locally, so don't rely on this happening through -listen below.

if (SoftSetBoolArg("-upnp", false))

LogPrintf("%s: parameter interaction: -proxy set -> setting -upnp=0\n", __func__);

// to protect privacy, do not discover addresses by default

if (SoftSetBoolArg("-discover", false))

LogPrintf("AppInit2 : parameter interaction: -proxy set -> setting -discover=0\n");

}

if (!GetBoolArg("-listen", true)) {

// do not map ports or try to retrieve public IP when not listening (pointless)

if (SoftSetBoolArg("-upnp", false))

LogPrintf("AppInit2 : parameter interaction: -listen=0 -> setting -upnp=0\n");

if (SoftSetBoolArg("-discover", false))

LogPrintf("AppInit2 : parameter interaction: -listen=0 -> setting -discover=0\n");

}

if (mapArgs.count("-externalip")) {

// if an explicit public IP is specified, do not try to find others

if (SoftSetBoolArg("-discover", false))

LogPrintf("AppInit2 : parameter interaction: -externalip set -> setting -discover=0\n");

}

if (GetBoolArg("-salvagewallet", false)) {

// Rewrite just private keys: rescan to find transactions

if (SoftSetBoolArg("-rescan", true))

LogPrintf("AppInit2 : parameter interaction: -salvagewallet=1 -> setting -rescan=1\n");

}

// -zapwallettx implies a rescan

if (GetBoolArg("-zapwallettxes", false)) {

if (SoftSetBoolArg("-rescan", true))

LogPrintf("AppInit2 : parameter interaction: -zapwallettxes=<mode> -> setting -rescan=1\n");

}

if (!GetBoolArg("-enableswifttx", fEnableSwiftTX)) {

if (SoftSetArg("-swifttxdepth", 0))

LogPrintf("AppInit2 : parameter interaction: -enableswifttx=false -> setting -nSwiftTXDepth=0\n");

}

if (mapArgs.count("-reservebalance")) {

if (!ParseMoney(mapArgs["-reservebalance"], nReserveBalance)) {

InitError(_("Invalid amount for -reservebalance=<amount>"));

return false;

}

}

// Make sure enough file descriptors are available

int nBind = std::max((int)mapArgs.count("-bind") + (int)mapArgs.count("-whitebind"), 1);

nMaxConnections = GetArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);

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 = !mapMultiArgs["-debug"].empty();

// Special-case: if -debug=0/-nodebug is set, turn off debugging messages

const vector<string>& categories = mapMultiArgs["-debug"];

if (GetBoolArg("-nodebug", false) || find(categories.begin(), categories.end(), string("0")) != categories.end())

fDebug = false;

// Check for -debugnet

if (GetBoolArg("-debugnet", false))

InitWarning(_("Warning: Unsupported argument -debugnet ignored, use -debug=net."));

// Check for -socks - as this is a privacy risk to continue, exit here

if (mapArgs.count("-socks"))

return InitError(_("Error: Unsupported argument -socks found. Setting SOCKS version isn't possible anymore, only SOCKS5 proxies are supported."));

// Check for -tor - as this is a privacy risk to continue, exit here

if (GetBoolArg("-tor", false))

return InitError(_("Error: Unsupported argument -tor found, use -onion."));

if (GetBoolArg("-benchmark", false))

InitWarning(_("Warning: Unsupported argument -benchmark ignored, use -debug=bench."));

// Checkmempool and checkblockindex default to true in regtest mode

mempool.setSanityCheck(GetBoolArg("-checkmempool", Params().DefaultConsistencyChecks()));

fCheckBlockIndex = GetBoolArg("-checkblockindex", Params().DefaultConsistencyChecks());

Checkpoints::fEnabled = GetBoolArg("-checkpoints", true);

// -par=0 means autodetect, but nScriptCheckThreads==0 means no concurrency

nScriptCheckThreads = GetArg("-par", DEFAULT_SCRIPTCHECK_THREADS);

if (nScriptCheckThreads <= 0)

nScriptCheckThreads += boost::thread::hardware_concurrency();

if (nScriptCheckThreads <= 1)

nScriptCheckThreads = 0;

else if (nScriptCheckThreads > MAX_SCRIPTCHECK_THREADS)

nScriptCheckThreads = MAX_SCRIPTCHECK_THREADS;

fServer = GetBoolArg("-server", false);

setvbuf(stdout, NULL, _IOLBF, 0); /// ***TODO*** do we still need this after -printtoconsole is gone?

// Staking needs a CWallet instance, so make sure wallet is enabled

#ifdef ENABLE_WALLET

bool fDisableWallet = GetBoolArg("-disablewallet", false);

if (fDisableWallet) {

#endif

if (SoftSetBoolArg("-staking", false))

LogPrintf("AppInit2 : parameter interaction: wallet functionality not enabled -> setting -staking=0\n");

#ifdef ENABLE_WALLET

}

#endif

nConnectTimeout = GetArg("-timeout", DEFAULT_CONNECT_TIMEOUT);

if (nConnectTimeout <= 0)

nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;

// 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("-minrelaytxfee")) {

CAmount n = 0;

if (ParseMoney(mapArgs["-minrelaytxfee"], n) && n > 0)

::minRelayTxFee = CFeeRate(n);

else

return InitError(strprintf(_("Invalid amount for -minrelaytxfee=<amount>: '%s'"), mapArgs["-minrelaytxfee"]));

}

#ifdef ENABLE_WALLET

if (mapArgs.count("-mintxfee")) {

CAmount n = 0;

if (ParseMoney(mapArgs["-mintxfee"], n) && n > 0)

CWallet::minTxFee = CFeeRate(n);

else

return InitError(strprintf(_("Invalid amount for -mintxfee=<amount>: '%s'"), mapArgs["-mintxfee"]));

}

if (mapArgs.count("-paytxfee")) {

CAmount nFeePerK = 0;

if (!ParseMoney(mapArgs["-paytxfee"], nFeePerK))

return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s'"), mapArgs["-paytxfee"]));

if (nFeePerK > nHighTransactionFeeWarning)

InitWarning(_("Warning: -paytxfee is set very high! This is the transaction fee you will pay if you send a transaction."));

payTxFee = CFeeRate(nFeePerK, 1000);

if (payTxFee < ::minRelayTxFee) {

return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' (must be at least %s)"),

mapArgs["-paytxfee"], ::minRelayTxFee.ToString()));

}

}

if (mapArgs.count("-maxtxfee")) {

CAmount nMaxFee = 0;

if (!ParseMoney(mapArgs["-maxtxfee"], nMaxFee))

return InitError(strprintf(_("Invalid amount for -maxtxfee=<amount>: '%s'"), mapArgs["-maxtxfee"]));

if (nMaxFee > nHighTransactionMaxFeeWarning)

InitWarning(_("Warning: -maxtxfee is set very high! Fees this large could be paid on a single transaction."));

maxTxFee = nMaxFee;

if (CFeeRate(maxTxFee, 1000) < ::minRelayTxFee) {

return InitError(strprintf(_("Invalid amount for -maxtxfee=<amount>: '%s' (must be at least the minrelay fee of %s to prevent stuck transactions)"),

mapArgs["-maxtxfee"], ::minRelayTxFee.ToString()));

}

}

nTxConfirmTarget = GetArg("-txconfirmtarget", 1);

bSpendZeroConfChange = GetArg("-spendzeroconfchange", true);

fSendFreeTransactions = GetArg("-sendfreetransactions", false);

std::string strWalletFile = GetArg("-wallet", "wallet.dat");

#endif // ENABLE_WALLET

fIsBareMultisigStd = GetArg("-permitbaremultisig", true) != 0;

nMaxDatacarrierBytes = GetArg("-datacarriersize", nMaxDatacarrierBytes);

fAlerts = GetBoolArg("-alerts", DEFAULT_ALERTS);

if (GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))

nLocalServices |= NODE_BLOOM;

// ********************************************************* Step 4: application initialization: dir lock, daemonize, pidfile, debug log

// Sanity check

if (!InitSanityCheck())

return InitError(_("Initialization sanity check failed. BitBlocks Core is shutting down."));

std::string strDataDir = GetDataDir().string();

#ifdef ENABLE_WALLET

// Wallet file must be a plain filename without a directory

if (strWalletFile != boost::filesystem::basename(strWalletFile) + boost::filesystem::extension(strWalletFile))

return InitError(strprintf(_("Wallet %s resides outside data directory %s"), strWalletFile, strDataDir));

#endif

// Make sure only a single BitBlocks 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());

// Wait maximum 10 seconds if an old wallet is still running. Avoids lockup during restart

if (!lock.timed_lock(boost::get_system_time() + boost::posix_time::seconds(10)))

return InitError(strprintf(_("Cannot obtain a lock on data directory %s. BitBlocks Core is probably already running."), strDataDir));

#ifndef WIN32

CreatePidFile(GetPidFile(), getpid());

#endif

if (GetBoolArg("-shrinkdebugfile", !fDebug))

ShrinkDebugFile();

LogPrintf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");

LogPrintf("BitBlocks version %s (%s)\n", FormatFullVersion(), CLIENT_DATE);

LogPrintf("Using OpenSSL version %s\n", SSLeay_version(SSLEAY_VERSION));

#ifdef ENABLE_WALLET

LogPrintf("Using BerkeleyDB version %s\n", DbEnv::version(0, 0, 0));

#endif

if (!fLogTimestamps)

LogPrintf("Startup time: %s\n", DateTimeStrFormat("%Y-%m-%d %H:%M:%S", GetTime()));

LogPrintf("Default data directory %s\n", GetDefaultDataDir().string());

LogPrintf("Using data directory %s\n", strDataDir);

LogPrintf("Using config file %s\n", GetConfigFile().string());

LogPrintf("Using at most %i connections (%i file descriptors available)\n", nMaxConnections, nFD);

std::ostringstream strErrors;

LogPrintf("Using %u threads for script verification\n", nScriptCheckThreads);

if (nScriptCheckThreads) {

for (int i = 0; i < nScriptCheckThreads - 1; i++)

threadGroup.create_thread(&ThreadScriptCheck);

}

if (mapArgs.count("-sporkkey")) // spork priv key

{

if (!sporkManager.SetPrivKey(GetArg("-sporkkey", "")))

return InitError(_("Unable to sign spork message, wrong key?"));

}

/* Start the RPC server already. It will be started in "warmup" mode

if (fServer) {

uiInterface.InitMessage.connect(SetRPCWarmupStatus);

StartRPCThreads();

}

int64_t nStart;

#ifdef ENABLE_WALLET

if (!fDisableWallet) {

filesystem::path backupDir = GetDataDir() / "backups";

if (!filesystem::exists(backupDir)) {

// Always create backup folder to not confuse the operating system's file browser

filesystem::create_directories(backupDir);

}

nWalletBackups = GetArg("-createwalletbackups", 10);

nWalletBackups = std::max(0, std::min(10, nWalletBackups));

if (nWalletBackups > 0) {

if (filesystem::exists(backupDir)) {

// Create backup of the wallet

std::string dateTimeStr = DateTimeStrFormat(".%Y-%m-%d-%H-%M", GetTime());

std::string backupPathStr = backupDir.string();

backupPathStr += "/" + strWalletFile;

std::string sourcePathStr = GetDataDir().string();

sourcePathStr += "/" + strWalletFile;

boost::filesystem::path sourceFile = sourcePathStr;

boost::filesystem::path backupFile = backupPathStr + dateTimeStr;

sourceFile.make_preferred();

backupFile.make_preferred();

if (boost::filesystem::exists(sourceFile)) {

#if BOOST_VERSION >= 158000

try {

boost::filesystem::copy_file(sourceFile, backupFile);

LogPrintf("Creating backup of %s -> %s\n", sourceFile, backupFile);

} catch (boost::filesystem::filesystem_error& error) {

LogPrintf("Failed to create backup %s\n", error.what());

}

#else

std::ifstream src(sourceFile.string(), std::ios::binary);

std::ofstream dst(backupFile.string(), std::ios::binary);

dst << src.rdbuf();

#endif

}

// Keep only the last 10 backups, including the new one of course

typedef std::multimap<std::time_t, boost::filesystem::path> folder_set_t;

folder_set_t folder_set;

boost::filesystem::directory_iterator end_iter;

boost::filesystem::path backupFolder = backupDir.string();

backupFolder.make_preferred();

// Build map of backup files for current(!) wallet sorted by last write time

boost::filesystem::path currentFile;

for (boost::filesystem::directory_iterator dir_iter(backupFolder); dir_iter != end_iter; ++dir_iter) {