{

fsbridge::ofstream file{GetPidFile()};

if (file) {

#ifdef WIN32

tfm::format(file, "%d\n", GetCurrentProcessId());

#else

tfm::format(file, "%d\n", getpid());

#endif

return true;

} else {

return InitError(strprintf(_("Unable to create the PID file '%s': %s").translated, GetPidFile().string(), std::strerror(errno)));

}

{

InterruptHTTPServer();

InterruptHTTPRPC();

InterruptRPC();

InterruptREST();

InterruptTorControl();

InterruptMapPort();

if (g_connman)

g_connman->Interrupt();

if (g_txindex) {

g_txindex->Interrupt();

}

ForEachBlockFilterIndex([](BlockFilterIndex& index) { index.Interrupt(); });

{

LogPrintf("%s: In progress...\n", __func__);

static CCriticalSection cs_Shutdown;

TRY_LOCK(cs_Shutdown, lockShutdown);

if (!lockShutdown)

return;

/// Note: Shutdown() must be able to handle cases in which initialization failed part of the way,

/// for example if the data directory was found to be locked.

/// Be sure that anything that writes files or flushes caches only does this if the respective

/// module was initialized.

util::ThreadRename("shutoff");

mempool.AddTransactionsUpdated(1);

StopHTTPRPC();

StopREST();

StopRPC();

StopHTTPServer();

for (const auto& client : interfaces.chain_clients) {

client->flush();

}

StopMapPort();

// Because these depend on each-other, we make sure that neither can be

// using the other before destroying them.

if (peerLogic) UnregisterValidationInterface(peerLogic.get());

if (g_connman) g_connman->Stop();

StopTorControl();

// After everything has been shut down, but before things get flushed, stop the

// CScheduler/checkqueue threadGroup

threadGroup.interrupt_all();

threadGroup.join_all();

// After the threads that potentially access these pointers have been stopped,

// destruct and reset all to nullptr.

peerLogic.reset();

g_connman.reset();

g_banman.reset();

if (::mempool.IsLoaded() && gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {

DumpMempool(::mempool);

}

if (fFeeEstimatesInitialized)

{

::feeEstimator.FlushUnconfirmed();

fs::path est_path = GetDataDir() / FEE_ESTIMATES_FILENAME;

CAutoFile est_fileout(fsbridge::fopen(est_path, "wb"), SER_DISK, CLIENT_VERSION);

if (!est_fileout.IsNull())

::feeEstimator.Write(est_fileout);

else

LogPrintf("%s: Failed to write fee estimates to %s\n", __func__, est_path.string());

fFeeEstimatesInitialized = false;

}

// FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing

//

// g_chainstate is referenced here directly (instead of ::ChainstateActive()) because it

// may not have been initialized yet.

{

LOCK(cs_main);

if (g_chainstate && g_chainstate->CanFlushToDisk()) {

g_chainstate->ForceFlushStateToDisk();

}

}

// After there are no more peers/RPC left to give us new data which may generate

// CValidationInterface callbacks, flush them...

GetMainSignals().FlushBackgroundCallbacks();

// Stop and delete all indexes only after flushing background callbacks.

if (g_txindex) {

g_txindex->Stop();

g_txindex.reset();

}

ForEachBlockFilterIndex([](BlockFilterIndex& index) { index.Stop(); });

DestroyAllBlockFilterIndexes();

// Any future callbacks will be dropped. This should absolutely be safe - if

// missing a callback results in an unrecoverable situation, unclean shutdown

// would too. The only reason to do the above flushes is to let the wallet catch

// up with our current chain to avoid any strange pruning edge cases and make

// next startup faster by avoiding rescan.

{

LOCK(cs_main);

if (g_chainstate && g_chainstate->CanFlushToDisk()) {

g_chainstate->ForceFlushStateToDisk();

g_chainstate->ResetCoinsViews();

}

pblocktree.reset();

}

for (const auto& client : interfaces.chain_clients) {

client->stop();

}

#if ENABLE_ZMQ

if (g_zmq_notification_interface) {

UnregisterValidationInterface(g_zmq_notification_interface);

delete g_zmq_notification_interface;

g_zmq_notification_interface = nullptr;

}

#endif

try {

if (!fs::remove(GetPidFile())) {

LogPrintf("%s: Unable to remove PID file: File does not exist\n", __func__);

}

} catch (const fs::filesystem_error& e) {

LogPrintf("%s: Unable to remove PID file: %s\n", __func__, fsbridge::get_filesystem_error_message(e));

}

interfaces.chain_clients.clear();

UnregisterAllValidationInterfaces();

GetMainSignals().UnregisterBackgroundSignalScheduler();

GetMainSignals().UnregisterWithMempoolSignals(mempool);

globalVerifyHandle.reset();

ECC_Stop();

LogPrintf("%s: done\n", __func__);

{

StartShutdown();

Sleep(INFINITE);

return true;

{

struct sigaction sa;

sa.sa_handler = handler;

sigemptyset(&sa.sa_mask);

sa.sa_flags = 0;

sigaction(signal, &sa, nullptr);

{

rpc_notify_block_change_connection.disconnect();

RPCNotifyBlockChange(false, nullptr);

g_best_block_cv.notify_all();

LogPrint(BCLog::RPC, "RPC stopped.\n");

{

SetupHelpOptions(gArgs);

gArgs.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now

const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);

const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);

const auto regtestBaseParams = CreateBaseChainParams(CBaseChainParams::REGTEST);

const auto defaultChainParams = CreateChainParams(CBaseChainParams::MAIN);

const auto testnetChainParams = CreateChainParams(CBaseChainParams::TESTNET);

const auto regtestChainParams = CreateChainParams(CBaseChainParams::REGTEST);

// Hidden Options

std::vector<std::string> hidden_args = {

"-dbcrashratio", "-forcecompactdb",

// GUI args. These will be overwritten by SetupUIArgs for the GUI

"-allowselfsignedrootcertificates", "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-rootcertificates=<file>", "-splash", "-uiplatform"};

gArgs.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

#if HAVE_SYSTEM

gArgs.AddArg("-alertnotify=<cmd>", "Execute command when a relevant alert is received or we see a really long fork (%s in cmd is replaced by message)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

#endif

gArgs.AddArg("-assumevalid=<hex>", strprintf("If this block is in the chain assume that it and its ancestors are valid and potentially skip their script verification (0 to verify all, default: %s, testnet: %s)", defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-blocksdir=<dir>", "Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

#if HAVE_SYSTEM

gArgs.AddArg("-blocknotify=<cmd>", "Execute command when the best block changes (%s in cmd is replaced by block hash)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

#endif

gArgs.AddArg("-blockreconstructionextratxn=<n>", strprintf("Extra transactions to keep in memory for compact block reconstructions (default: %u)", DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-blocksonly", strprintf("Whether to reject transactions from network peers. Transactions from the wallet, RPC and relay whitelisted inbound peers are not affected. (default: %u)", DEFAULT_BLOCKSONLY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-conf=<file>", strprintf("Specify configuration file. Relative paths will be prefixed by datadir location. (default: %s)", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", nDefaultDbBatchSize), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);

gArgs.AddArg("-dbcache=<n>", strprintf("Maximum database cache size <n> MiB (%d to %d, default: %d). In addition, unused mempool memory is shared for this cache (see -maxmempool).", nMinDbCache, nMaxDbCache, nDefaultDbCache), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-debuglogfile=<file>", strprintf("Specify location of debug log file. Relative paths will be prefixed by a net-specific datadir location. (-nodebuglogfile to disable; default: %s)", DEFAULT_DEBUGLOGFILE), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-feefilter", strprintf("Tell other nodes to filter invs to us by our mempool min fee (default: %u)", DEFAULT_FEEFILTER), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);

gArgs.AddArg("-includeconf=<file>", "Specify additional configuration file, relative to the -datadir path (only useable from configuration file, not command line)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-loadblock=<file>", "Imports blocks from external blk000??.dat file on startup", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-maxmempool=<n>", strprintf("Keep the transaction memory pool below <n> megabytes (default: %u)", DEFAULT_MAX_MEMPOOL_SIZE), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-maxorphantx=<n>", strprintf("Keep at most <n> unconnectable transactions in memory (default: %u)", DEFAULT_MAX_ORPHAN_TRANSACTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-mempoolexpiry=<n>", strprintf("Do not keep transactions in the mempool longer than <n> hours (default: %u)", DEFAULT_MEMPOOL_EXPIRY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-minimumchainwork=<hex>", strprintf("Minimum work assumed to exist on a valid chain in hex (default: %s, testnet: %s)", defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);

gArgs.AddArg("-par=<n>", strprintf("Set the number of script verification threads (%u to %d, 0 = auto, <0 = leave that many cores free, default: %d)",

-GetNumCores(), MAX_SCRIPTCHECK_THREADS, DEFAULT_SCRIPTCHECK_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-persistmempool", strprintf("Whether to save the mempool on shutdown and load on restart (default: %u)", DEFAULT_PERSIST_MEMPOOL), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-pid=<file>", strprintf("Specify pid file. Relative paths will be prefixed by a net-specific datadir location. (default: %s)", BITCOIN_PID_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-prune=<n>", strprintf("Reduce storage requirements by enabling pruning (deleting) of old blocks. This allows the pruneblockchain RPC to be called to delete specific blocks, and enables automatic pruning of old blocks if a target size in MiB is provided. This mode is incompatible with -txindex and -rescan. "

"Warning: Reverting this setting requires re-downloading the entire blockchain. "

"(default: 0 = disable pruning blocks, 1 = allow manual pruning via RPC, >=%u = automatically prune block files to stay under the specified target size in MiB)", MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-reindex", "Rebuild chain state and block index from the blk*.dat files on disk", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-reindex-chainstate", "Rebuild chain state from the currently indexed blocks. When in pruning mode or if blocks on disk might be corrupted, use full -reindex instead.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

#ifndef WIN32

gArgs.AddArg("-sysperms", "Create new files with system default permissions, instead of umask 077 (only effective with disabled wallet functionality)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

#else

hidden_args.emplace_back("-sysperms");

#endif

gArgs.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-blockfilterindex=<type>",

strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +

" If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",

ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-addnode=<ip>", "Add a node to connect to and attempt to keep the connection open (see the `addnode` RPC command help for more info). This option can be specified multiple times to add multiple nodes.", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);

gArgs.AddArg("-banscore=<n>", strprintf("Threshold for disconnecting misbehaving peers (default: %u)", DEFAULT_BANSCORE_THRESHOLD), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-bantime=<n>", strprintf("Number of seconds to keep misbehaving peers from reconnecting (default: %u)", DEFAULT_MISBEHAVING_BANTIME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-bind=<addr>", "Bind to given address and always listen on it. Use [host]:port notation for IPv6", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);

gArgs.AddArg("-connect=<ip>", "Connect only to the specified node; -noconnect disables automatic connections (the rules for this peer are the same as for -addnode). This option can be specified multiple times to connect to multiple nodes.", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);

gArgs.AddArg("-discover", "Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-dns", strprintf("Allow DNS lookups for -addnode, -seednode and -connect (default: %u)", DEFAULT_NAME_LOOKUP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-dnsseed", "Query for peer addresses via DNS lookup, if low on addresses (default: 1 unless -connect used)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-enablebip61", strprintf("Send reject messages per BIP61 (default: %u)", DEFAULT_ENABLE_BIP61), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-externalip=<ip>", "Specify your own public address", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-forcednsseed", strprintf("Always query for peer addresses via DNS lookup (default: %u)", DEFAULT_FORCEDNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-listen", "Accept connections from outside (default: 1 if no -proxy or -connect)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-listenonion", strprintf("Automatically create Tor hidden service (default: %d)", DEFAULT_LISTEN_ONION), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-maxconnections=<n>", strprintf("Maintain at most <n> connections to peers (default: %u)", DEFAULT_MAX_PEER_CONNECTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-maxsendbuffer=<n>", strprintf("Maximum per-connection send buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXSENDBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-maxtimeadjustment", strprintf("Maximum allowed median peer time offset adjustment. Local perspective of time may be influenced by peers forward or backward by this amount. (default: %u seconds)", DEFAULT_MAX_TIME_ADJUSTMENT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-maxuploadtarget=<n>", strprintf("Tries to keep outbound traffic under the given target (in MiB per 24h), 0 = no limit (default: %d)", DEFAULT_MAX_UPLOAD_TARGET), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-onion=<ip:port>", "Use separate SOCKS5 proxy to reach peers via Tor hidden services, set -noonion to disable (default: -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-onlynet=<net>", "Make outgoing connections only through network <net> (ipv4, ipv6 or onion). Incoming connections are not affected by this option. This option can be specified multiple times to allow multiple networks.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-permitbaremultisig", strprintf("Relay non-P2SH multisig (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-port=<port>", strprintf("Listen for connections on <port> (default: %u, testnet: %u, regtest: %u)", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);

gArgs.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-seednode=<ip>", "Connect to a node to retrieve peer addresses, and disconnect. This option can be specified multiple times to connect to multiple nodes.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-timeout=<n>", strprintf("Specify connection timeout in milliseconds (minimum: 1, default: %d)", DEFAULT_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-peertimeout=<n>", strprintf("Specify p2p connection timeout in seconds. This option determines the amount of time a peer may be inactive before the connection to it is dropped. (minimum: 1, default: %d)", DEFAULT_PEER_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);

gArgs.AddArg("-torcontrol=<ip>:<port>", strprintf("Tor control port to use if onion listening enabled (default: %s)", DEFAULT_TOR_CONTROL), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

#ifdef USE_UPNP

#if USE_UPNP

gArgs.AddArg("-upnp", "Use UPnP to map the listening port (default: 1 when listening and no -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

#else

gArgs.AddArg("-upnp", strprintf("Use UPnP to map the listening port (default: %u)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

#endif

#else

hidden_args.emplace_back("-upnp");

#endif

gArgs.AddArg("-whitebind=<[permissions@]addr>", "Bind to given address and whitelist peers connecting to it. "

"Use [host]:port notation for IPv6. Allowed permissions are bloomfilter (allow requesting BIP37 filtered blocks and transactions), "

"noban (do not ban for misbehavior), "

"forcerelay (relay even non-standard transactions), "

"relay (relay even in -blocksonly mode), "

"and mempool (allow requesting BIP35 mempool contents). "

"Specify multiple permissions separated by commas (default: noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

gArgs.AddArg("-whitelist=<[permissions@]IP address or network>", "Whitelist peers connecting from the given IP address (e.g. 1.2.3.4) or "

"CIDR notated network(e.g. 1.2.3.0/24). Uses same permissions as "

"-whitebind. Can be specified multiple times." , ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

g_wallet_init_interface.AddWalletOptions();

#if ENABLE_ZMQ

gArgs.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

gArgs.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

gArgs.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

gArgs.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

gArgs.AddArg("-zmqpubhashblockhwm=<n>", strprintf("Set publish hash block outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

gArgs.AddArg("-zmqpubhashtxhwm=<n>", strprintf("Set publish hash transaction outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

gArgs.AddArg("-zmqpubrawblockhwm=<n>", strprintf("Set publish raw block outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

gArgs.AddArg("-zmqpubrawtxhwm=<n>", strprintf("Set publish raw transaction outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);

#else

hidden_args.emplace_back("-zmqpubhashblock=<address>");

hidden_args.emplace_back("-zmqpubhashtx=<address>");

hidden_args.emplace_back("-zmqpubrawblock=<address>");

hidden_args.emplace_back("-zmqpubrawtx=<address>");

hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");

hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");

hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");

hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");

#endif

gArgs.AddArg("-checkblocks=<n>", strprintf("How many blocks to check at startup (default: %u, 0 = all)", DEFAULT_CHECKBLOCKS), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-checklevel=<n>", strprintf("How thorough the block verification of -checkblocks is: "

"level 0 reads the blocks from disk, "

"level 1 verifies block validity, "

"level 2 verifies undo data, "

"level 3 checks disconnection of tip blocks, "

"and level 4 tries to reconnect the blocks, "

"each level includes the checks of the previous levels "

"(0-4, default: %u)", DEFAULT_CHECKLEVEL), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-checkblockindex", strprintf("Do a consistency check for the block tree, chainstate, and other validation data structures occasionally. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-checkmempool=<n>", strprintf("Run checks every <n> transactions (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-checkpoints", strprintf("Disable expensive verification for known chain history (default: %u)", DEFAULT_CHECKPOINTS_ENABLED), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-dropmessagestest=<n>", "Randomly drop 1 of every <n> network messages", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-stopatheight", strprintf("Stop running after reaching the given height in the main chain (default: %u)", DEFAULT_STOPATHEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-limitancestorcount=<n>", strprintf("Do not accept transactions if number of in-mempool ancestors is <n> or more (default: %u)", DEFAULT_ANCESTOR_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-limitancestorsize=<n>", strprintf("Do not accept transactions whose size with all in-mempool ancestors exceeds <n> kilobytes (default: %u)", DEFAULT_ANCESTOR_SIZE_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-limitdescendantcount=<n>", strprintf("Do not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u)", DEFAULT_DESCENDANT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-limitdescendantsize=<n>", strprintf("Do not accept transactions if any ancestor would have more than <n> kilobytes of in-mempool descendants (default: %u).", DEFAULT_DESCENDANT_SIZE_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-addrmantest", "Allows to test address relay on localhost", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-debug=<category>", "Output debugging information (default: -nodebug, supplying <category> is optional). "

"If <category> is not supplied or if <category> = 1, output all debugging information. <category> can be: " + ListLogCategories() + ".", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-debugexclude=<category>", strprintf("Exclude debugging information for a category. Can be used in conjunction with -debug=1 to output debug logs for all categories except one or more specified categories."), ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-logips", strprintf("Include IP addresses in debug output (default: %u)", DEFAULT_LOGIPS), ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-logtimestamps", strprintf("Prepend debug output with timestamp (default: %u)", DEFAULT_LOGTIMESTAMPS), ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-logthreadnames", strprintf("Prepend debug output with name of the originating thread (only available on platforms supporting thread_local) (default: %u)", DEFAULT_LOGTHREADNAMES), ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-logtimemicros", strprintf("Add microsecond precision to debug timestamps (default: %u)", DEFAULT_LOGTIMEMICROS), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-mocktime=<n>", "Replace actual time with <n> seconds since epoch (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_SIZE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-maxtipage=<n>", strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)", DEFAULT_MAX_TIP_AGE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-printpriority", strprintf("Log transaction fee per kB when mining blocks (default: %u)", DEFAULT_PRINTPRIORITY), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-printtoconsole", "Send trace/debug info to console (default: 1 when no -daemon. To disable logging to file, set -nodebuglogfile)", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-shrinkdebugfile", "Shrink debug.log file on client startup (default: 1 when no -debug)", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

gArgs.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

SetupChainParamsBaseOptions();

gArgs.AddArg("-acceptnonstdtxn", strprintf("Relay and mine \"non-standard\" transactions (%sdefault: %u)", "testnet/regtest only; ", !testnetChainParams->RequireStandard()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-incrementalrelayfee=<amt>", strprintf("Fee rate (in %s/kB) used to define cost of relay, used for mempool limiting and BIP 125 replacement. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_INCREMENTAL_RELAY_FEE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-dustrelayfee=<amt>", strprintf("Fee rate (in %s/kB) used to define dust, the value of an output such that it will cost more than its value in fees at this fee rate to spend it. (default: %s)", CURRENCY_UNIT, FormatMoney(DUST_RELAY_TX_FEE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-bytespersigop", strprintf("Equivalent bytes per sigop in transactions for relay and mining (default: %u)", DEFAULT_BYTES_PER_SIGOP), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-datacarrier", strprintf("Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-datacarriersize", strprintf("Maximum size of data in data carrier transactions we relay and mine (default: %u)", MAX_OP_RETURN_RELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",

CURRENCY_UNIT, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-whitelistforcerelay", strprintf("Add 'forcerelay' permission to whitelisted inbound peers with default permissions. This will relay transactions even if the transactions were already in the mempool or violate local relay policy. (default: %d)", DEFAULT_WHITELISTFORCERELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-whitelistrelay", strprintf("Add 'relay' permission to whitelisted inbound peers with default permissions. The will accept relayed transactions even when not relaying transactions (default: %d)", DEFAULT_WHITELISTRELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

gArgs.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);

gArgs.AddArg("-blockmintxfee=<amt>", strprintf("Set lowest fee rate (in %s/kB) for transactions to be included in block creation. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);

gArgs.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);

gArgs.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcallowip=<ip>", "Allow JSON-RPC connections from specified source. Valid for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcauth=<userpw>", "Username and HMAC-SHA-256 hashed password for JSON-RPC connections. The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A canonical python script is included in share/rpcauth. The client then connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> pair of arguments. This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcbind=<addr>[:port]", "Bind to given address to listen for JSON-RPC connections. Do not expose the RPC server to untrusted networks such as the public internet! This option is ignored unless -rpcallowip is also passed. Port is optional and overrides -rpcport. Use [host]:port notation for IPv6. This option can be specified multiple times (default: 127.0.0.1 and ::1 i.e., localhost)", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC);

gArgs.AddArg("-rpccookiefile=<loc>", "Location of the auth cookie. Relative paths will be prefixed by a net-specific datadir location. (default: data dir)", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcport=<port>", strprintf("Listen for JSON-RPC connections on <port> (default: %u, testnet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), regtestBaseParams->RPCPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC);

gArgs.AddArg("-rpcserialversion", strprintf("Sets the serialization of raw transaction or block hex returned in non-verbose mode, non-segwit(0) or segwit(1) (default: %d)", DEFAULT_RPC_SERIALIZE_VERSION), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);

gArgs.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

gArgs.AddArg("-rpcworkqueue=<n>", strprintf("Set the depth of the work queue to service RPC calls (default: %d)", DEFAULT_HTTP_WORKQUEUE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);

gArgs.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

#if HAVE_DECL_DAEMON

gArgs.AddArg("-daemon", "Run in the background as a daemon and accept commands", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

#else

hidden_args.emplace_back("-daemon");

#endif

// Add the hidden options

gArgs.AddHiddenArgs(hidden_args);

{

const std::string URL_SOURCE_CODE = "<https://github.com/bitcoin/bitcoin>";

const std::string URL_WEBSITE = "<https://bitcoincore.org>";

return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009, COPYRIGHT_YEAR) + " ") + "\n" +

"\n" +

strprintf(_("Please contribute if you find %s useful. "

"Visit %s for further information about the software.").translated,

PACKAGE_NAME, URL_WEBSITE) +

"\n" +

strprintf(_("The source code is available from %s.").translated,

URL_SOURCE_CODE) +

"\n" +

"\n" +

_("This is experimental software.").translated + "\n" +

strprintf(_("Distributed under the MIT software license, see the accompanying file %s or %s").translated, "COPYING", "<https://opensource.org/licenses/MIT>") + "\n" +

"\n" +

strprintf(_("This product includes software developed by the OpenSSL Project for use in the OpenSSL Toolkit %s and cryptographic software written by Eric Young and UPnP software written by Thomas Bernard.").translated, "<https://www.openssl.org>") +

"\n";

{

if (initialSync || !pBlockIndex)

return;

std::string strCmd = gArgs.GetArg("-blocknotify", "");

if (!strCmd.empty()) {

boost::replace_all(strCmd, "%s", pBlockIndex->GetBlockHash().GetHex());

std::thread t(runCommand, strCmd);

t.detach(); // thread runs free

}

{

if (pBlockIndex != nullptr) {

{

LOCK(g_genesis_wait_mutex);

fHaveGenesis = true;

}

g_genesis_wait_cv.notify_all();

}

{

CImportingNow() {

assert(fImporting == false);

fImporting = true;

}

~CImportingNow() {

assert(fImporting == true);

fImporting = false;

}

{

std::map<std::string, fs::path> mapBlockFiles;

// Glob all blk?????.dat and rev?????.dat files from the blocks directory.

// Remove the rev files immediately and insert the blk file paths into an

// ordered map keyed by block file index.

LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for -reindex with -prune\n");

fs::path blocksdir = GetBlocksDir();

for (fs::directory_iterator it(blocksdir); it != fs::directory_iterator(); it++) {

if (fs::is_regular_file(*it) &&

it->path().filename().string().length() == 12 &&

it->path().filename().string().substr(8,4) == ".dat")

{

if (it->path().filename().string().substr(0,3) == "blk")

mapBlockFiles[it->path().filename().string().substr(3,5)] = it->path();

else if (it->path().filename().string().substr(0,3) == "rev")

remove(it->path());

}

}

// Remove all block files that aren't part of a contiguous set starting at

// zero by walking the ordered map (keys are block file indices) by

// keeping a separate counter. Once we hit a gap (or if 0 doesn't exist)

// start removing block files.

int nContigCounter = 0;

for (const std::pair<const std::string, fs::path>& item : mapBlockFiles) {

if (atoi(item.first) == nContigCounter) {

nContigCounter++;

continue;

}

remove(item.second);

}

{

const CChainParams& chainparams = Params();

util::ThreadRename("loadblk");

ScheduleBatchPriority();

{

CImportingNow imp;

// -reindex

if (fReindex) {

int nFile = 0;

while (true) {

FlatFilePos pos(nFile, 0);

if (!fs::exists(GetBlockPosFilename(pos)))

break; // No block files left to reindex

FILE *file = OpenBlockFile(pos, true);

if (!file)

break; // This error is logged in OpenBlockFile

LogPrintf("Reindexing block file blk%05u.dat...\n", (unsigned int)nFile);

LoadExternalBlockFile(chainparams, file, &pos);

nFile++;

}

pblocktree->WriteReindexing(false);

fReindex = false;

LogPrintf("Reindexing finished\n");

// To avoid ending up in a situation without genesis block, re-try initializing (no-op if reindexing worked):

LoadGenesisBlock(chainparams);

}

// hardcoded $DATADIR/bootstrap.dat

fs::path pathBootstrap = GetDataDir() / "bootstrap.dat";

if (fs::exists(pathBootstrap)) {

FILE *file = fsbridge::fopen(pathBootstrap, "rb");

if (file) {

fs::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";

LogPrintf("Importing bootstrap.dat...\n");

LoadExternalBlockFile(chainparams, file);

RenameOver(pathBootstrap, pathBootstrapOld);

} else {

LogPrintf("Warning: Could not open bootstrap file %s\n", pathBootstrap.string());

}

}

// -loadblock=

for (const fs::path& path : vImportFiles) {

FILE *file = fsbridge::fopen(path, "rb");

if (file) {

LogPrintf("Importing blocks file %s...\n", path.string());

LoadExternalBlockFile(chainparams, file);

} else {

LogPrintf("Warning: Could not open blocks file %s\n", path.string());

}

}

// scan for better chains in the block chain database, that are not yet connected in the active best chain

CValidationState state;

if (!ActivateBestChain(state, chainparams)) {

LogPrintf("Failed to connect best block (%s)\n", FormatStateMessage(state));

StartShutdown();

return;

}

if (gArgs.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) {

LogPrintf("Stopping after block import\n");

StartShutdown();

return;

}

} // End scope of CImportingNow

if (gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {

LoadMempool(::mempool);

}

::mempool.SetIsLoaded(!ShutdownRequested());

{

if(!ECC_InitSanityCheck()) {

InitError("Elliptic curve cryptography sanity check failure. Aborting.");

return false;

}

if (!glibc_sanity_test() || !glibcxx_sanity_test())

return false;

if (!Random_SanityCheck()) {

InitError("OS cryptographic RNG sanity check failure. Aborting.");

return false;

}

return true;

{

RPCServer::OnStarted(&OnRPCStarted);

RPCServer::OnStopped(&OnRPCStopped);

if (!InitHTTPServer())

return false;

StartRPC();

if (!StartHTTPRPC())

return false;

if (gArgs.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) StartREST();

StartHTTPServer();

return true;

{

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

// even when -connect or -proxy is specified

if (gArgs.IsArgSet("-bind")) {

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

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

}

if (gArgs.IsArgSet("-whitebind")) {

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

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

}

if (gArgs.IsArgSet("-connect")) {

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

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

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

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

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

}

if (gArgs.IsArgSet("-proxy")) {

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

if (gArgs.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 (gArgs.SoftSetBoolArg("-upnp", false))

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

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

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

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

}

if (!gArgs.GetBoolArg("-listen", DEFAULT_LISTEN)) {

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

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

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

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

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

if (gArgs.SoftSetBoolArg("-listenonion", false))

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

}

if (gArgs.IsArgSet("-externalip")) {

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

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

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

}

// disable whitelistrelay in blocksonly mode

if (gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {

if (gArgs.SoftSetBoolArg("-whitelistrelay", false))

LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n", __func__);

}

// Forcing relay from whitelisted hosts implies we will accept relays from them in the first place.

if (gArgs.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {

if (gArgs.SoftSetBoolArg("-whitelistrelay", true))

LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n", __func__);

}

{

LogInstance().m_print_to_file = !gArgs.IsArgNegated("-debuglogfile");

LogInstance().m_file_path = AbsPathForConfigVal(gArgs.GetArg("-debuglogfile", DEFAULT_DEBUGLOGFILE));

LogInstance().m_print_to_console = gArgs.GetBoolArg("-printtoconsole", !gArgs.GetBoolArg("-daemon", false));

LogInstance().m_log_timestamps = gArgs.GetBoolArg("-logtimestamps", DEFAULT_LOGTIMESTAMPS);

LogInstance().m_log_time_micros = gArgs.GetBoolArg("-logtimemicros", DEFAULT_LOGTIMEMICROS);

LogInstance().m_log_threadnames = gArgs.GetBoolArg("-logthreadnames", DEFAULT_LOGTHREADNAMES);

fLogIPs = gArgs.GetBoolArg("-logips", DEFAULT_LOGIPS);

std::string version_string = FormatFullVersion();

#ifdef DEBUG

version_string += " (debug build)";

#else

version_string += " (release build)";

#endif

LogPrintf(PACKAGE_NAME " version %s\n", version_string);

{

// Rather than throwing std::bad-alloc if allocation fails, terminate

// immediately to (try to) avoid chain corruption.

// Since LogPrintf may itself allocate memory, set the handler directly

// to terminate first.

std::set_new_handler(std::terminate);

LogPrintf("Error: Out of memory. Terminating.\n");

// The log was successful, terminate now.

std::terminate();

{

// ********************************************************* 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, nullptr, OPEN_EXISTING, 0, 0));

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

SetProcessDEPPolicy(PROCESS_DEP_ENABLE);

#endif

if (!SetupNetworking())

return InitError("Initializing networking failed");

#ifndef WIN32

if (!gArgs.GetBoolArg("-sysperms", false)) {

umask(077);

}

// Clean shutdown on SIGTERM

registerSignalHandler(SIGTERM, HandleSIGTERM);

registerSignalHandler(SIGINT, HandleSIGTERM);

// Reopen debug.log on SIGHUP

registerSignalHandler(SIGHUP, HandleSIGHUP);

// Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly

signal(SIGPIPE, SIG_IGN);

#else

SetConsoleCtrlHandler(consoleCtrlHandler, true);

#endif

std::set_new_handler(new_handler_terminate);

return true;

{

const CChainParams& chainparams = Params();

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

// also see: InitParameterInteraction()

// Warn if network-specific options (-addnode, -connect, etc) are

// specified in default section of config file, but not overridden

// on the command line or in this network's section of the config file.

std::string network = gArgs.GetChainName();

for (const auto& arg : gArgs.GetUnsuitableSectionOnlyArgs()) {

return InitError(strprintf(_("Config setting for %s only applied on %s network when in [%s] section.").translated, arg, network, network));

}

// Warn if unrecognized section name are present in the config file.

for (const auto& section : gArgs.GetUnrecognizedSections()) {

InitWarning(strprintf("%s:%i " + _("Section [%s] is not recognized.").translated, section.m_file, section.m_line, section.m_name));

}

if (!fs::is_directory(GetBlocksDir())) {

return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist.").translated, gArgs.GetArg("-blocksdir", "").c_str()));

}

// parse and validate enabled filter types

std::string blockfilterindex_value = gArgs.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);

if (blockfilterindex_value == "" || blockfilterindex_value == "1") {

g_enabled_filter_types = AllBlockFilterTypes();

} else if (blockfilterindex_value != "0") {

const std::vector<std::string> names = gArgs.GetArgs("-blockfilterindex");

for (const auto& name : names) {

BlockFilterType filter_type;

if (!BlockFilterTypeByName(name, filter_type)) {

return InitError(strprintf(_("Unknown -blockfilterindex value %s.").translated, name));

}

g_enabled_filter_types.insert(filter_type);

}

}

// if using block pruning, then disallow txindex

if (gArgs.GetArg("-prune", 0)) {

if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX))

return InitError(_("Prune mode is incompatible with -txindex.").translated);

if (!g_enabled_filter_types.empty()) {

return InitError(_("Prune mode is incompatible with -blockfilterindex.").translated);

}

}

// -bind and -whitebind can't be set when not listening

size_t nUserBind = gArgs.GetArgs("-bind").size() + gArgs.GetArgs("-whitebind").size();

if (nUserBind != 0 && !gArgs.GetBoolArg("-listen", DEFAULT_LISTEN)) {

return InitError("Cannot set -bind or -whitebind together with -listen=0");

}

// Make sure enough file descriptors are available

int nBind = std::max(nUserBind, size_t(1));

nUserMaxConnections = gArgs.GetArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);

nMaxConnections = std::max(nUserMaxConnections, 0);

// Trim requested connection counts, to fit into system limitations

// <int> in std::min<int>(...) to work around FreeBSD compilation issue described in #2695

nFD = RaiseFileDescriptorLimit(nMaxConnections + MIN_CORE_FILEDESCRIPTORS + MAX_ADDNODE_CONNECTIONS);

#ifdef USE_POLL

int fd_max = nFD;

#else

int fd_max = FD_SETSIZE;

#endif

nMaxConnections = std::max(std::min<int>(nMaxConnections, fd_max - nBind - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS), 0);

if (nFD < MIN_CORE_FILEDESCRIPTORS)

return InitError(_("Not enough file descriptors available.").translated);