1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-present The Bitcoin Core developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 6 #include <bitcoin-build-config.h> // IWYU pragma: keep
7 8 #include <init.h>
9 10 #include <addrdb.h>
11 #include <addrman.h>
12 #include <banman.h>
13 #include <blockfilter.h>
14 #include <chain.h>
15 #include <chainparams.h>
16 #include <chainparamsbase.h>
17 #include <clientversion.h>
18 #include <common/args.h>
19 #include <common/messages.h>
20 #include <common/system.h>
21 #include <compat/compat.h>
22 #include <consensus/params.h>
23 #include <crypto/hex_base.h>
24 #include <dbwrapper.h>
25 #include <httprpc.h>
26 #include <httpserver.h>
27 #include <index/base.h>
28 #include <index/blockfilterindex.h>
29 #include <index/coinstatsindex.h>
30 #include <index/txindex.h>
31 #include <index/txospenderindex.h>
32 #include <init/common.h>
33 #include <interfaces/chain.h>
34 #include <interfaces/init.h>
35 #include <interfaces/ipc.h>
36 #include <interfaces/mining.h>
37 #include <interfaces/node.h>
38 #include <ipc/exception.h>
39 #include <kernel/blockmanager_opts.h>
40 #include <kernel/caches.h>
41 #include <kernel/chainstatemanager_opts.h>
42 #include <kernel/checks.h>
43 #include <kernel/context.h>
44 #include <kernel/notifications_interface.h>
45 #include <key.h>
46 #include <logging.h>
47 #include <mapport.h>
48 #include <net.h>
49 #include <net_permissions.h>
50 #include <net_processing.h>
51 #include <netaddress.h>
52 #include <netbase.h>
53 #include <netgroup.h>
54 #include <node/blockmanager_args.h>
55 #include <node/blockstorage.h>
56 #include <node/caches.h>
57 #include <node/chainstate.h>
58 #include <node/chainstatemanager_args.h>
59 #include <node/context.h>
60 #include <node/interface_ui.h>
61 #include <node/kernel_notifications.h>
62 #include <node/mempool_args.h>
63 #include <node/mempool_persist.h>
64 #include <node/mempool_persist_args.h>
65 #include <node/mining_args.h>
66 #include <node/mining_types.h>
67 #include <node/peerman_args.h>
68 #include <policy/feerate.h>
69 #include <policy/fees/block_policy_estimator.h>
70 #include <policy/fees/block_policy_estimator_args.h>
71 #include <policy/policy.h>
72 #include <policy/settings.h>
73 #include <protocol.h>
74 #include <random.h>
75 #include <rpc/register.h>
76 #include <rpc/server.h>
77 #include <rpc/util.h>
78 #include <scheduler.h>
79 #include <script/sigcache.h>
80 #include <sync.h>
81 #include <tinyformat.h>
82 #include <torcontrol.h>
83 #include <txgraph.h>
84 #include <txmempool.h>
85 #include <uint256.h>
86 #include <util/asmap.h>
87 #include <util/batchpriority.h>
88 #include <util/btcsignals.h>
89 #include <util/chaintype.h>
90 #include <util/check.h>
91 #include <util/fs.h>
92 #include <util/fs_helpers.h>
93 #include <util/moneystr.h>
94 #include <util/result.h>
95 #include <util/signalinterrupt.h>
96 #include <util/strencodings.h>
97 #include <util/string.h>
98 #include <util/syserror.h>
99 #include <util/thread.h>
100 #include <util/threadnames.h>
101 #include <util/time.h>
102 #include <util/translation.h>
103 #include <validation.h>
104 #include <validationinterface.h>
105 #include <walletinitinterface.h>
106 107 #include <algorithm>
108 #include <any>
109 #include <cerrno>
110 #include <condition_variable>
111 #include <cstddef>
112 #include <cstdint>
113 #include <exception>
114 #include <fstream>
115 #include <functional>
116 #include <initializer_list>
117 #include <list>
118 #include <memory>
119 #include <new>
120 #include <optional>
121 #include <set>
122 #include <span>
123 #include <string>
124 #include <system_error>
125 #include <thread>
126 #include <tuple>
127 #include <utility>
128 #include <variant>
129 #include <vector>
130 131 #ifndef WIN32
132 #include <csignal>
133 #endif
134 135 #ifdef ENABLE_ZMQ
136 #include <zmq/zmqabstractnotifier.h>
137 #include <zmq/zmqnotificationinterface.h>
138 #include <zmq/zmqrpc.h>
139 #endif
140 141 #ifdef ENABLE_EMBEDDED_ASMAP
142 #include <node/data/ip_asn.dat.h>
143 #endif
144 145 using common::InvalidPortErrMsg;
146 using common::ResolveErrMsg;
147 148 using http_bitcoin::InitHTTPServer;
149 using http_bitcoin::InterruptHTTPServer;
150 using http_bitcoin::StartHTTPServer;
151 using http_bitcoin::StopHTTPServer;
152 using node::ApplyArgsManOptions;
153 using node::BlockManager;
154 using node::CalculateCacheSizes;
155 using node::ChainstateLoadResult;
156 using node::ChainstateLoadStatus;
157 using node::DEFAULT_PERSIST_MEMPOOL;
158 using node::DEFAULT_PRINT_MODIFIED_FEE;
159 using node::DEFAULT_STOPATHEIGHT;
160 using node::DumpMempool;
161 using node::ImportBlocks;
162 using node::KernelNotifications;
163 using node::LoadChainstate;
164 using node::LoadMempool;
165 using node::MempoolPath;
166 using node::NodeContext;
167 using node::ShouldPersistMempool;
168 using node::VerifyLoadedChainstate;
169 using util::Join;
170 using util::ReplaceAll;
171 using util::ToString;
172 173 static constexpr bool DEFAULT_PROXYRANDOMIZE{true};
174 static constexpr bool DEFAULT_REST_ENABLE{false};
175 static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING{true};
176 static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT{false};
177 178 #ifdef WIN32
179 // Win32 LevelDB doesn't use filedescriptors, and the ones used for
180 // accessing block files don't count towards the fd_set size limit
181 // anyway.
182 #define MIN_LEVELDB_FDS 0
183 #else
184 #define MIN_LEVELDB_FDS 150
185 #endif
186 187 static constexpr int MIN_CORE_FDS = MIN_LEVELDB_FDS + NUM_FDS_MESSAGE_CAPTURE;
188 189 /**
190 * The PID file facilities.
191 */
192 static const char* BITCOIN_PID_FILENAME = "bitcoind.pid";
193 /**
194 * True if this process has created a PID file.
195 * Used to determine whether we should remove the PID file on shutdown.
196 */
197 static bool g_generated_pid{false};
198 199 static fs::path GetPidFile(const ArgsManager& args)
200 {
201 return AbsPathForConfigVal(args, args.GetPathArg("-pid", BITCOIN_PID_FILENAME));
202 }
203 204 [[nodiscard]] static bool CreatePidFile(const ArgsManager& args)
205 {
206 if (args.IsArgNegated("-pid")) return true;
207 208 std::ofstream file{GetPidFile(args).std_path()};
209 if (file) {
210 #ifdef WIN32
211 tfm::format(file, "%d\n", GetCurrentProcessId());
212 #else
213 tfm::format(file, "%d\n", getpid());
214 #endif
215 g_generated_pid = true;
216 return true;
217 } else {
218 return InitError(strprintf(_("Unable to create the PID file '%s': %s"), fs::PathToString(GetPidFile(args)), SysErrorString(errno)));
219 }
220 }
221 222 static void RemovePidFile(const ArgsManager& args)
223 {
224 if (!g_generated_pid) return;
225 const auto pid_path{GetPidFile(args)};
226 if (std::error_code error; !fs::remove(pid_path, error)) {
227 std::string msg{error ? error.message() : "File does not exist"};
228 LogWarning("Unable to remove PID file (%s): %s", fs::PathToString(pid_path), msg);
229 }
230 }
231 232 static std::optional<util::SignalInterrupt> g_shutdown;
233 234 void InitContext(NodeContext& node)
235 {
236 assert(!g_shutdown);
237 g_shutdown.emplace();
238 239 node.args = &gArgs;
240 node.shutdown_signal = &*g_shutdown;
241 node.shutdown_request = [&node] {
242 assert(node.shutdown_signal);
243 if (!(*node.shutdown_signal)()) return false;
244 return true;
245 };
246 }
247 248 //////////////////////////////////////////////////////////////////////////////
249 //
250 // Shutdown
251 //
252 253 //
254 // Thread management and startup/shutdown:
255 //
256 // The network-processing threads are all part of a thread group
257 // created by AppInit() or the Qt main() function.
258 //
259 // A clean exit happens when the SignalInterrupt object is triggered, which
260 // makes the main thread's SignalInterrupt::wait() call return, and join all
261 // other ongoing threads in the thread group to the main thread.
262 // Shutdown() is then called to clean up database connections, and stop other
263 // threads that should only be stopped after the main network-processing
264 // threads have exited.
265 //
266 // Shutdown for Qt is very similar, only it uses a QTimer to detect
267 // ShutdownRequested() getting set, and then does the normal Qt
268 // shutdown thing.
269 //
270 271 bool ShutdownRequested(node::NodeContext& node)
272 {
273 return bool{*Assert(node.shutdown_signal)};
274 }
275 276 #if HAVE_SYSTEM
277 static void ShutdownNotify(const ArgsManager& args)
278 {
279 std::vector<std::thread> threads;
280 for (const auto& cmd : args.GetArgs("-shutdownnotify")) {
281 threads.emplace_back(runCommand, cmd);
282 }
283 for (auto& t : threads) {
284 t.join();
285 }
286 }
287 #endif
288 289 void Interrupt(NodeContext& node)
290 {
291 #if HAVE_SYSTEM
292 ShutdownNotify(*node.args);
293 #endif
294 // Wake any threads that may be waiting for the tip to change.
295 if (node.notifications) WITH_LOCK(node.notifications->m_tip_block_mutex, node.notifications->m_tip_block_cv.notify_all());
296 InterruptHTTPServer();
297 InterruptHTTPRPC();
298 InterruptRPC();
299 InterruptREST();
300 if (node.tor_controller) {
301 node.tor_controller->Interrupt();
302 }
303 InterruptMapPort();
304 if (node.connman)
305 node.connman->Interrupt();
306 for (auto* index : node.indexes) {
307 index->Interrupt();
308 }
309 }
310 311 void Shutdown(NodeContext& node)
312 {
313 static Mutex g_shutdown_mutex;
314 TRY_LOCK(g_shutdown_mutex, lock_shutdown);
315 if (!lock_shutdown) return;
316 LogInfo("Shutdown in progress...");
317 Assert(node.args);
318 319 /// Note: Shutdown() must be able to handle cases in which initialization failed part of the way,
320 /// for example if the data directory was found to be locked.
321 /// Be sure that anything that writes files or flushes caches only does this if the respective
322 /// module was initialized.
323 util::ThreadRename("shutoff");
324 if (node.mempool) node.mempool->AddTransactionsUpdated(1);
325 326 StopHTTPRPC();
327 StopREST();
328 StopRPC();
329 StopHTTPServer();
330 for (auto& client : node.chain_clients) {
331 try {
332 client->stop();
333 } catch (const ipc::Exception& e) {
334 LogDebug(BCLog::IPC, "Chain client did not disconnect cleanly: %s", e.what());
335 client.reset();
336 }
337 }
338 StopMapPort();
339 340 // Because these depend on each-other, we make sure that neither can be
341 // using the other before destroying them.
342 if (node.peerman && node.validation_signals) node.validation_signals->UnregisterValidationInterface(node.peerman.get());
343 if (node.connman) node.connman->Stop();
344 345 if (node.tor_controller) {
346 node.tor_controller->Join();
347 node.tor_controller.reset();
348 }
349 350 if (node.background_init_thread.joinable()) node.background_init_thread.join();
351 // After everything has been shut down, but before things get flushed, stop the
352 // the scheduler. After this point, SyncWithValidationInterfaceQueue() should not be called anymore
353 // as this would prevent the shutdown from completing.
354 if (node.scheduler) node.scheduler->stop();
355 356 // After the threads that potentially access these pointers have been stopped,
357 // destruct and reset all to nullptr.
358 node.peerman.reset();
359 node.connman.reset();
360 node.banman.reset();
361 node.addrman.reset();
362 node.netgroupman.reset();
363 364 if (node.mempool && node.mempool->GetLoadTried() && ShouldPersistMempool(*node.args)) {
365 DumpMempool(*node.mempool, MempoolPath(*node.args));
366 }
367 368 // Drop transactions we were still watching, record fee estimations and unregister
369 // fee estimator from validation interface.
370 if (node.fee_estimator) {
371 node.fee_estimator->Flush();
372 if (node.validation_signals) {
373 node.validation_signals->UnregisterValidationInterface(node.fee_estimator.get());
374 }
375 }
376 377 // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
378 if (node.chainman) {
379 LOCK(cs_main);
380 for (const auto& chainstate : node.chainman->m_chainstates) {
381 if (chainstate->CanFlushToDisk()) {
382 chainstate->ForceFlushStateToDisk();
383 }
384 }
385 }
386 387 // After there are no more peers/RPC left to give us new data which may generate
388 // CValidationInterface callbacks, flush them...
389 if (node.validation_signals) node.validation_signals->FlushBackgroundCallbacks();
390 391 // Stop and delete all indexes only after flushing background callbacks.
392 for (auto* index : node.indexes) index->Stop();
393 if (g_txindex) g_txindex.reset();
394 if (g_txospenderindex) g_txospenderindex.reset();
395 if (g_coin_stats_index) g_coin_stats_index.reset();
396 DestroyAllBlockFilterIndexes();
397 node.indexes.clear(); // all instances are nullptr now
398 399 // Any future callbacks will be dropped. This should absolutely be safe - if
400 // missing a callback results in an unrecoverable situation, unclean shutdown
401 // would too. The only reason to do the above flushes is to let the wallet catch
402 // up with our current chain to avoid any strange pruning edge cases and make
403 // next startup faster by avoiding rescan.
404 405 if (node.chainman) {
406 LOCK(cs_main);
407 for (const auto& chainstate : node.chainman->m_chainstates) {
408 if (chainstate->CanFlushToDisk()) {
409 chainstate->ForceFlushStateToDisk();
410 chainstate->ResetCoinsViews();
411 }
412 }
413 }
414 415 // If any -ipcbind clients are still connected, disconnect them now so they
416 // do not block shutdown.
417 if (interfaces::Ipc* ipc = node.init->ipc()) {
418 ipc->disconnectIncoming();
419 }
420 421 #ifdef ENABLE_ZMQ
422 if (g_zmq_notification_interface) {
423 if (node.validation_signals) node.validation_signals->UnregisterValidationInterface(g_zmq_notification_interface.get());
424 g_zmq_notification_interface.reset();
425 }
426 #endif
427 428 node.chain_clients.clear();
429 if (node.validation_signals) {
430 node.validation_signals->UnregisterAllValidationInterfaces();
431 }
432 node.mempool.reset();
433 node.fee_estimator.reset();
434 node.chainman.reset();
435 node.validation_signals.reset();
436 node.scheduler.reset();
437 node.ecc_context.reset();
438 node.kernel.reset();
439 440 RemovePidFile(*node.args);
441 442 LogInfo("Shutdown done");
443 }
444 445 /**
446 * Signal handlers are very limited in what they are allowed to do.
447 * The execution context the handler is invoked in is not guaranteed,
448 * so we restrict handler operations to just touching variables:
449 */
450 #ifndef WIN32
451 static void HandleSIGTERM(int)
452 {
453 // Return value is intentionally ignored because there is not a better way
454 // of handling this failure in a signal handler.
455 (void)(*Assert(g_shutdown))();
456 }
457 458 static void HandleSIGHUP(int)
459 {
460 LogInstance().m_reopen_file = true;
461 }
462 #else
463 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
464 {
465 if (!(*Assert(g_shutdown))()) {
466 LogError("Failed to send shutdown signal on Ctrl-C\n");
467 return false;
468 }
469 Sleep(INFINITE);
470 return true;
471 }
472 #endif
473 474 #ifndef WIN32
475 static void registerSignalHandler(int signal, void(*handler)(int))
476 {
477 struct sigaction sa;
478 sa.sa_handler = handler;
479 sigemptyset(&sa.sa_mask);
480 sa.sa_flags = 0;
481 sigaction(signal, &sa, nullptr);
482 }
483 #endif
484 485 void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
486 {
487 SetupHelpOptions(argsman);
488 argsman.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now
489 490 init::AddLoggingArgs(argsman);
491 492 const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN);
493 const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
494 const auto testnet4BaseParams = CreateBaseChainParams(ChainType::TESTNET4);
495 const auto signetBaseParams = CreateBaseChainParams(ChainType::SIGNET);
496 const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
497 const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN);
498 const auto testnetChainParams = CreateChainParams(argsman, ChainType::TESTNET);
499 const auto testnet4ChainParams = CreateChainParams(argsman, ChainType::TESTNET4);
500 const auto signetChainParams = CreateChainParams(argsman, ChainType::SIGNET);
501 const auto regtestChainParams = CreateChainParams(argsman, ChainType::REGTEST);
502 503 // Hidden Options
504 std::vector<std::string> hidden_args = {
505 "-dbcrashratio", "-forcecompactdb",
506 // GUI args. These will be overwritten by SetupUIArgs for the GUI
507 "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-splash", "-uiplatform"};
508 509 argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
510 #if HAVE_SYSTEM
511 argsman.AddArg("-alertnotify=<cmd>", "Execute command when an alert is raised (%s in cmd is replaced by message)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
512 #endif
513 argsman.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, testnet3: %s, testnet4: %s, signet: %s)", defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnetChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnet4ChainParams->GetConsensus().defaultAssumeValid.GetHex(), signetChainParams->GetConsensus().defaultAssumeValid.GetHex()), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
514 argsman.AddArg("-blocksdir=<dir>", "Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
515 argsman.AddArg("-blocksxor",
516 strprintf("Whether an XOR-key applies to blocksdir *.dat files. "
517 "The created XOR-key will be zeros for an existing blocksdir or when `-blocksxor=0` is "
518 "set, and random for a freshly initialized blocksdir. "
519 "(default: %u)",
520 kernel::DEFAULT_XOR_BLOCKSDIR),
521 ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
522 argsman.AddArg("-fastprune", "Use smaller block files and lower minimum prune height for testing purposes", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
523 #if HAVE_SYSTEM
524 argsman.AddArg("-blocknotify=<cmd>", "Execute command when the best block changes (%s in cmd is replaced by block hash)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
525 #endif
526 argsman.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);
527 argsman.AddArg("-blocksonly", strprintf("Whether to reject transactions from network peers. Disables automatic broadcast and rebroadcast of transactions, unless the source peer has the 'forcerelay' permission. RPC transactions are not affected. (default: %u)", DEFAULT_BLOCKSONLY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
528 argsman.AddArg("-coinstatsindex", strprintf("Maintain coinstats index used by the gettxoutsetinfo RPC (default: %u)", DEFAULT_COINSTATSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
529 argsman.AddArg("-conf=<file>", strprintf("Specify path to read-only configuration file. Relative paths will be prefixed by datadir location (only useable from command line, not configuration file) (default: %s)", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
530 argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
531 argsman.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", DEFAULT_DB_CACHE_BATCH), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
532 argsman.AddArg("-dbcache=<n>", strprintf("Maximum database cache size <n> MiB (minimum %d, default: %d). Make sure you have enough RAM. In addition, unused memory allocated to the mempool is shared with this cache (see -maxmempool).", MIN_DB_CACHE >> 20, node::GetDefaultDBCache() >> 20), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
533 argsman.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);
534 argsman.AddArg("-allowignoredconf", strprintf("For backwards compatibility, treat an unused %s file in the datadir as a warning, not an error.", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
535 argsman.AddArg("-loadblock=<file>", "Imports blocks from an external file on startup. Obfuscated blocks are not supported.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
536 argsman.AddArg("-maxmempool=<n>", strprintf("Keep the transaction memory pool below <n> megabytes (default: %u)", DEFAULT_MAX_MEMPOOL_SIZE_MB), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
537 argsman.AddArg("-mempoolexpiry=<n>", strprintf("Do not keep transactions in the mempool longer than <n> hours (default: %u)", DEFAULT_MEMPOOL_EXPIRY_HOURS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
538 argsman.AddArg("-minimumchainwork=<hex>", strprintf("Minimum work assumed to exist on a valid chain in hex (default: %s, testnet3: %s, testnet4: %s, signet: %s)", defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnetChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnet4ChainParams->GetConsensus().nMinimumChainWork.GetHex(), signetChainParams->GetConsensus().nMinimumChainWork.GetHex()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
539 argsman.AddArg("-par=<n>", strprintf("Set the number of script verification threads (0 = auto, up to %d, <0 = leave that many cores free, default: %d)",
540 MAX_SCRIPTCHECK_THREADS, DEFAULT_SCRIPTCHECK_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
541 argsman.AddArg("-prevoutfetchthreads=<n>", strprintf("Set the number of threads used to prefetch block input prevouts from the chainstate database (0 disables, up to %d, default: %d). Negative values are rejected.", MAX_PREVOUTFETCH_THREADS, DEFAULT_PREVOUTFETCH_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
542 argsman.AddArg("-persistmempool", strprintf("Whether to save the mempool on shutdown and load on restart (default: %u)", DEFAULT_PERSIST_MEMPOOL), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
543 argsman.AddArg("-persistmempoolv1",
544 strprintf("Whether a mempool.dat file created by -persistmempool or the savemempool RPC will be written in the legacy format "
545 "(version 1) or the current format (version 2). This temporary option will be removed in the future. (default: %u)",
546 DEFAULT_PERSIST_V1_DAT),
547 ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
548 argsman.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);
549 argsman.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. "
550 "Warning: Reverting this setting requires re-downloading the entire blockchain. "
551 "(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 / 1_MiB), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
552 argsman.AddArg("-reindex", "If enabled, wipe chain state and block index, and rebuild them from blk*.dat files on disk. Also wipe and rebuild other optional indexes that are active. If an assumeutxo snapshot was loaded, its chainstate will be wiped as well. The snapshot can then be reloaded via RPC.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
553 argsman.AddArg("-reindex-chainstate", "If enabled, wipe chain state, and rebuild it from blk*.dat files on disk. If an assumeutxo snapshot was loaded, its chainstate will be wiped as well. The snapshot can then be reloaded via RPC.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
554 argsman.AddArg("-settings=<file>", strprintf("Specify path to dynamic settings data file. Can be disabled with -nosettings. File is written at runtime and not meant to be edited by users (use %s instead for custom settings). Relative paths will be prefixed by datadir location. (default: %s)", BITCOIN_CONF_FILENAME, BITCOIN_SETTINGS_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
555 #if HAVE_SYSTEM
556 argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
557 argsman.AddArg("-shutdownnotify=<cmd>", "Execute command immediately before beginning shutdown. The need for shutdown may be urgent, so be careful not to delay it long (if the command doesn't require interaction with the server, consider having it fork into the background).", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
558 #endif
559 argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
560 argsman.AddArg("-txospenderindex", strprintf("Maintain a transaction output spender index, used by the gettxspendingprevout rpc call (default: %u)", DEFAULT_TXOSPENDERINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
561 argsman.AddArg("-blockfilterindex=<type>",
562 strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
563 " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
564 ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
565 566 argsman.AddArg("-addnode=<ip>", strprintf("Add a node to connect to and attempt to keep the connection open (see the addnode RPC help for more info). This option can be specified multiple times to add multiple nodes; connections are limited to %u at a time and are counted separately from the -maxconnections limit.", MAX_ADDNODE_CONNECTIONS), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
567 argsman.AddArg("-asmap=<file>", strprintf("Specify asn mapping used for bucketing of the peers. Relative paths will be prefixed by the net-specific datadir location.%s",
568 #ifdef ENABLE_EMBEDDED_ASMAP
569 " If a bool arg is given (-asmap or -asmap=1), the embedded mapping data in the binary will be used."
570 #else
571 ""
572 #endif
573 ), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
574 argsman.AddArg("-bantime=<n>", strprintf("Default duration (in seconds) of manually configured bans (default: %u)", DEFAULT_MISBEHAVING_BANTIME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
575 argsman.AddArg("-bind=<addr>[:<port>][=onion]", strprintf("Bind to given address and always listen on it (default: 0.0.0.0). Use [host]:port notation for IPv6. Append =onion to tag any incoming connections to that address and port as incoming Tor connections (default: 127.0.0.1:%u=onion, testnet3: 127.0.0.1:%u=onion, testnet4: 127.0.0.1:%u=onion, signet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)", defaultChainParams->GetDefaultPort() + 1, testnetChainParams->GetDefaultPort() + 1, testnet4ChainParams->GetDefaultPort() + 1, signetChainParams->GetDefaultPort() + 1, regtestChainParams->GetDefaultPort() + 1), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
576 argsman.AddArg("-cjdnsreachable", "If set, then this host is configured for CJDNS (connecting to fc00::/8 addresses would lead us to the CJDNS network, see doc/cjdns.md) (default: 0)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
577 argsman.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);
578 argsman.AddArg("-discover", "Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
579 argsman.AddArg("-dns", strprintf("Allow DNS lookups for -addnode, -seednode and -connect (default: %u)", DEFAULT_NAME_LOOKUP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
580 argsman.AddArg("-dnsseed", strprintf("Query for peer addresses via DNS lookup, if low on addresses (default: %u unless -connect used or -maxconnections=0)", DEFAULT_DNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
581 argsman.AddArg("-externalip=<ip>", "Specify your own public address", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
582 argsman.AddArg("-fixedseeds", strprintf("Allow fixed seeds if DNS seeds don't provide peers (default: %u)", DEFAULT_FIXEDSEEDS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
583 argsman.AddArg("-forcednsseed", strprintf("Always query for peer addresses via DNS lookup (default: %u)", DEFAULT_FORCEDNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
584 argsman.AddArg("-listen", strprintf("Accept connections from outside (default: %u if no -proxy, -connect or -maxconnections=0)", DEFAULT_LISTEN), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
585 argsman.AddArg("-listenonion", strprintf("Automatically create Tor onion service (default: %d)", DEFAULT_LISTEN_ONION), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
586 argsman.AddArg("-maxconnections=<n>", strprintf("Maintain at most <n> automatic connections to peers (default: %u). This limit does not apply to connections manually added via -addnode or the addnode RPC, which have a separate limit of %u. It does not apply to short-lived private broadcast connections either, which have a separate limit of %u.", DEFAULT_MAX_PEER_CONNECTIONS, MAX_ADDNODE_CONNECTIONS, MAX_PRIVATE_BROADCAST_CONNECTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
587 argsman.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
588 argsman.AddArg("-maxsendbuffer=<n>", strprintf("Maximum per-connection memory usage for the send buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXSENDBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
589 argsman.AddArg("-maxuploadtarget=<n>", strprintf("Tries to keep outbound traffic under the given target per 24h. Limit does not apply to peers with 'download' permission or blocks created within past week. 0 = no limit (default: %s). Optional suffix units [k|K|m|M|g|G|t|T] (default: M). Lowercase is 1000 base while uppercase is 1024 base", DEFAULT_MAX_UPLOAD_TARGET), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
590 #ifdef HAVE_SOCKADDR_UN
591 argsman.AddArg("-onion=<ip:port|path>", "Use separate SOCKS5 proxy to reach peers via Tor onion services, set -noonion to disable (default: -proxy). May be a local file path prefixed with 'unix:'.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
592 #else
593 argsman.AddArg("-onion=<ip:port>", "Use separate SOCKS5 proxy to reach peers via Tor onion services, set -noonion to disable (default: -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
594 #endif
595 argsman.AddArg("-i2psam=<ip:port>", "I2P SAM proxy to reach I2P peers and accept I2P connections", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
596 argsman.AddArg("-i2pacceptincoming", strprintf("Whether to accept inbound I2P connections (default: %i). Ignored if -i2psam is not set. Listening for inbound I2P connections is done through the SAM proxy, not by binding to a local address and port.", DEFAULT_I2P_ACCEPT_INCOMING), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
597 argsman.AddArg("-onlynet=<net>", "Make automatic outbound connections only to network <net> (" + Join(GetNetworkNames(), ", ") + "). Inbound and manual connections are not affected by this option. It can be specified multiple times to allow multiple networks.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
598 argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
599 argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
600 argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
601 argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
602 argsman.AddArg("-port=<port>", strprintf("Listen for connections on <port> (default: %u, testnet3: %u, testnet4: %u, signet: %u, regtest: %u). Not relevant for I2P (see doc/i2p.md). If set to a value x, the default onion listening port will be set to x+1.", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), testnet4ChainParams->GetDefaultPort(), signetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
603 const std::string proxy_doc_for_value =
604 #ifdef HAVE_SOCKADDR_UN
605 "<ip>[:<port>]|unix:<path>";
606 #else
607 "<ip>[:<port>]";
608 #endif
609 const std::string proxy_doc_for_unix_socket =
610 #ifdef HAVE_SOCKADDR_UN
611 "May be a local file path prefixed with 'unix:' if the proxy supports it. ";
612 #else
613 "";
614 #endif
615 argsman.AddArg("-proxy=" + proxy_doc_for_value + "[=<network>]",
616 "Connect through SOCKS5 proxy, set -noproxy to disable. " +
617 proxy_doc_for_unix_socket +
618 "Could end in =network to set the proxy only for that network. " +
619 "The network can be any of ipv4, ipv6, tor or cjdns. " +
620 "(default: disabled)",
621 ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION,
622 OptionsCategory::CONNECTION);
623 argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
624 argsman.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. During startup, seednodes will be tried before dnsseeds.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
625 argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
626 argsman.AddArg("-timeout=<n>", strprintf("Specify socket connection timeout in milliseconds. If an initial attempt to connect is unsuccessful after this amount of time, drop it (minimum: 1, default: %d)", DEFAULT_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
627 argsman.AddArg("-peertimeout=<n>", strprintf("Specify a p2p connection timeout delay in seconds. After connecting to a peer, wait this amount of time before considering disconnection based on inactivity (minimum: 1, default: %d)", DEFAULT_PEER_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
628 argsman.AddArg("-torcontrol=<ip>:<port>", strprintf("Tor control host and port to use if onion listening enabled (default: %s). If no port is specified, the default port of %i will be used.", DEFAULT_TOR_CONTROL, DEFAULT_TOR_CONTROL_PORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
629 argsman.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::CONNECTION);
630 argsman.AddArg("-natpmp", strprintf("Use PCP or NAT-PMP to map the listening port (default: %u)", DEFAULT_NATPMP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
631 argsman.AddArg("-whitebind=<[permissions@]addr>", "Bind to the given address and add permission flags to the peers connecting to it. "
632 "Use [host]:port notation for IPv6. Allowed permissions: " + Join(NET_PERMISSIONS_DOC, ", ") + ". "
633 "Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
634 635 argsman.AddArg("-whitelist=<[permissions@]IP address or network>", "Add permission flags to the peers using the given IP address (e.g. 1.2.3.4) or "
636 "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
637 "-whitebind. "
638 "Additional flags \"in\" and \"out\" control whether permissions apply to incoming connections and/or manual (default: incoming only). "
639 "Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
640 641 g_wallet_init_interface.AddWalletOptions(argsman);
642 643 #ifdef ENABLE_ZMQ
644 argsman.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
645 argsman.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
646 argsman.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
647 argsman.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
648 argsman.AddArg("-zmqpubsequence=<address>", "Enable publish hash block and tx sequence in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
649 argsman.AddArg("-zmqpubhashblockhwm=<n>", strprintf("Set publish hash block outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
650 argsman.AddArg("-zmqpubhashtxhwm=<n>", strprintf("Set publish hash transaction outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
651 argsman.AddArg("-zmqpubrawblockhwm=<n>", strprintf("Set publish raw block outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
652 argsman.AddArg("-zmqpubrawtxhwm=<n>", strprintf("Set publish raw transaction outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
653 argsman.AddArg("-zmqpubsequencehwm=<n>", strprintf("Set publish hash sequence message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
654 #else
655 hidden_args.emplace_back("-zmqpubhashblock=<address>");
656 hidden_args.emplace_back("-zmqpubhashtx=<address>");
657 hidden_args.emplace_back("-zmqpubrawblock=<address>");
658 hidden_args.emplace_back("-zmqpubrawtx=<address>");
659 hidden_args.emplace_back("-zmqpubsequence=<n>");
660 hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
661 hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
662 hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
663 hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
664 hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
665 #endif
666 667 argsman.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);
668 argsman.AddArg("-checklevel=<n>", strprintf("How thorough the block verification of -checkblocks is: %s (0-4, default: %u)", Join(CHECKLEVEL_DOC, ", "), DEFAULT_CHECKLEVEL), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
669 argsman.AddArg("-checkblockindex", strprintf("Do a consistency check for the block tree, chainstate, and other validation data structures every <n> operations. Use 0 to disable. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
670 argsman.AddArg("-checkaddrman=<n>", strprintf("Run addrman consistency checks every <n> operations. Use 0 to disable. (default: %u)", DEFAULT_ADDRMAN_CONSISTENCY_CHECKS), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
671 argsman.AddArg("-checkmempool=<n>", strprintf("Run mempool consistency checks every <n> transactions. Use 0 to disable. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
672 // Checkpoints were removed. We keep `-checkpoints` as a hidden arg to display a more user friendly error when set.
673 argsman.AddArg("-checkpoints", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
674 argsman.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
675 argsman.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
676 argsman.AddArg("-stopatheight", strprintf("Stop running after reaching the given height in the main chain (default: %u). Blocks after target height may be processed during shutdown.", DEFAULT_STOPATHEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
677 argsman.AddArg("-limitancestorcount=<n>", strprintf("Deprecated setting to not accept transactions if number of in-mempool ancestors is <n> or more (default: %u); replaced by cluster limits (see -limitclustercount) and only used by wallet for coin selection", DEFAULT_ANCESTOR_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
678 // Ancestor and descendant size limits were removed. We keep
679 // -limitancestorsize/-limitdescendantsize as hidden args to display a more
680 // user friendly error when set.
681 argsman.AddArg("-limitancestorsize", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
682 argsman.AddArg("-limitdescendantsize", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
683 argsman.AddArg("-limitdescendantcount=<n>", strprintf("Deprecated setting to not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u); replaced by cluster limits (see -limitclustercount) and only used by wallet for coin selection", DEFAULT_DESCENDANT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
684 argsman.AddArg("-test=<option>", "Pass a test-only option. Options include : " + Join(TEST_OPTIONS_DOC, ", ") + ".", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
685 argsman.AddArg("-limitclustercount=<n>", strprintf("Do not accept transactions into mempool which are directly or indirectly connected to <n> or more other unconfirmed transactions (default: %u, maximum: %u)", DEFAULT_CLUSTER_LIMIT, MAX_CLUSTER_COUNT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
686 argsman.AddArg("-limitclustersize=<n>", strprintf("Do not accept transactions whose virtual size with all in-mempool connected transactions exceeds <n> kilobytes (default: %u)", DEFAULT_CLUSTER_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
687 argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
688 argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
689 argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_VALIDATION_CACHE_BYTES >> 20), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
690 argsman.AddArg("-maxtipage=<n>",
691 strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)",
692 Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
693 ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
694 argsman.AddArg("-printpriority", strprintf("Log transaction fee rate in %s/kvB when mining blocks (default: %u)", CURRENCY_UNIT, DEFAULT_PRINT_MODIFIED_FEE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
695 argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
696 697 SetupChainParamsBaseOptions(argsman);
698 699 argsman.AddArg("-acceptnonstdtxn", strprintf("Relay and mine \"non-standard\" transactions (test networks only; default: %u)", DEFAULT_ACCEPT_NON_STD_TXN), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
700 argsman.AddArg("-incrementalrelayfee=<amt>", strprintf("Fee rate (in %s/kvB) used to define cost of relay, used for mempool limiting and replacement policy. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_INCREMENTAL_RELAY_FEE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
701 argsman.AddArg("-dustrelayfee=<amt>", strprintf("Fee rate (in %s/kvB) 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);
702 argsman.AddArg("-acceptstalefeeestimates", strprintf("Read fee estimates even if they are stale (%sdefault: %u) fee estimates are considered stale if they are %s hours old", "regtest only; ", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES, Ticks<std::chrono::hours>(MAX_FILE_AGE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
703 argsman.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);
704 argsman.AddArg("-datacarrier", strprintf("Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
705 argsman.AddArg("-datacarriersize",
706 strprintf("Relay and mine transactions whose data-carrying raw scriptPubKeys in aggregate "
707 "are of this size or less, allowing multiple outputs (default: %u)",
708 MAX_OP_RETURN_RELAY),
709 ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
710 argsman.AddArg("-permitbaremultisig", strprintf("Relay transactions creating non-P2SH multisig outputs (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY,
711 OptionsCategory::NODE_RELAY);
712 argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
713 CURRENCY_UNIT, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
714 argsman.AddArg("-privatebroadcast",
715 strprintf(
716 "Broadcast transactions submitted via sendrawtransaction RPC using short-lived "
717 "connections through the Tor or I2P networks, without putting them in the mempool first. "
718 "Transactions submitted through the wallet are not affected by this option "
719 "(default: %u)",
720 DEFAULT_PRIVATE_BROADCAST),
721 ArgsManager::ALLOW_ANY,
722 OptionsCategory::NODE_RELAY);
723 argsman.AddArg("-whitelistforcerelay", strprintf("Add 'forcerelay' permission to whitelisted peers with default permissions. This will relay transactions even if the transactions were already in the mempool. (default: %d)", DEFAULT_WHITELISTFORCERELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
724 argsman.AddArg("-whitelistrelay", strprintf("Add 'relay' permission to whitelisted peers with default permissions. This will accept relayed transactions even when not relaying transactions (default: %d)", DEFAULT_WHITELISTRELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
725 726 727 argsman.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
728 argsman.AddArg("-blockreservedweight=<n>", strprintf("Reserve space for the fixed-size block header plus the largest coinbase transaction the mining software may add to the block. Only affects mining RPC clients, not IPC clients. (default: %d).", DEFAULT_BLOCK_RESERVED_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
729 argsman.AddArg("-blockmintxfee=<amt>", strprintf("Set lowest fee rate (in %s/kvB) for transactions to be included in block creation. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
730 argsman.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
731 732 argsman.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
733 argsman.AddArg("-rpcallowip=<ip>", "Allow JSON-RPC connections from specified source. Valid values 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), a network/CIDR (e.g. 1.2.3.4/24), all ipv4 (0.0.0.0/0), or all ipv6 (::/0). RFC4193 is allowed only if -cjdnsreachable=0. This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
734 argsman.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 | ArgsManager::SENSITIVE, OptionsCategory::RPC);
735 argsman.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);
736 argsman.AddArg("-rpcdoccheck", strprintf("Throw a non-fatal error at runtime if the documentation for an RPC is incorrect (default: %u)", DEFAULT_RPC_DOC_CHECK), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
737 argsman.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);
738 argsman.AddArg("-rpccookieperms=<readable-by>", strprintf("Set permissions on the RPC auth cookie file so that it is readable by [owner|group|all] (default: owner [via umask 0077])"), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
739 argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
740 argsman.AddArg("-rpcport=<port>", strprintf("Listen for JSON-RPC connections on <port> (default: %u, testnet3: %u, testnet4: %u, signet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), testnet4BaseParams->RPCPort(), signetBaseParams->RPCPort(), regtestBaseParams->RPCPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC);
741 argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
742 argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
743 argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
744 argsman.AddArg("-rpcwhitelist=<whitelist>", "Set a whitelist to filter incoming RPC calls for a specific user. The field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc 2>,...,<rpc n>. If multiple whitelists are set for a given user, they are set-intersected. See -rpcwhitelistdefault documentation for information on default whitelist behavior.", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
745 argsman.AddArg("-rpcwhitelistdefault", "Sets default behavior for rpc whitelisting. Unless rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc server acts as if all rpc users are subject to empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault is set to 1 and no -rpcwhitelist is set, rpc server acts as if all rpc users are subject to empty whitelists.", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
746 argsman.AddArg("-rpcworkqueue=<n>", strprintf("Set the maximum depth of the work queue to service RPC calls (default: %d)", DEFAULT_HTTP_WORKQUEUE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
747 argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
748 if (can_listen_ipc) {
749 argsman.AddArg("-ipcbind=<address>", "Bind to Unix socket address and listen for incoming connections. Valid address values are \"unix\" to listen on the default path, <datadir>/node.sock, or \"unix:/custom/path\" to specify a custom path. Can be specified multiple times to listen on multiple paths. Default behavior is not to listen on any path. If relative paths are specified, they are interpreted relative to the network data directory. If paths include any parent directory components and the parent directories do not exist, they will be created. Enabling this gives local processes that can access the socket unauthenticated RPC access, so it's important to choose a path with secure permissions if customizing this.", ArgsManager::ALLOW_ANY, OptionsCategory::IPC);
750 }
751 752 #if HAVE_DECL_FORK
753 argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
754 argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
755 #else
756 hidden_args.emplace_back("-daemon");
757 hidden_args.emplace_back("-daemonwait");
758 #endif
759 760 // Add the hidden options
761 argsman.AddHiddenArgs(hidden_args);
762 }
763 764 #if HAVE_SYSTEM
765 static void StartupNotify(const ArgsManager& args)
766 {
767 std::string cmd = args.GetArg("-startupnotify", "");
768 if (!cmd.empty()) {
769 std::thread t(runCommand, cmd);
770 t.detach(); // thread runs free
771 }
772 }
773 #endif
774 775 static bool AppInitServers(NodeContext& node)
776 {
777 const ArgsManager& args = *Assert(node.args);
778 if (!InitHTTPServer()) {
779 return false;
780 }
781 StartRPC();
782 node.rpc_interruption_point = RpcInterruptionPoint;
783 if (!StartHTTPRPC(&node))
784 return false;
785 if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) StartREST(&node);
786 StartHTTPServer();
787 return true;
788 }
789 790 // Parameter interaction based on rules
791 void InitParameterInteraction(ArgsManager& args)
792 {
793 // when specifying an explicit binding address, you want to listen on it
794 // even when -connect or -proxy is specified
795 if (!args.GetArgs("-bind").empty()) {
796 if (args.SoftSetBoolArg("-listen", true))
797 LogInfo("parameter interaction: -bind set -> setting -listen=1\n");
798 }
799 if (!args.GetArgs("-whitebind").empty()) {
800 if (args.SoftSetBoolArg("-listen", true))
801 LogInfo("parameter interaction: -whitebind set -> setting -listen=1\n");
802 }
803 804 if (!args.GetArgs("-connect").empty() || args.IsArgNegated("-connect") || args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS) <= 0) {
805 // when only connecting to trusted nodes, do not seed via DNS, or listen by default
806 // do the same when connections are disabled
807 if (args.SoftSetBoolArg("-dnsseed", false))
808 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -dnsseed=0\n");
809 if (args.SoftSetBoolArg("-listen", false))
810 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -listen=0\n");
811 }
812 813 std::string proxy_arg = args.GetArg("-proxy", "");
814 if (proxy_arg != "" && proxy_arg != "0") {
815 // to protect privacy, do not listen by default if a default proxy server is specified
816 if (args.SoftSetBoolArg("-listen", false))
817 LogInfo("parameter interaction: -proxy set -> setting -listen=0\n");
818 // to protect privacy, do not map ports when a proxy is set. The user may still specify -listen=1
819 // to listen locally, so don't rely on this happening through -listen below.
820 if (args.SoftSetBoolArg("-natpmp", false)) {
821 LogInfo("parameter interaction: -proxy set -> setting -natpmp=0\n");
822 }
823 // to protect privacy, do not discover addresses by default
824 if (args.SoftSetBoolArg("-discover", false))
825 LogInfo("parameter interaction: -proxy set -> setting -discover=0\n");
826 }
827 828 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
829 // do not map ports or try to retrieve public IP when not listening (pointless)
830 if (args.SoftSetBoolArg("-natpmp", false)) {
831 LogInfo("parameter interaction: -listen=0 -> setting -natpmp=0\n");
832 }
833 if (args.SoftSetBoolArg("-discover", false))
834 LogInfo("parameter interaction: -listen=0 -> setting -discover=0\n");
835 if (args.SoftSetBoolArg("-listenonion", false))
836 LogInfo("parameter interaction: -listen=0 -> setting -listenonion=0\n");
837 if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
838 LogInfo("parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n");
839 }
840 }
841 842 if (!args.GetArgs("-externalip").empty()) {
843 // if an explicit public IP is specified, do not try to find others
844 if (args.SoftSetBoolArg("-discover", false))
845 LogInfo("parameter interaction: -externalip set -> setting -discover=0\n");
846 }
847 848 if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
849 // disable whitelistrelay in blocksonly mode
850 if (args.SoftSetBoolArg("-whitelistrelay", false))
851 LogInfo("parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n");
852 // Reduce default mempool size in blocksonly mode to avoid unexpected resource usage
853 if (args.SoftSetArg("-maxmempool", ToString(DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB)))
854 LogInfo("parameter interaction: -blocksonly=1 -> setting -maxmempool=%d\n", DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB);
855 }
856 857 // Forcing relay from whitelisted hosts implies we will accept relays from them in the first place.
858 if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
859 if (args.SoftSetBoolArg("-whitelistrelay", true))
860 LogInfo("parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n");
861 }
862 const auto onlynets = args.GetArgs("-onlynet");
863 if (!onlynets.empty()) {
864 bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](const auto& net) {
865 const auto n = ParseNetwork(net);
866 return n == NET_IPV4 || n == NET_IPV6;
867 });
868 if (!clearnet_reachable && args.SoftSetBoolArg("-dnsseed", false)) {
869 LogInfo("parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n");
870 }
871 }
872 }
873 874 /**
875 * Initialize global loggers.
876 *
877 * Note that this is called very early in the process lifetime, so you should be
878 * careful about what global state you rely on here.
879 */
880 void InitLogging(const ArgsManager& args)
881 {
882 init::SetLoggingOptions(args);
883 init::LogPackageVersion();
884 }
885 886 namespace { // Variables internal to initialization process only
887 888 int nMaxConnections;
889 int available_fds;
890 ServiceFlags g_local_services = ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
891 int64_t peer_connect_timeout;
892 std::set<BlockFilterType> g_enabled_filter_types;
893 894 } // namespace
895 896 [[noreturn]] static void new_handler_terminate()
897 {
898 // Rather than throwing std::bad-alloc if allocation fails, terminate
899 // immediately to (try to) avoid chain corruption.
900 // Since logging may itself allocate memory, set the handler directly
901 // to terminate first.
902 std::set_new_handler(std::terminate);
903 LogError("Out of memory. Terminating.\n");
904 905 // The log was successful, terminate now.
906 std::terminate();
907 };
908 909 bool AppInitBasicSetup(const ArgsManager& args, std::atomic<int>& exit_status)
910 {
911 // ********************************************************* Step 1: setup
912 #ifdef _MSC_VER
913 // Turn off Microsoft heap dump noise
914 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
915 _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, 0));
916 // Disable confusing "helpful" text message on abort, Ctrl-C
917 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
918 #endif
919 #ifdef WIN32
920 // Enable heap terminate-on-corruption
921 HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, 0);
922 #endif
923 if (!SetupNetworking()) {
924 return InitError(Untranslated("Initializing networking failed."));
925 }
926 927 #ifndef WIN32
928 // Clean shutdown on SIGTERM
929 registerSignalHandler(SIGTERM, HandleSIGTERM);
930 registerSignalHandler(SIGINT, HandleSIGTERM);
931 932 // Reopen debug.log on SIGHUP
933 registerSignalHandler(SIGHUP, HandleSIGHUP);
934 935 // Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly
936 signal(SIGPIPE, SIG_IGN);
937 #else
938 SetConsoleCtrlHandler(consoleCtrlHandler, true);
939 #endif
940 941 std::set_new_handler(new_handler_terminate);
942 943 return true;
944 }
945 946 bool AppInitParameterInteraction(const ArgsManager& args)
947 {
948 const CChainParams& chainparams = Params();
949 // ********************************************************* Step 2: parameter interactions
950 951 // also see: InitParameterInteraction()
952 953 // We removed checkpoints but keep the option to warn users who still have it in their config.
954 if (args.IsArgSet("-checkpoints")) {
955 InitWarning(_("Option '-checkpoints' is set but checkpoints were removed. This option has no effect."));
956 }
957 if (args.IsArgSet("-limitancestorsize")) {
958 InitWarning(_("Option '-limitancestorsize' is given but ancestor size limits have been replaced with cluster size limits (see -limitclustersize). This option has no effect."));
959 }
960 if (args.IsArgSet("-limitdescendantsize")) {
961 InitWarning(_("Option '-limitdescendantsize' is given but descendant size limits have been replaced with cluster size limits (see -limitclustersize). This option has no effect."));
962 }
963 964 // Error if network-specific options (-addnode, -connect, etc) are
965 // specified in default section of config file, but not overridden
966 // on the command line or in this chain's section of the config file.
967 ChainType chain = args.GetChainType();
968 if (chain == ChainType::SIGNET) {
969 LogInfo("Signet derived magic (message start): %s", HexStr(chainparams.MessageStart()));
970 }
971 bilingual_str errors;
972 for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) {
973 errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section."), arg, ChainTypeToString(chain), ChainTypeToString(chain)) + Untranslated("\n");
974 }
975 976 if (!errors.empty()) {
977 return InitError(errors);
978 }
979 980 // Testnet3 deprecation warning
981 if (chain == ChainType::TESTNET) {
982 LogInfo("Warning: Support for testnet3 is deprecated and will be removed in an upcoming release. Consider switching to testnet4.\n");
983 }
984 985 // Warn if unrecognized section name are present in the config file.
986 bilingual_str warnings;
987 for (const auto& section : args.GetUnrecognizedSections()) {
988 warnings += Untranslated(strprintf("%s:%i ", section.m_file, section.m_line)) + strprintf(_("Section [%s] is not recognized."), section.m_name) + Untranslated("\n");
989 }
990 991 if (!warnings.empty()) {
992 InitWarning(warnings);
993 }
994 995 if (!fs::is_directory(args.GetBlocksDirPath())) {
996 return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", "")));
997 }
998 999 // parse and validate enabled filter types
1000 std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
1001 if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
1002 g_enabled_filter_types = AllBlockFilterTypes();
1003 } else if (blockfilterindex_value != "0") {
1004 const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
1005 for (const auto& name : names) {
1006 BlockFilterType filter_type;
1007 if (!BlockFilterTypeByName(name, filter_type)) {
1008 return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name));
1009 }
1010 g_enabled_filter_types.insert(filter_type);
1011 }
1012 }
1013 1014 // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled.
1015 if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) {
1016 g_local_services = ServiceFlags(g_local_services | NODE_P2P_V2);
1017 }
1018 1019 // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
1020 if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
1021 if (!g_enabled_filter_types.contains(BlockFilterType::BASIC)) {
1022 return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
1023 }
1024 1025 g_local_services = ServiceFlags(g_local_services | NODE_COMPACT_FILTERS);
1026 }
1027 1028 if (args.GetIntArg("-prune", 0)) {
1029 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
1030 return InitError(_("Prune mode is incompatible with -txindex."));
1031 if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX))
1032 return InitError(_("Prune mode is incompatible with -txospenderindex."));
1033 if (args.GetBoolArg("-reindex-chainstate", false)) {
1034 return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
1035 }
1036 }
1037 1038 // If -forcednsseed is set to true, ensure -dnsseed has not been set to false
1039 if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){
1040 return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false."));
1041 }
1042 1043 // -bind and -whitebind can't be set when not listening
1044 size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
1045 if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
1046 return InitError(Untranslated("Cannot set -bind or -whitebind together with -listen=0"));
1047 }
1048 1049 // if listen=0, then disallow listenonion=1
1050 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN) && args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
1051 return InitError(Untranslated("Cannot set -listen=0 together with -listenonion=1"));
1052 }
1053 1054 // Make sure enough file descriptors are available. We need to reserve enough FDs to account for the bare minimum,
1055 // plus all manual connections and all bound interfaces. Any remainder will be available for connection sockets
1056 1057 // Number of bound interfaces (we have at least one)
1058 int nBind = std::max(nUserBind, size_t(1));
1059 // Maximum number of connections with other nodes, this accounts for all types of outbounds and inbounds except for manual
1060 int user_max_connection = args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
1061 if (user_max_connection < 0) {
1062 return InitError(Untranslated("-maxconnections must be greater or equal than zero"));
1063 }
1064 const size_t max_private{args.GetBoolArg("-privatebroadcast", DEFAULT_PRIVATE_BROADCAST)
1065 ? MAX_PRIVATE_BROADCAST_CONNECTIONS
1066 : 0};
1067 // Reserve enough FDs to account for the bare minimum, plus any manual connections, plus the bound interfaces
1068 int min_required_fds = MIN_CORE_FDS + MAX_ADDNODE_CONNECTIONS + nBind;
1069 1070 // Try raising the FD limit to what we need (available_fds may be smaller than the requested amount if this fails)
1071 available_fds = RaiseFileDescriptorLimit(user_max_connection + max_private + min_required_fds);
1072 // If we are using select instead of poll, our actual limit may be even smaller
1073 #ifndef USE_POLL
1074 available_fds = std::min(FD_SETSIZE, available_fds);
1075 #endif
1076 if (available_fds < min_required_fds)
1077 return InitError(strprintf(_("Not enough file descriptors available. %d available, %d required."), available_fds, min_required_fds));
1078 1079 // Trim requested connection counts, to fit into system limitations
1080 nMaxConnections = std::min(available_fds - min_required_fds, user_max_connection);
1081 1082 if (nMaxConnections < user_max_connection)
1083 InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), user_max_connection, nMaxConnections));
1084 1085 // ********************************************************* Step 3: parameter-to-internal-flags
1086 if (auto result{init::SetLoggingCategories(args)}; !result) return InitError(util::ErrorString(result));
1087 if (auto result{init::SetLoggingLevel(args)}; !result) return InitError(util::ErrorString(result));
1088 1089 nConnectTimeout = args.GetIntArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
1090 if (nConnectTimeout <= 0) {
1091 nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
1092 }
1093 1094 peer_connect_timeout = args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
1095 if (peer_connect_timeout <= 0) {
1096 return InitError(Untranslated("peertimeout must be a positive integer."));
1097 }
1098 1099 auto mining_result{node::ReadMiningArgs(args)};
1100 if (!mining_result) {
1101 return InitError(util::ErrorString(mining_result));
1102 }
1103 1104 nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp);
1105 1106 if (!g_wallet_init_interface.ParameterInteraction()) return false;
1107 1108 // Option to startup with mocktime set (used for regression testing):
1109 if (const auto mocktime{args.GetIntArg("-mocktime")}) {
1110 SetMockTime(std::chrono::seconds{*mocktime});
1111 }
1112 1113 if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
1114 g_local_services = ServiceFlags(g_local_services | NODE_BLOOM);
1115 1116 const std::vector<std::string> test_options = args.GetArgs("-test");
1117 if (!test_options.empty()) {
1118 if (chainparams.GetChainType() != ChainType::REGTEST) {
1119 return InitError(Untranslated("-test=<option> can only be used with regtest"));
1120 }
1121 for (const std::string& option : test_options) {
1122 auto it = std::find_if(TEST_OPTIONS_DOC.begin(), TEST_OPTIONS_DOC.end(), [&option](const std::string& doc_option) {
1123 size_t pos = doc_option.find(" (");
1124 return (pos != std::string::npos) && (doc_option.substr(0, pos) == option);
1125 });
1126 if (it == TEST_OPTIONS_DOC.end()) {
1127 InitWarning(strprintf(_("Unrecognised option \"%s\" provided in -test=<option>."), option));
1128 }
1129 }
1130 }
1131 1132 // Prevent setting deployment parameters on mainnet.
1133 if (chainparams.GetChainType() == ChainType::MAIN) {
1134 if (args.IsArgSet("-testactivationheight")) {
1135 return InitError(_("The -testactivationheight option may not be used on mainnet."));
1136 }
1137 if (args.IsArgSet("-vbparams")) {
1138 return InitError(_("The -vbparams option may not be used on mainnet."));
1139 }
1140 }
1141 1142 // Also report errors from parsing before daemonization
1143 {
1144 kernel::Notifications notifications{};
1145 ChainstateManager::Options chainman_opts_dummy{
1146 .chainparams = chainparams,
1147 .datadir = args.GetDataDirNet(),
1148 .notifications = notifications,
1149 };
1150 auto chainman_result{ApplyArgsManOptions(args, chainman_opts_dummy)};
1151 if (!chainman_result) {
1152 return InitError(util::ErrorString(chainman_result));
1153 }
1154 BlockManager::Options blockman_opts_dummy{
1155 .chainparams = chainman_opts_dummy.chainparams,
1156 .blocks_dir = args.GetBlocksDirPath(),
1157 .notifications = chainman_opts_dummy.notifications,
1158 .block_tree_db_params = DBParams{
1159 .path = args.GetDataDirNet() / "blocks" / "index",
1160 .cache_bytes = 0,
1161 },
1162 };
1163 auto blockman_result{ApplyArgsManOptions(args, blockman_opts_dummy)};
1164 if (!blockman_result) {
1165 return InitError(util::ErrorString(blockman_result));
1166 }
1167 CTxMemPool::Options mempool_opts{};
1168 auto mempool_result{ApplyArgsManOptions(args, chainparams, mempool_opts)};
1169 if (!mempool_result) {
1170 return InitError(util::ErrorString(mempool_result));
1171 }
1172 }
1173 1174 return true;
1175 }
1176 1177 static bool LockDirectory(const fs::path& dir, bool probeOnly)
1178 {
1179 // Make sure only a single process is using the directory.
1180 switch (util::LockDirectory(dir, ".lock", probeOnly)) {
1181 case util::LockResult::ErrorWrite:
1182 return InitError(strprintf(_("Cannot write to directory '%s'; check permissions."), fs::PathToString(dir)));
1183 case util::LockResult::ErrorLock:
1184 return InitError(strprintf(_("Cannot obtain a lock on directory %s. %s is probably already running."), fs::PathToString(dir), CLIENT_NAME));
1185 case util::LockResult::Success: return true;
1186 } // no default case, so the compiler can warn about missing cases
1187 assert(false);
1188 }
1189 static bool LockDirectories(bool probeOnly)
1190 {
1191 return LockDirectory(gArgs.GetDataDirNet(), probeOnly) && \
1192 LockDirectory(gArgs.GetBlocksDirPath(), probeOnly);
1193 }
1194 1195 bool AppInitSanityChecks(const kernel::Context& kernel)
1196 {
1197 // ********************************************************* Step 4: sanity checks
1198 auto result{kernel::SanityChecks(kernel)};
1199 if (!result) {
1200 InitError(util::ErrorString(result));
1201 return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), CLIENT_NAME));
1202 }
1203 1204 if (!ECC_InitSanityCheck()) {
1205 return InitError(strprintf(_("Elliptic curve cryptography sanity check failure. %s is shutting down."), CLIENT_NAME));
1206 }
1207 1208 // Probe the directory locks to give an early error message, if possible
1209 // We cannot hold the directory locks here, as the forking for daemon() hasn't yet happened,
1210 // and a fork will cause weird behavior to them.
1211 return LockDirectories(true);
1212 }
1213 1214 bool AppInitLockDirectories()
1215 {
1216 // After daemonization get the directory locks again and hold on to them until exit
1217 // This creates a slight window for a race condition to happen, however this condition is harmless: it
1218 // will at most make us exit without printing a message to console.
1219 if (!LockDirectories(false)) {
1220 // Detailed error printed inside LockDirectory
1221 return false;
1222 }
1223 return true;
1224 }
1225 1226 bool AppInitInterfaces(NodeContext& node)
1227 {
1228 node.chain = interfaces::MakeChain(node);
1229 // Specify wait_loaded=false so internal mining interface can be initialized
1230 // on early startup and does not need to be tied to chainstate loading.
1231 node.mining = interfaces::MakeMining(node, /*wait_loaded=*/false);
1232 return true;
1233 }
1234 1235 bool CheckHostPortOptions(const ArgsManager& args) {
1236 for (const std::string port_option : {
1237 "-port",
1238 "-rpcport",
1239 }) {
1240 if (const auto port{args.GetArg(port_option)}) {
1241 const auto n{ToIntegral<uint16_t>(*port)};
1242 if (!n || *n == 0) {
1243 return InitError(InvalidPortErrMsg(port_option, *port));
1244 }
1245 }
1246 }
1247 1248 for ([[maybe_unused]] const auto& [param_name, unix, suffix_allowed] : std::vector<std::tuple<std::string, bool, bool>>{
1249 // arg name UNIX socket support =suffix allowed
1250 {"-i2psam", false, false},
1251 {"-onion", true, false},
1252 {"-proxy", true, true},
1253 {"-bind", false, true},
1254 {"-rpcbind", false, false},
1255 {"-torcontrol", false, false},
1256 {"-whitebind", false, false},
1257 {"-zmqpubhashblock", true, false},
1258 {"-zmqpubhashtx", true, false},
1259 {"-zmqpubrawblock", true, false},
1260 {"-zmqpubrawtx", true, false},
1261 {"-zmqpubsequence", true, false},
1262 }) {
1263 for (const std::string& param_value : args.GetArgs(param_name)) {
1264 const std::string param_value_hostport{
1265 suffix_allowed ? param_value.substr(0, param_value.rfind('=')) : param_value};
1266 std::string host_out;
1267 uint16_t port_out{0};
1268 if (!SplitHostPort(param_value_hostport, port_out, host_out)) {
1269 #ifdef HAVE_SOCKADDR_UN
1270 // Allow unix domain sockets for some options e.g. unix:/some/file/path
1271 if (!unix || !param_value.starts_with(ADDR_PREFIX_UNIX)) {
1272 return InitError(InvalidPortErrMsg(param_name, param_value));
1273 }
1274 #else
1275 return InitError(InvalidPortErrMsg(param_name, param_value));
1276 #endif
1277 }
1278 }
1279 }
1280 1281 return true;
1282 }
1283 1284 /**
1285 * @brief Checks for duplicate bindings across all binding configurations.
1286 *
1287 * @param[in] conn_options Connection options containing the binding vectors to check
1288 * @return std::optional<CService> containing the first duplicate found, or std::nullopt if no duplicates
1289 */
1290 static std::optional<CService> CheckBindingConflicts(const CConnman::Options& conn_options)
1291 {
1292 std::set<CService> seen;
1293 1294 // Check all whitelisted bindings
1295 for (const auto& wb : conn_options.vWhiteBinds) {
1296 if (!seen.insert(wb.m_service).second) {
1297 return wb.m_service;
1298 }
1299 }
1300 1301 // Check regular bindings
1302 for (const auto& bind : conn_options.vBinds) {
1303 if (!seen.insert(bind).second) {
1304 return bind;
1305 }
1306 }
1307 1308 // Check onion bindings
1309 for (const auto& onion_bind : conn_options.onion_binds) {
1310 if (!seen.insert(onion_bind).second) {
1311 return onion_bind;
1312 }
1313 }
1314 1315 return std::nullopt;
1316 }
1317 1318 // A GUI user may opt to retry once with do_reindex set if there is a failure during chainstate initialization.
1319 // The function therefore has to support re-entry.
1320 static ChainstateLoadResult InitAndLoadChainstate(
1321 NodeContext& node,
1322 bool do_reindex,
1323 const bool do_reindex_chainstate,
1324 const kernel::CacheSizes& cache_sizes,
1325 const ArgsManager& args)
1326 {
1327 // This function may be called twice, so any dirty state must be reset.
1328 node.notifications->setChainstateLoaded(false); // Drop state, such as a cached tip block
1329 node.mempool.reset();
1330 node.chainman.reset(); // Drop state, such as an initialized m_block_tree_db
1331 1332 const CChainParams& chainparams = Params();
1333 1334 CTxMemPool::Options mempool_opts{
1335 .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
1336 .signals = node.validation_signals.get(),
1337 };
1338 Assert(ApplyArgsManOptions(args, chainparams, mempool_opts)); // no error can happen, already checked in AppInitParameterInteraction
1339 bilingual_str mempool_error;
1340 Assert(!node.mempool); // Was reset above
1341 node.mempool = std::make_unique<CTxMemPool>(mempool_opts, mempool_error);
1342 if (!mempool_error.empty()) {
1343 return {ChainstateLoadStatus::FAILURE_FATAL, mempool_error};
1344 }
1345 auto mining_args{node::ReadMiningArgs(args)};
1346 Assert(mining_args); // no error can happen, already checked in AppInitParameterInteraction
1347 node.mining_args = std::move(*mining_args);
1348 LogInfo("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)",
1349 cache_sizes.coins / double(1_MiB),
1350 mempool_opts.max_size_bytes / double(1_MiB));
1351 ChainstateManager::Options chainman_opts{
1352 .chainparams = chainparams,
1353 .datadir = args.GetDataDirNet(),
1354 .notifications = *node.notifications,
1355 .signals = node.validation_signals.get(),
1356 };
1357 Assert(ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1358 1359 BlockManager::Options blockman_opts{
1360 .chainparams = chainman_opts.chainparams,
1361 .blocks_dir = args.GetBlocksDirPath(),
1362 .notifications = chainman_opts.notifications,
1363 .block_tree_db_params = DBParams{
1364 .path = args.GetDataDirNet() / "blocks" / "index",
1365 .cache_bytes = cache_sizes.block_tree_db,
1366 .wipe_data = do_reindex,
1367 },
1368 };
1369 Assert(ApplyArgsManOptions(args, blockman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1370 1371 // Creating the chainstate manager internally creates a BlockManager, opens
1372 // the blocks tree db, and wipes existing block files in case of a reindex.
1373 // The coinsdb is opened at a later point on LoadChainstate.
1374 Assert(!node.chainman); // Was reset above
1375 try {
1376 node.chainman = std::make_unique<ChainstateManager>(*Assert(node.shutdown_signal), chainman_opts, blockman_opts);
1377 } catch (dbwrapper_error& e) {
1378 LogError("%s", e.what());
1379 return {ChainstateLoadStatus::FAILURE, _("Error opening block database")};
1380 } catch (std::exception& e) {
1381 return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated(strprintf("Failed to initialize ChainstateManager: %s", e.what()))};
1382 }
1383 ChainstateManager& chainman = *node.chainman;
1384 if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
1385 1386 // This is defined and set here instead of inline in validation.h to avoid a hard
1387 // dependency between validation and index/base, since the latter is not in
1388 // libbitcoinkernel.
1389 chainman.snapshot_download_completed = [&node]() {
1390 if (!node.chainman->m_blockman.IsPruneMode()) {
1391 LogInfo("[snapshot] re-enabling NODE_NETWORK services");
1392 node.connman->AddLocalServices(NODE_NETWORK);
1393 }
1394 LogInfo("[snapshot] restarting indexes");
1395 // Drain the validation interface queue to ensure that the old indexes
1396 // don't have any pending work.
1397 Assert(node.validation_signals)->SyncWithValidationInterfaceQueue();
1398 for (auto* index : node.indexes) {
1399 index->Interrupt();
1400 index->Stop();
1401 if (!(index->Init() && index->StartBackgroundSync())) {
1402 LogWarning("[snapshot] Failed to restart index %s on snapshot chain", index->GetName());
1403 }
1404 }
1405 };
1406 node::ChainstateLoadOptions options;
1407 options.mempool = Assert(node.mempool.get());
1408 options.wipe_chainstate_db = do_reindex || do_reindex_chainstate;
1409 options.prune = chainman.m_blockman.IsPruneMode();
1410 options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
1411 options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
1412 options.require_full_verification = args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
1413 options.coins_error_cb = [] {
1414 uiInterface.ThreadSafeMessageBox(
1415 _("Error reading from database, shutting down."),
1416 CClientUIInterface::MSG_ERROR);
1417 };
1418 uiInterface.InitMessage(_("Loading block index…"));
1419 auto catch_exceptions = [](auto&& f) -> ChainstateLoadResult {
1420 try {
1421 return f();
1422 } catch (const std::exception& e) {
1423 LogError("%s\n", e.what());
1424 return std::make_tuple(node::ChainstateLoadStatus::FAILURE, _("Error loading databases"));
1425 }
1426 };
1427 auto [status, error] = catch_exceptions([&] { return LoadChainstate(chainman, cache_sizes, options); });
1428 if (status == node::ChainstateLoadStatus::SUCCESS) {
1429 uiInterface.InitMessage(_("Verifying blocks…"));
1430 if (chainman.m_blockman.m_have_pruned && options.check_blocks > MIN_BLOCKS_TO_KEEP) {
1431 LogWarning("pruned datadir may not have more than %d blocks; only checking available blocks\n",
1432 MIN_BLOCKS_TO_KEEP);
1433 }
1434 std::tie(status, error) = catch_exceptions([&] { return VerifyLoadedChainstate(chainman, options); });
1435 if (status == node::ChainstateLoadStatus::SUCCESS) {
1436 LogInfo("Block index and chainstate loaded");
1437 node.notifications->setChainstateLoaded(true);
1438 }
1439 }
1440 return {status, error};
1441 };
1442 1443 bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
1444 {
1445 const ArgsManager& args = *Assert(node.args);
1446 const CChainParams& chainparams = Params();
1447 1448 auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M);
1449 if (!opt_max_upload) {
1450 return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", "")));
1451 }
1452 1453 // ********************************************************* Step 4a: application initialization
1454 if (!CreatePidFile(args)) {
1455 // Detailed error printed inside CreatePidFile().
1456 return false;
1457 }
1458 if (!init::StartLogging(args)) {
1459 // Detailed error printed inside StartLogging().
1460 return false;
1461 }
1462 1463 LogInfo("Using at most %i automatic connections (%i file descriptors available)", nMaxConnections, available_fds);
1464 1465 // Warn about relative -datadir path.
1466 if (args.IsArgSet("-datadir") && !args.GetPathArg("-datadir").is_absolute()) {
1467 LogWarning("Relative datadir option '%s' specified, which will be interpreted relative to the "
1468 "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1469 "from a different location, it will be unable to locate the current data files. There could "
1470 "also be data loss if bitcoin is started while in a temporary directory.",
1471 args.GetArg("-datadir", ""), fs::PathToString(fs::current_path()));
1472 }
1473 1474 assert(!node.scheduler);
1475 node.scheduler = std::make_unique<CScheduler>();
1476 auto& scheduler = *node.scheduler;
1477 1478 // Start the lightweight task scheduler thread
1479 scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); });
1480 1481 // Gather some entropy once per minute.
1482 scheduler.scheduleEvery([]{
1483 RandAddPeriodic();
1484 }, std::chrono::minutes{1});
1485 1486 // Check disk space every 5 minutes to avoid db corruption.
1487 scheduler.scheduleEvery([&args, &node]{
1488 constexpr uint64_t min_disk_space{50_MiB};
1489 if (!CheckDiskSpace(args.GetBlocksDirPath(), min_disk_space)) {
1490 LogError("Shutting down due to lack of disk space!\n");
1491 if (!(Assert(node.shutdown_request))()) {
1492 LogError("Failed to send shutdown signal after disk space check\n");
1493 }
1494 }
1495 }, std::chrono::minutes{5});
1496 1497 if (args.GetBoolArg("-logratelimit", BCLog::DEFAULT_LOGRATELIMIT)) {
1498 LogInstance().SetRateLimiting(BCLog::LogRateLimiter::Create(
1499 [&scheduler](auto func, auto window) { scheduler.scheduleEvery(std::move(func), window); },
1500 BCLog::RATELIMIT_MAX_BYTES,
1501 BCLog::RATELIMIT_WINDOW));
1502 } else {
1503 LogInfo("Log rate limiting disabled");
1504 }
1505 1506 assert(!node.validation_signals);
1507 node.validation_signals = std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(scheduler));
1508 auto& validation_signals = *node.validation_signals;
1509 1510 // Create KernelNotifications object. Important to do this early before
1511 // calling ipc->listenAddress() below so makeMining and other IPC methods
1512 // can use this.
1513 assert(!node.notifications);
1514 node.notifications = std::make_unique<KernelNotifications>(Assert(node.shutdown_request), node.exit_status, *Assert(node.warnings));
1515 ReadNotificationArgs(args, *node.notifications);
1516 1517 // Create client interfaces for wallets that are supposed to be loaded
1518 // according to -wallet and -disablewallet options. This only constructs
1519 // the interfaces, it doesn't load wallet data. Wallets actually get loaded
1520 // when load() and start() interface methods are called below.
1521 g_wallet_init_interface.Construct(node);
1522 uiInterface.InitWallet();
1523 1524 if (interfaces::Ipc* ipc = node.init->ipc()) {
1525 for (std::string address : gArgs.GetArgs("-ipcbind")) {
1526 try {
1527 ipc->listenAddress(address);
1528 } catch (const std::exception& e) {
1529 return InitError(Untranslated(strprintf("Unable to bind to IPC address '%s'. %s", address, e.what())));
1530 }
1531 LogInfo("Listening for IPC requests on address %s", address);
1532 }
1533 }
1534 1535 /* Register RPC commands regardless of -server setting so they will be
1536 * available in the GUI RPC console even if external calls are disabled.
1537 */
1538 RegisterAllCoreRPCCommands(tableRPC);
1539 for (const auto& client : node.chain_clients) {
1540 client->registerRpcs();
1541 }
1542 #ifdef ENABLE_ZMQ
1543 RegisterZMQRPCCommands(tableRPC);
1544 #endif
1545 1546 // Check port numbers
1547 if (!CheckHostPortOptions(args)) return false;
1548 1549 // Configure reachable networks before we start the RPC server.
1550 // This is necessary for -rpcallowip to distinguish CJDNS from other RFC4193
1551 const auto onlynets = args.GetArgs("-onlynet");
1552 if (!onlynets.empty()) {
1553 g_reachable_nets.RemoveAll();
1554 for (const std::string& snet : onlynets) {
1555 enum Network net = ParseNetwork(snet);
1556 if (net == NET_UNROUTABLE)
1557 return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
1558 g_reachable_nets.Add(net);
1559 }
1560 }
1561 1562 if (!args.IsArgSet("-cjdnsreachable")) {
1563 if (!onlynets.empty() && g_reachable_nets.Contains(NET_CJDNS)) {
1564 return InitError(
1565 _("Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1566 "-cjdnsreachable is not provided"));
1567 }
1568 g_reachable_nets.Remove(NET_CJDNS);
1569 }
1570 // Now g_reachable_nets.Contains(NET_CJDNS) is true if:
1571 // 1. -cjdnsreachable is given and
1572 // 2.1. -onlynet is not given or
1573 // 2.2. -onlynet=cjdns is given
1574 1575 /* Start the RPC server already. It will be started in "warmup" mode
1576 * and not really process calls already (but it will signify connections
1577 * that the server is there and will be ready later). Warmup mode will
1578 * be disabled when initialisation is finished.
1579 */
1580 if (args.GetBoolArg("-server", false)) {
1581 uiInterface.InitMessage.connect(SetRPCWarmupStatus);
1582 if (!AppInitServers(node))
1583 return InitError(_("Unable to start HTTP server. See debug log for details."));
1584 }
1585 1586 // ********************************************************* Step 5: verify wallet database integrity
1587 for (const auto& client : node.chain_clients) {
1588 if (!client->verify()) {
1589 return false;
1590 }
1591 }
1592 1593 // ********************************************************* Step 6: network initialization
1594 // Note that we absolutely cannot open any actual connections
1595 // until the very end ("start node") as the UTXO/block state
1596 // is not yet setup and may end up being set up twice if we
1597 // need to reindex later.
1598 1599 fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
1600 fDiscover = args.GetBoolArg("-discover", true);
1601 1602 PeerManager::Options peerman_opts{};
1603 ApplyArgsManOptions(args, peerman_opts);
1604 1605 {
1606 // Read asmap file if configured or embedded asmap data and initialize
1607 // Netgroupman with or without it
1608 assert(!node.netgroupman);
1609 if (args.IsArgSet("-asmap") && !args.IsArgNegated("-asmap")) {
1610 uint256 asmap_version{};
1611 if (!args.GetBoolArg("-asmap", false)) {
1612 fs::path asmap_path = args.GetPathArg("-asmap");
1613 if (!asmap_path.is_absolute()) {
1614 asmap_path = args.GetDataDirNet() / asmap_path;
1615 }
1616 1617 // If a specific path was passed with the asmap argument check if
1618 // the file actually exists in that location
1619 if (!fs::exists(asmap_path)) {
1620 InitError(strprintf(_("Could not find asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1621 return false;
1622 }
1623 1624 // If a file exists at the path, try to read the file
1625 std::vector<std::byte> asmap{DecodeAsmap(asmap_path)};
1626 if (asmap.empty()) {
1627 InitError(strprintf(_("Could not parse asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1628 return false;
1629 }
1630 asmap_version = AsmapVersion(asmap);
1631 node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::WithLoadedAsmap(std::move(asmap)));
1632 } else {
1633 #ifdef ENABLE_EMBEDDED_ASMAP
1634 // Use the embedded asmap data
1635 std::span<const std::byte> asmap{node::data::ip_asn};
1636 if (asmap.empty() || !CheckStandardAsmap(asmap)) {
1637 InitError(strprintf(_("Could not read embedded asmap data")));
1638 return false;
1639 }
1640 node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::WithEmbeddedAsmap(asmap));
1641 asmap_version = AsmapVersion(asmap);
1642 LogInfo("Opened asmap data (%zu bytes) from embedded byte array\n", asmap.size());
1643 #else
1644 // If there is no embedded data, fail and report it since
1645 // the user tried to use it
1646 InitError(strprintf(_("Embedded asmap data not available")));
1647 return false;
1648 #endif
1649 }
1650 LogInfo("Using asmap version %s for IP bucketing", asmap_version.ToString());
1651 } else {
1652 node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::NoAsmap());
1653 LogInfo("Using /16 prefix for IP bucketing");
1654 }
1655 1656 // Initialize addrman
1657 assert(!node.addrman);
1658 uiInterface.InitMessage(_("Loading P2P addresses…"));
1659 auto addrman{LoadAddrman(*node.netgroupman, args)};
1660 if (!addrman) return InitError(util::ErrorString(addrman));
1661 node.addrman = std::move(*addrman);
1662 }
1663 1664 FastRandomContext rng;
1665 assert(!node.banman);
1666 node.banman = std::make_unique<BanMan>(args.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
1667 assert(!node.connman);
1668 node.connman = std::make_unique<CConnman>(rng.rand64(),
1669 rng.rand64(),
1670 *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true));
1671 1672 assert(!node.fee_estimator);
1673 // Don't initialize fee estimation with old data if we don't relay transactions,
1674 // as they would never get updated.
1675 if (!peerman_opts.ignore_incoming_txs) {
1676 bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
1677 if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
1678 return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
1679 }
1680 node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
1681 1682 // Flush estimates to disk periodically
1683 CBlockPolicyEstimator* fee_estimator = node.fee_estimator.get();
1684 scheduler.scheduleEvery([fee_estimator] { fee_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
1685 validation_signals.RegisterValidationInterface(fee_estimator);
1686 }
1687 1688 for (const std::string& socket_addr : args.GetArgs("-bind")) {
1689 std::string host_out;
1690 uint16_t port_out{0};
1691 std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind('='));
1692 if (!SplitHostPort(bind_socket_addr, port_out, host_out)) {
1693 return InitError(InvalidPortErrMsg("-bind", socket_addr));
1694 }
1695 }
1696 1697 // sanitize comments per BIP-0014, format user agent and check total size
1698 std::vector<std::string> uacomments;
1699 for (const std::string& cmt : args.GetArgs("-uacomment")) {
1700 if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT))
1701 return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt));
1702 uacomments.push_back(cmt);
1703 }
1704 strSubVersion = FormatSubVersion(UA_NAME, CLIENT_VERSION, uacomments);
1705 if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
1706 return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1707 strSubVersion.size(), MAX_SUBVERSION_LENGTH));
1708 }
1709 1710 // Requesting DNS seeds entails connecting to IPv4/IPv6, which -onlynet options may prohibit:
1711 // If -dnsseed=1 is explicitly specified, abort. If it's left unspecified by the user, we skip
1712 // the DNS seeds by adjusting -dnsseed in InitParameterInteraction.
1713 if (args.GetBoolArg("-dnsseed") == true && !g_reachable_nets.Contains(NET_IPV4) && !g_reachable_nets.Contains(NET_IPV6)) {
1714 return InitError(strprintf(_("Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1715 };
1716 1717 // Check for host lookup allowed before parsing any network related parameters
1718 fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
1719 1720 bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
1721 // -proxy sets a proxy for outgoing network traffic, possibly per network.
1722 // -noproxy, -proxy=0 or -proxy="" can be used to remove the proxy setting, this is the default
1723 Proxy ipv4_proxy;
1724 Proxy ipv6_proxy;
1725 Proxy onion_proxy;
1726 Proxy name_proxy;
1727 Proxy cjdns_proxy;
1728 for (const std::string& param_value : args.GetArgs("-proxy")) {
1729 const auto eq_pos{param_value.rfind('=')};
1730 const std::string proxy_str{param_value.substr(0, eq_pos)}; // e.g. 127.0.0.1:9050=ipv4 -> 127.0.0.1:9050
1731 std::string net_str;
1732 if (eq_pos != std::string::npos) {
1733 if (eq_pos + 1 == param_value.length()) {
1734 return InitError(strprintf(_("Invalid -proxy address or hostname, ends with '=': '%s'"), param_value));
1735 }
1736 net_str = ToLower(param_value.substr(eq_pos + 1)); // e.g. 127.0.0.1:9050=ipv4 -> ipv4
1737 }
1738 1739 Proxy proxy;
1740 if (!proxy_str.empty() && proxy_str != "0") {
1741 if (IsUnixSocketPath(proxy_str)) {
1742 proxy = Proxy{proxy_str, /*tor_stream_isolation=*/proxyRandomize};
1743 } else {
1744 const std::optional<CService> addr{Lookup(proxy_str, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1745 if (!addr.has_value()) {
1746 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1747 }
1748 proxy = Proxy{addr.value(), /*tor_stream_isolation=*/proxyRandomize};
1749 }
1750 if (!proxy.IsValid()) {
1751 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1752 }
1753 }
1754 1755 if (net_str.empty()) { // For all networks.
1756 ipv4_proxy = ipv6_proxy = name_proxy = cjdns_proxy = onion_proxy = proxy;
1757 } else if (net_str == "ipv4") {
1758 ipv4_proxy = name_proxy = proxy;
1759 } else if (net_str == "ipv6") {
1760 ipv6_proxy = name_proxy = proxy;
1761 } else if (net_str == "onion") {
1762 onion_proxy = proxy;
1763 } else if (net_str == "cjdns") {
1764 cjdns_proxy = proxy;
1765 } else {
1766 return InitError(strprintf(_("Unrecognized network in -proxy='%s': '%s'"), param_value, net_str));
1767 }
1768 }
1769 if (ipv4_proxy.IsValid()) {
1770 SetProxy(NET_IPV4, ipv4_proxy);
1771 }
1772 if (ipv6_proxy.IsValid()) {
1773 SetProxy(NET_IPV6, ipv6_proxy);
1774 }
1775 if (name_proxy.IsValid()) {
1776 SetNameProxy(name_proxy);
1777 }
1778 if (cjdns_proxy.IsValid()) {
1779 SetProxy(NET_CJDNS, cjdns_proxy);
1780 }
1781 1782 const bool onlynet_used_with_onion{!onlynets.empty() && g_reachable_nets.Contains(NET_ONION)};
1783 1784 // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
1785 // -noonion (or -onion=0) disables connecting to .onion entirely
1786 // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
1787 std::string onionArg = args.GetArg("-onion", "");
1788 if (onionArg != "") {
1789 if (onionArg == "0") { // Handle -noonion/-onion=0
1790 onion_proxy = Proxy{};
1791 if (onlynet_used_with_onion) {
1792 return InitError(
1793 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1794 "reaching the Tor network is explicitly forbidden: -onion=0"));
1795 }
1796 } else {
1797 if (IsUnixSocketPath(onionArg)) {
1798 onion_proxy = Proxy(onionArg, /*tor_stream_isolation=*/proxyRandomize);
1799 } else {
1800 const std::optional<CService> addr{Lookup(onionArg, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1801 if (!addr.has_value() || !addr->IsValid()) {
1802 return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1803 }
1804 1805 onion_proxy = Proxy(addr.value(), /*tor_stream_isolation=*/proxyRandomize);
1806 }
1807 }
1808 }
1809 1810 const bool listenonion{args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)};
1811 if (onion_proxy.IsValid()) {
1812 SetProxy(NET_ONION, onion_proxy);
1813 } else {
1814 // If -listenonion is set, then we will (try to) connect to the Tor control port
1815 // later from the torcontrol thread and may retrieve the onion proxy from there.
1816 if (onlynet_used_with_onion && !listenonion) {
1817 return InitError(
1818 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1819 "reaching the Tor network is not provided: none of -proxy, -onion or "
1820 "-listenonion is given"));
1821 }
1822 g_reachable_nets.Remove(NET_ONION);
1823 }
1824 1825 for (const std::string& strAddr : args.GetArgs("-externalip")) {
1826 const std::optional<CService> addrLocal{Lookup(strAddr, GetListenPort(), fNameLookup)};
1827 if (addrLocal.has_value() && addrLocal->IsValid())
1828 AddLocal(addrLocal.value(), LOCAL_MANUAL);
1829 else
1830 return InitError(ResolveErrMsg("externalip", strAddr));
1831 }
1832 1833 #ifdef ENABLE_ZMQ
1834 g_zmq_notification_interface = CZMQNotificationInterface::Create(
1835 [&chainman = node.chainman](std::vector<std::byte>& block, const CBlockIndex& index) {
1836 assert(chainman);
1837 if (auto ret{chainman->m_blockman.ReadRawBlock(WITH_LOCK(cs_main, return index.GetBlockPos()))}) {
1838 block = std::move(*ret);
1839 return true;
1840 }
1841 return false;
1842 });
1843 1844 if (g_zmq_notification_interface) {
1845 validation_signals.RegisterValidationInterface(g_zmq_notification_interface.get());
1846 }
1847 #endif
1848 1849 // ********************************************************* Step 7: load block chain
1850 1851 // cache size calculations
1852 node::LogOversizedDbCache(args);
1853 const auto [index_cache_sizes, kernel_cache_sizes] = CalculateCacheSizes(args, g_enabled_filter_types.size());
1854 1855 LogInfo("Cache configuration:");
1856 LogInfo("* Using %.1f MiB for block index database", kernel_cache_sizes.block_tree_db / double(1_MiB));
1857 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1858 LogInfo("* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index / double(1_MiB));
1859 }
1860 if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
1861 LogInfo("* Using %.1f MiB for transaction output spender index database", index_cache_sizes.txospender_index / double(1_MiB));
1862 }
1863 for (BlockFilterType filter_type : g_enabled_filter_types) {
1864 LogInfo("* Using %.1f MiB for %s block filter index database",
1865 index_cache_sizes.filter_index / double(1_MiB), BlockFilterTypeName(filter_type));
1866 }
1867 LogInfo("* Using %.1f MiB for chain state database", kernel_cache_sizes.coins_db / double(1_MiB));
1868 1869 assert(!node.mempool);
1870 assert(!node.chainman);
1871 1872 bool do_reindex{args.GetBoolArg("-reindex", false)};
1873 const bool do_reindex_chainstate{args.GetBoolArg("-reindex-chainstate", false)};
1874 1875 // Chainstate initialization and loading may be retried once with reindexing by GUI users
1876 auto [status, error] = InitAndLoadChainstate(
1877 node,
1878 do_reindex,
1879 do_reindex_chainstate,
1880 kernel_cache_sizes,
1881 args);
1882 if (status == ChainstateLoadStatus::FAILURE && !do_reindex && !ShutdownRequested(node)) {
1883 // suggest a reindex
1884 bool do_retry{HasTestOption(args, "reindex_after_failure_noninteractive_yes") ||
1885 uiInterface.ThreadSafeQuestion(
1886 error + Untranslated(".\n\n") + _("Do you want to rebuild the databases now?"),
1887 error.original + ".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1888 CClientUIInterface::MSG_ERROR | CClientUIInterface::BTN_ABORT)};
1889 if (!do_retry) {
1890 return false;
1891 }
1892 do_reindex = true;
1893 if (!Assert(node.shutdown_signal)->reset()) {
1894 LogError("Internal error: failed to reset shutdown signal.\n");
1895 }
1896 std::tie(status, error) = InitAndLoadChainstate(
1897 node,
1898 do_reindex,
1899 do_reindex_chainstate,
1900 kernel_cache_sizes,
1901 args);
1902 }
1903 if (status != ChainstateLoadStatus::SUCCESS && status != ChainstateLoadStatus::INTERRUPTED) {
1904 return InitError(error);
1905 }
1906 1907 // As LoadBlockIndex can take several minutes, it's possible the user
1908 // requested to kill the GUI during the last operation. If so, exit.
1909 if (ShutdownRequested(node)) {
1910 LogInfo("Shutdown requested. Exiting.");
1911 return true;
1912 }
1913 1914 ChainstateManager& chainman = *Assert(node.chainman);
1915 auto& kernel_notifications{*Assert(node.notifications)};
1916 1917 assert(!node.peerman);
1918 node.peerman = PeerManager::make(*node.connman, *node.addrman,
1919 node.banman.get(), chainman,
1920 *node.mempool, *node.warnings,
1921 peerman_opts);
1922 validation_signals.RegisterValidationInterface(node.peerman.get());
1923 1924 // ********************************************************* Step 8: start indexers
1925 1926 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1927 g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), index_cache_sizes.tx_index, false, do_reindex);
1928 node.indexes.emplace_back(g_txindex.get());
1929 }
1930 1931 if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
1932 g_txospenderindex = std::make_unique<TxoSpenderIndex>(interfaces::MakeChain(node), index_cache_sizes.txospender_index, false, do_reindex);
1933 node.indexes.emplace_back(g_txospenderindex.get());
1934 }
1935 1936 for (const auto& filter_type : g_enabled_filter_types) {
1937 InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, index_cache_sizes.filter_index, false, do_reindex);
1938 node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
1939 }
1940 1941 if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1942 g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, do_reindex);
1943 node.indexes.emplace_back(g_coin_stats_index.get());
1944 }
1945 1946 // Init indexes
1947 for (auto index : node.indexes) if (!index->Init()) return false;
1948 1949 // ********************************************************* Step 9: load wallet
1950 for (const auto& client : node.chain_clients) {
1951 if (!client->load()) {
1952 return false;
1953 }
1954 }
1955 1956 // ********************************************************* Step 10: data directory maintenance
1957 1958 // if pruning, perform the initial blockstore prune
1959 // after any wallet rescanning has taken place.
1960 if (chainman.m_blockman.IsPruneMode()) {
1961 if (chainman.m_blockman.m_blockfiles_indexed) {
1962 LOCK(cs_main);
1963 for (const auto& chainstate : chainman.m_chainstates) {
1964 uiInterface.InitMessage(_("Pruning blockstore…"));
1965 chainstate->PruneAndFlush();
1966 }
1967 }
1968 } else {
1969 // Prior to setting NODE_NETWORK, check if we can provide historical blocks.
1970 if (!WITH_LOCK(chainman.GetMutex(), return chainman.HistoricalChainstate())) {
1971 LogInfo("Setting NODE_NETWORK in non-prune mode");
1972 g_local_services = ServiceFlags(g_local_services | NODE_NETWORK);
1973 } else {
1974 LogInfo("Running node in NODE_NETWORK_LIMITED mode until snapshot background sync completes");
1975 }
1976 }
1977 1978 // ********************************************************* Step 11: import blocks
1979 1980 if (!CheckDiskSpace(args.GetDataDirNet())) {
1981 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetDataDirNet()))));
1982 return false;
1983 }
1984 if (!CheckDiskSpace(args.GetBlocksDirPath())) {
1985 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetBlocksDirPath()))));
1986 return false;
1987 }
1988 1989 int chain_active_height = WITH_LOCK(cs_main, return chainman.ActiveChain().Height());
1990 1991 // On first startup, warn on low block storage space
1992 if (!do_reindex && !do_reindex_chainstate && chain_active_height <= 1) {
1993 uint64_t assumed_chain_bytes{chainparams.AssumedBlockchainSize() * 1_GiB};
1994 uint64_t additional_bytes_needed{
1995 chainman.m_blockman.IsPruneMode() ?
1996 std::min(chainman.m_blockman.GetPruneTarget(), assumed_chain_bytes) :
1997 assumed_chain_bytes};
1998 1999 if (!CheckDiskSpace(args.GetBlocksDirPath(), additional_bytes_needed)) {
2000 InitWarning(strprintf(_(
2001 "Disk space for %s may not accommodate the block files. " \
2002 "Approximately %u GB of data will be stored in this directory."
2003 ),
2004 fs::quoted(fs::PathToString(args.GetBlocksDirPath())),
2005 chainparams.AssumedBlockchainSize()
2006 ));
2007 }
2008 }
2009 2010 #ifdef __APPLE__
2011 auto check_and_warn_fs{[&](const fs::path& path, std::string_view desc) {
2012 const auto path_desc{strprintf("%s (\"%s\")", desc, fs::PathToString(path))};
2013 switch (GetFilesystemType(path)) {
2014 case FSType::EXFAT:
2015 InitWarning(strprintf(_("The %s path uses exFAT, which is known to have intermittent corruption problems on macOS. "
2016 "Move this directory to a different filesystem to avoid data loss."), path_desc));
2017 break;
2018 case FSType::ERROR:
2019 LogInfo("Failed to detect filesystem type for %s", path_desc);
2020 break;
2021 case FSType::OTHER:
2022 break;
2023 }
2024 }};
2025 2026 check_and_warn_fs(args.GetDataDirNet(), "data directory");
2027 check_and_warn_fs(args.GetBlocksDirPath(), "blocks directory");
2028 #endif
2029 2030 #if HAVE_SYSTEM
2031 const std::string block_notify = args.GetArg("-blocknotify", "");
2032 if (!block_notify.empty()) {
2033 uiInterface.NotifyBlockTip.connect([block_notify](SynchronizationState sync_state, const CBlockIndex& block, double /* verification_progress */) {
2034 if (sync_state != SynchronizationState::POST_INIT) return;
2035 std::string command = block_notify;
2036 ReplaceAll(command, "%s", block.GetBlockHash().GetHex());
2037 std::thread t(runCommand, command);
2038 t.detach(); // thread runs free
2039 });
2040 }
2041 #endif
2042 2043 std::vector<fs::path> vImportFiles;
2044 for (const std::string& strFile : args.GetArgs("-loadblock")) {
2045 vImportFiles.push_back(fs::PathFromString(strFile));
2046 }
2047 2048 /// \anchor initload
2049 node.background_init_thread = std::thread(&util::TraceThread, "initload", [=, &chainman, &args, &kernel_notifications, &node] {
2050 ScheduleBatchPriority();
2051 // Import blocks and ActivateBestChain()
2052 ImportBlocks(chainman, vImportFiles);
2053 // An interrupted import may return without activating genesis. Wake
2054 // the init thread's genesis wait, which is otherwise only notified
2055 // on blockTip, and that never fires when the import was interrupted
2056 // before activating genesis. This wakeup lets the wait observe the
2057 // shutdown request.
2058 WITH_LOCK(kernel_notifications.m_tip_block_mutex, kernel_notifications.m_tip_block_cv.notify_all());
2059 WITH_LOCK(::cs_main, chainman.UpdateIBDStatus());
2060 if (args.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) {
2061 LogInfo("Stopping after block import");
2062 if (!(Assert(node.shutdown_request))()) {
2063 LogError("Failed to send shutdown signal after finishing block import\n");
2064 }
2065 return;
2066 }
2067 2068 // Start indexes initial sync
2069 if (!StartIndexBackgroundSync(node)) {
2070 bilingual_str err_str = _("Failed to start indexes, shutting down…");
2071 chainman.GetNotifications().fatalError(err_str);
2072 return;
2073 }
2074 // Load mempool from disk
2075 if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
2076 LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {});
2077 pool->SetLoadTried(!chainman.m_interrupt);
2078 }
2079 });
2080 2081 /*
2082 * Wait for genesis block to be processed. Typically kernel_notifications.m_tip_block
2083 * has already been set by a call to LoadChainTip() in CompleteChainstateInitialization().
2084 * But this is skipped if the chainstate doesn't exist yet or is being wiped:
2085 *
2086 * 1. first startup with an empty datadir
2087 * 2. reindex
2088 * 3. reindex-chainstate
2089 *
2090 * In these case it's connected by a call to ActivateBestChain() in the initload thread.
2091 */
2092 {
2093 WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
2094 kernel_notifications.m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
2095 return kernel_notifications.TipBlock() || ShutdownRequested(node);
2096 });
2097 }
2098 2099 if (ShutdownRequested(node)) {
2100 return true;
2101 }
2102 2103 // ********************************************************* Step 12: start node
2104 2105 int64_t best_block_time{};
2106 {
2107 LOCK(chainman.GetMutex());
2108 const auto& tip{*Assert(chainman.ActiveTip())};
2109 LogInfo("block tree size = %u", chainman.BlockIndex().size());
2110 chain_active_height = tip.nHeight;
2111 best_block_time = tip.GetBlockTime();
2112 if (tip_info) {
2113 tip_info->block_height = chain_active_height;
2114 tip_info->block_time = best_block_time;
2115 tip_info->verification_progress = chainman.GuessVerificationProgress(&tip);
2116 }
2117 if (tip_info && chainman.m_best_header) {
2118 tip_info->header_height = chainman.m_best_header->nHeight;
2119 tip_info->header_time = chainman.m_best_header->GetBlockTime();
2120 }
2121 }
2122 LogInfo("nBestHeight = %d", chain_active_height);
2123 if (node.peerman) node.peerman->SetBestBlock(chain_active_height, std::chrono::seconds{best_block_time});
2124 2125 // Map ports with NAT-PMP
2126 StartMapPort(args.GetBoolArg("-natpmp", DEFAULT_NATPMP));
2127 2128 CConnman::Options connOptions;
2129 connOptions.m_local_services = g_local_services;
2130 connOptions.m_max_automatic_connections = nMaxConnections;
2131 connOptions.uiInterface = &uiInterface;
2132 connOptions.m_banman = node.banman.get();
2133 connOptions.m_msgproc = node.peerman.get();
2134 connOptions.nSendBufferMaxSize = 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
2135 connOptions.nReceiveFloodSize = 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
2136 connOptions.m_added_nodes = args.GetArgs("-addnode");
2137 connOptions.nMaxOutboundLimit = *opt_max_upload;
2138 connOptions.m_peer_connect_timeout = peer_connect_timeout;
2139 connOptions.whitelist_forcerelay = args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
2140 connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
2141 connOptions.m_capture_messages = args.GetBoolArg("-capturemessages", false);
2142 2143 // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
2144 const uint16_t default_bind_port =
2145 static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort()));
2146 2147 const uint16_t default_bind_port_onion = default_bind_port + 1;
2148 2149 const auto BadPortWarning = [](const char* prefix, uint16_t port) {
2150 return strprintf(_("%s request to listen on port %u. This port is considered \"bad\" and "
2151 "thus it is unlikely that any peer will connect to it. See "
2152 "doc/p2p-bad-ports.md for details and a full list."),
2153 prefix,
2154 port);
2155 };
2156 2157 for (const std::string& bind_arg : args.GetArgs("-bind")) {
2158 std::optional<CService> bind_addr;
2159 const size_t index = bind_arg.rfind('=');
2160 if (index == std::string::npos) {
2161 bind_addr = Lookup(bind_arg, default_bind_port, /*fAllowLookup=*/false);
2162 if (bind_addr.has_value()) {
2163 connOptions.vBinds.push_back(bind_addr.value());
2164 if (IsBadPort(bind_addr.value().GetPort())) {
2165 InitWarning(BadPortWarning("-bind", bind_addr.value().GetPort()));
2166 }
2167 continue;
2168 }
2169 } else {
2170 const std::string network_type = bind_arg.substr(index + 1);
2171 if (network_type == "onion") {
2172 const std::string truncated_bind_arg = bind_arg.substr(0, index);
2173 bind_addr = Lookup(truncated_bind_arg, default_bind_port_onion, false);
2174 if (bind_addr.has_value()) {
2175 connOptions.onion_binds.push_back(bind_addr.value());
2176 continue;
2177 }
2178 }
2179 }
2180 return InitError(ResolveErrMsg("bind", bind_arg));
2181 }
2182 2183 for (const std::string& strBind : args.GetArgs("-whitebind")) {
2184 NetWhitebindPermissions whitebind;
2185 bilingual_str error;
2186 if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error);
2187 connOptions.vWhiteBinds.push_back(whitebind);
2188 }
2189 2190 // If the user did not specify -bind= or -whitebind= then we bind
2191 // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
2192 connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
2193 2194 // Emit a warning if a bad port is given to -port= but only if -bind and -whitebind are not
2195 // given, because if they are, then -port= is ignored.
2196 if (connOptions.bind_on_any && args.IsArgSet("-port")) {
2197 const uint16_t port_arg = args.GetIntArg("-port", 0);
2198 if (IsBadPort(port_arg)) {
2199 InitWarning(BadPortWarning("-port", port_arg));
2200 }
2201 }
2202 2203 CService onion_service_target;
2204 if (!connOptions.onion_binds.empty()) {
2205 onion_service_target = connOptions.onion_binds.front();
2206 } else if (!connOptions.vBinds.empty()) {
2207 onion_service_target = connOptions.vBinds.front();
2208 } else {
2209 onion_service_target = DefaultOnionServiceTarget(default_bind_port_onion);
2210 connOptions.onion_binds.push_back(onion_service_target);
2211 }
2212 2213 if (listenonion) {
2214 if (connOptions.onion_binds.size() > 1) {
2215 InitWarning(strprintf(_("More than one onion bind address is provided. Using %s "
2216 "for the automatically created Tor onion service."),
2217 onion_service_target.ToStringAddrPort()));
2218 }
2219 node.tor_controller = std::make_unique<TorController>(gArgs.GetArg("-torcontrol", DEFAULT_TOR_CONTROL), onion_service_target);
2220 }
2221 2222 bool should_discover = connOptions.bind_on_any;
2223 if (!should_discover) {
2224 for (const auto& bind : connOptions.vBinds) {
2225 if (bind.IsBindAny()) {
2226 should_discover = true;
2227 break;
2228 }
2229 }
2230 }
2231 2232 if (!should_discover) {
2233 for (const auto& whitebind : connOptions.vWhiteBinds) {
2234 if (whitebind.m_service.IsBindAny()) {
2235 should_discover = true;
2236 break;
2237 }
2238 }
2239 }
2240 2241 if (should_discover) {
2242 // Only add all IP addresses of the machine if we would be listening on
2243 // any address - 0.0.0.0 (IPv4) and :: (IPv6).
2244 Discover();
2245 }
2246 2247 for (const auto& net : args.GetArgs("-whitelist")) {
2248 NetWhitelistPermissions subnet;
2249 ConnectionDirection connection_direction;
2250 bilingual_str error;
2251 if (!NetWhitelistPermissions::TryParse(net, subnet, connection_direction, error)) return InitError(error);
2252 if (connection_direction & ConnectionDirection::In) {
2253 connOptions.vWhitelistedRangeIncoming.push_back(subnet);
2254 }
2255 if (connection_direction & ConnectionDirection::Out) {
2256 connOptions.vWhitelistedRangeOutgoing.push_back(subnet);
2257 }
2258 }
2259 2260 connOptions.vSeedNodes = args.GetArgs("-seednode");
2261 2262 const auto connect = args.GetArgs("-connect");
2263 if (!connect.empty() || args.IsArgNegated("-connect")) {
2264 // Do not initiate other outgoing connections when connecting to trusted
2265 // nodes, or when -noconnect is specified.
2266 connOptions.m_use_addrman_outgoing = false;
2267 2268 if (connect.size() != 1 || connect[0] != "0") {
2269 connOptions.m_specified_outgoing = connect;
2270 }
2271 if (!connOptions.m_specified_outgoing.empty() && !connOptions.vSeedNodes.empty()) {
2272 LogInfo("-seednode is ignored when -connect is used");
2273 }
2274 2275 if (args.IsArgSet("-dnsseed") && args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED) && args.IsArgSet("-proxy")) {
2276 LogInfo("-dnsseed is ignored when -connect is used and -proxy is specified");
2277 }
2278 }
2279 2280 const std::string& i2psam_arg = args.GetArg("-i2psam", "");
2281 if (!i2psam_arg.empty()) {
2282 const std::optional<CService> addr{Lookup(i2psam_arg, 7656, fNameLookup)};
2283 if (!addr.has_value() || !addr->IsValid()) {
2284 return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
2285 }
2286 SetProxy(NET_I2P, Proxy{addr.value()});
2287 } else {
2288 if (!onlynets.empty() && g_reachable_nets.Contains(NET_I2P)) {
2289 return InitError(
2290 _("Outbound connections restricted to i2p (-onlynet=i2p) but "
2291 "-i2psam is not provided"));
2292 }
2293 g_reachable_nets.Remove(NET_I2P);
2294 }
2295 2296 connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", DEFAULT_I2P_ACCEPT_INCOMING);
2297 2298 if (auto conflict = CheckBindingConflicts(connOptions)) {
2299 return InitError(strprintf(
2300 _("Duplicate binding configuration for address %s. "
2301 "Please check your -bind, -bind=...=onion and -whitebind settings."),
2302 conflict->ToStringAddrPort()));
2303 }
2304 2305 if (args.GetBoolArg("-privatebroadcast", DEFAULT_PRIVATE_BROADCAST)) {
2306 // If -listenonion is set, then NET_ONION may not be reachable now
2307 // but may become reachable later, thus only error here if it is not
2308 // reachable and will not become reachable for sure.
2309 const bool onion_may_become_reachable{listenonion && (!args.IsArgSet("-onlynet") || onlynet_used_with_onion)};
2310 if (!g_reachable_nets.Contains(NET_I2P) &&
2311 !g_reachable_nets.Contains(NET_ONION) &&
2312 !onion_may_become_reachable) {
2313 return InitError(_("Private broadcast of own transactions requested (-privatebroadcast), "
2314 "but none of Tor or I2P networks is reachable"));
2315 }
2316 if (!connOptions.m_use_addrman_outgoing) {
2317 return InitError(_("Private broadcast of own transactions requested (-privatebroadcast), "
2318 "but -connect is also configured. They are incompatible because the "
2319 "private broadcast needs to open new connections to randomly "
2320 "chosen Tor or I2P peers. Consider using -maxconnections=0 -addnode=... "
2321 "instead"));
2322 }
2323 if (!proxyRandomize && (g_reachable_nets.Contains(NET_ONION) || onion_may_become_reachable)) {
2324 InitWarning(_("Private broadcast of own transactions requested (-privatebroadcast) and "
2325 "-proxyrandomize is disabled. Tor circuits for private broadcast connections "
2326 "may be correlated to other connections over Tor. For maximum privacy set "
2327 "-proxyrandomize=1."));
2328 }
2329 }
2330 2331 if (!node.connman->Start(scheduler, connOptions)) {
2332 return false;
2333 }
2334 2335 // ********************************************************* Step 13: finished
2336 2337 // At this point, the RPC is "started", but still in warmup, which means it
2338 // cannot yet be called. Before we make it callable, we need to make sure
2339 // that the RPC's view of the best block is valid and consistent with
2340 // ChainstateManager's active tip.
2341 SetRPCWarmupFinished();
2342 2343 uiInterface.InitMessage(_("Done loading"));
2344 2345 for (const auto& client : node.chain_clients) {
2346 client->start(scheduler);
2347 }
2348 2349 BanMan* banman = node.banman.get();
2350 scheduler.scheduleEvery([banman]{
2351 banman->DumpBanlist();
2352 }, DUMP_BANS_INTERVAL);
2353 2354 if (node.peerman) node.peerman->StartScheduledTasks(scheduler);
2355 2356 #if HAVE_SYSTEM
2357 StartupNotify(args);
2358 #endif
2359 2360 return true;
2361 }
2362 2363 bool StartIndexBackgroundSync(NodeContext& node)
2364 {
2365 ChainstateManager& chainman = *Assert(node.chainman);
2366 const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.ValidatedChainstate());
2367 const CChain& index_chain = chainstate.m_chain;
2368 const int current_height = WITH_LOCK(::cs_main, return index_chain.Height());
2369 2370 // Skip checking data availability if we have not synced any blocks yet
2371 if (current_height > 0) {
2372 // Before starting index sync, verify that all required block data is available
2373 // on disk from each index's current sync position up to the chain tip.
2374 //
2375 // This is done separately for undo and block data: First we verify block + undo
2376 // data existence from tip down to the lowest height required by any index that
2377 // needs undo data (e.g., coinstatsindex, blockfilterindex). Then, if any
2378 // block-only index needs to sync from a lower height than previously covered,
2379 // verify block data existence down to that lower height.
2380 //
2381 // This avoids checking undo data for blocks where no index requires it,
2382 // though currently block and undo data availability are synchronized on disk
2383 // under normal circumstances.
2384 std::optional<const CBlockIndex*> block_start;
2385 std::string block_start_name;
2386 std::optional<const CBlockIndex*> undo_start;
2387 std::string undo_start_name;
2388 2389 for (const auto& index : node.indexes) {
2390 const IndexSummary& summary = index->GetSummary();
2391 if (summary.synced) continue;
2392 2393 // Get the last common block between the index best block and the active chain
2394 const CBlockIndex* pindex = nullptr;
2395 {
2396 LOCK(::cs_main);
2397 pindex = chainman.m_blockman.LookupBlockIndex(summary.best_block_hash);
2398 if (!pindex) {
2399 LogWarning("Failed to find block manager entry for best block %s from %s, falling back to genesis for index sync",
2400 summary.best_block_hash.ToString(), summary.name);
2401 } else if (!index_chain.Contains(*pindex)) {
2402 pindex = index_chain.FindFork(*pindex);
2403 }
2404 }
2405 if (!pindex) {
2406 pindex = index_chain.Genesis();
2407 }
2408 2409 bool need_undo = index->CustomOptions().connect_undo_data;
2410 auto& op_start_index = need_undo ? undo_start : block_start;
2411 auto& name_index = need_undo ? undo_start_name : block_start_name;
2412 2413 if (op_start_index && pindex->nHeight >= op_start_index.value()->nHeight) continue;
2414 op_start_index = pindex;
2415 name_index = summary.name;
2416 }
2417 2418 // Verify all blocks needed to sync to current tip are present including undo data.
2419 if (undo_start) {
2420 LOCK(::cs_main);
2421 if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(undo_start.value()), BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO})) {
2422 return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data (including undo data). Please disable the index or reindex (which will download the whole blockchain again)", undo_start_name)));
2423 }
2424 }
2425 2426 // Verify all blocks needed to sync to current tip are present unless we already checked all of them above.
2427 if (block_start && !(undo_start && undo_start.value()->nHeight <= block_start.value()->nHeight)) {
2428 LOCK(::cs_main);
2429 if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(block_start.value()), BlockStatus{BLOCK_HAVE_DATA})) {
2430 return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data. Please disable the index or reindex (which will download the whole blockchain again)", block_start_name)));
2431 }
2432 }
2433 }
2434 2435 // Start threads
2436 for (auto index : node.indexes) if (!index->StartBackgroundSync()) return false;
2437 return true;
2438 }
2439