init.cpp
1 // Copyright (c) 2009-2010 Satoshi Nakamoto 2 // Copyright (c) 2009-2022 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 #if defined(HAVE_CONFIG_H) 7 #include <config/bitcoin-config.h> 8 #endif 9 10 #include <init.h> 11 12 #include <kernel/checks.h> 13 #include <kernel/mempool_persist.h> 14 #include <kernel/validation_cache_sizes.h> 15 16 #include <addrman.h> 17 #include <banman.h> 18 #include <blockfilter.h> 19 #include <chain.h> 20 #include <chainparams.h> 21 #include <chainparamsbase.h> 22 #include <clientversion.h> 23 #include <common/args.h> 24 #include <common/system.h> 25 #include <consensus/amount.h> 26 #include <deploymentstatus.h> 27 #include <hash.h> 28 #include <httprpc.h> 29 #include <httpserver.h> 30 #include <index/blockfilterindex.h> 31 #include <index/coinstatsindex.h> 32 #include <index/txindex.h> 33 #include <init/common.h> 34 #include <interfaces/chain.h> 35 #include <interfaces/init.h> 36 #include <interfaces/node.h> 37 #include <logging.h> 38 #include <mapport.h> 39 #include <net.h> 40 #include <net_permissions.h> 41 #include <net_processing.h> 42 #include <netbase.h> 43 #include <netgroup.h> 44 #include <node/blockmanager_args.h> 45 #include <node/blockstorage.h> 46 #include <node/caches.h> 47 #include <node/chainstate.h> 48 #include <node/chainstatemanager_args.h> 49 #include <node/context.h> 50 #include <node/interface_ui.h> 51 #include <node/kernel_notifications.h> 52 #include <node/mempool_args.h> 53 #include <node/mempool_persist_args.h> 54 #include <node/miner.h> 55 #include <node/peerman_args.h> 56 #include <node/validation_cache_args.h> 57 #include <policy/feerate.h> 58 #include <policy/fees.h> 59 #include <policy/fees_args.h> 60 #include <policy/policy.h> 61 #include <policy/settings.h> 62 #include <protocol.h> 63 #include <rpc/blockchain.h> 64 #include <rpc/register.h> 65 #include <rpc/server.h> 66 #include <rpc/util.h> 67 #include <scheduler.h> 68 #include <script/sigcache.h> 69 #include <sync.h> 70 #include <timedata.h> 71 #include <torcontrol.h> 72 #include <txdb.h> 73 #include <txmempool.h> 74 #include <util/asmap.h> 75 #include <util/chaintype.h> 76 #include <util/check.h> 77 #include <util/fs.h> 78 #include <util/fs_helpers.h> 79 #include <util/moneystr.h> 80 #include <util/result.h> 81 #include <util/strencodings.h> 82 #include <util/string.h> 83 #include <util/syserror.h> 84 #include <util/thread.h> 85 #include <util/threadnames.h> 86 #include <util/time.h> 87 #include <util/translation.h> 88 #include <validation.h> 89 #include <validationinterface.h> 90 #include <walletinitinterface.h> 91 92 #include <algorithm> 93 #include <condition_variable> 94 #include <cstdint> 95 #include <cstdio> 96 #include <fstream> 97 #include <functional> 98 #include <set> 99 #include <string> 100 #include <thread> 101 #include <vector> 102 103 #ifndef WIN32 104 #include <cerrno> 105 #include <signal.h> 106 #include <sys/stat.h> 107 #endif 108 109 #include <boost/signals2/signal.hpp> 110 111 #if ENABLE_ZMQ 112 #include <zmq/zmqabstractnotifier.h> 113 #include <zmq/zmqnotificationinterface.h> 114 #include <zmq/zmqrpc.h> 115 #endif 116 117 using kernel::DumpMempool; 118 using kernel::LoadMempool; 119 using kernel::ValidationCacheSizes; 120 121 using node::ApplyArgsManOptions; 122 using node::BlockManager; 123 using node::CacheSizes; 124 using node::CalculateCacheSizes; 125 using node::DEFAULT_PERSIST_MEMPOOL; 126 using node::DEFAULT_PRINTPRIORITY; 127 using node::DEFAULT_STOPATHEIGHT; 128 using node::fReindex; 129 using node::KernelNotifications; 130 using node::LoadChainstate; 131 using node::MempoolPath; 132 using node::NodeContext; 133 using node::ShouldPersistMempool; 134 using node::ImportBlocks; 135 using node::VerifyLoadedChainstate; 136 137 static constexpr bool DEFAULT_PROXYRANDOMIZE{true}; 138 static constexpr bool DEFAULT_REST_ENABLE{false}; 139 static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING{true}; 140 static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT{false}; 141 142 #ifdef WIN32 143 // Win32 LevelDB doesn't use filedescriptors, and the ones used for 144 // accessing block files don't count towards the fd_set size limit 145 // anyway. 146 #define MIN_CORE_FILEDESCRIPTORS 0 147 #else 148 #define MIN_CORE_FILEDESCRIPTORS 150 149 #endif 150 151 static const char* DEFAULT_ASMAP_FILENAME="ip_asn.map"; 152 153 /** 154 * The PID file facilities. 155 */ 156 static const char* BITCOIN_PID_FILENAME = "bitcoind.pid"; 157 /** 158 * True if this process has created a PID file. 159 * Used to determine whether we should remove the PID file on shutdown. 160 */ 161 static bool g_generated_pid{false}; 162 163 static fs::path GetPidFile(const ArgsManager& args) 164 { 165 return AbsPathForConfigVal(args, args.GetPathArg("-pid", BITCOIN_PID_FILENAME)); 166 } 167 168 [[nodiscard]] static bool CreatePidFile(const ArgsManager& args) 169 { 170 std::ofstream file{GetPidFile(args)}; 171 if (file) { 172 #ifdef WIN32 173 tfm::format(file, "%d\n", GetCurrentProcessId()); 174 #else 175 tfm::format(file, "%d\n", getpid()); 176 #endif 177 g_generated_pid = true; 178 return true; 179 } else { 180 return InitError(strprintf(_("Unable to create the PID file '%s': %s"), fs::PathToString(GetPidFile(args)), SysErrorString(errno))); 181 } 182 } 183 184 static void RemovePidFile(const ArgsManager& args) 185 { 186 if (!g_generated_pid) return; 187 const auto pid_path{GetPidFile(args)}; 188 if (std::error_code error; !fs::remove(pid_path, error)) { 189 std::string msg{error ? error.message() : "File does not exist"}; 190 LogPrintf("Unable to remove PID file (%s): %s\n", fs::PathToString(pid_path), msg); 191 } 192 } 193 194 static std::optional<util::SignalInterrupt> g_shutdown; 195 196 void InitContext(NodeContext& node) 197 { 198 assert(!g_shutdown); 199 g_shutdown.emplace(); 200 201 node.args = &gArgs; 202 node.shutdown = &*g_shutdown; 203 } 204 205 ////////////////////////////////////////////////////////////////////////////// 206 // 207 // Shutdown 208 // 209 210 // 211 // Thread management and startup/shutdown: 212 // 213 // The network-processing threads are all part of a thread group 214 // created by AppInit() or the Qt main() function. 215 // 216 // A clean exit happens when the SignalInterrupt object is triggered, which 217 // makes the main thread's SignalInterrupt::wait() call return, and join all 218 // other ongoing threads in the thread group to the main thread. 219 // Shutdown() is then called to clean up database connections, and stop other 220 // threads that should only be stopped after the main network-processing 221 // threads have exited. 222 // 223 // Shutdown for Qt is very similar, only it uses a QTimer to detect 224 // ShutdownRequested() getting set, and then does the normal Qt 225 // shutdown thing. 226 // 227 228 bool ShutdownRequested(node::NodeContext& node) 229 { 230 return bool{*Assert(node.shutdown)}; 231 } 232 233 #if HAVE_SYSTEM 234 static void ShutdownNotify(const ArgsManager& args) 235 { 236 std::vector<std::thread> threads; 237 for (const auto& cmd : args.GetArgs("-shutdownnotify")) { 238 threads.emplace_back(runCommand, cmd); 239 } 240 for (auto& t : threads) { 241 t.join(); 242 } 243 } 244 #endif 245 246 void Interrupt(NodeContext& node) 247 { 248 #if HAVE_SYSTEM 249 ShutdownNotify(*node.args); 250 #endif 251 InterruptHTTPServer(); 252 InterruptHTTPRPC(); 253 InterruptRPC(); 254 InterruptREST(); 255 InterruptTorControl(); 256 InterruptMapPort(); 257 if (node.connman) 258 node.connman->Interrupt(); 259 for (auto* index : node.indexes) { 260 index->Interrupt(); 261 } 262 } 263 264 void Shutdown(NodeContext& node) 265 { 266 static Mutex g_shutdown_mutex; 267 TRY_LOCK(g_shutdown_mutex, lock_shutdown); 268 if (!lock_shutdown) return; 269 LogPrintf("%s: In progress...\n", __func__); 270 Assert(node.args); 271 272 /// Note: Shutdown() must be able to handle cases in which initialization failed part of the way, 273 /// for example if the data directory was found to be locked. 274 /// Be sure that anything that writes files or flushes caches only does this if the respective 275 /// module was initialized. 276 util::ThreadRename("shutoff"); 277 if (node.mempool) node.mempool->AddTransactionsUpdated(1); 278 279 StopHTTPRPC(); 280 StopREST(); 281 StopRPC(); 282 StopHTTPServer(); 283 for (const auto& client : node.chain_clients) { 284 client->flush(); 285 } 286 StopMapPort(); 287 288 // Because these depend on each-other, we make sure that neither can be 289 // using the other before destroying them. 290 if (node.peerman && node.validation_signals) node.validation_signals->UnregisterValidationInterface(node.peerman.get()); 291 if (node.connman) node.connman->Stop(); 292 293 StopTorControl(); 294 295 // After everything has been shut down, but before things get flushed, stop the 296 // scheduler and load block thread. 297 if (node.scheduler) node.scheduler->stop(); 298 if (node.chainman && node.chainman->m_thread_load.joinable()) node.chainman->m_thread_load.join(); 299 300 // After the threads that potentially access these pointers have been stopped, 301 // destruct and reset all to nullptr. 302 node.peerman.reset(); 303 node.connman.reset(); 304 node.banman.reset(); 305 node.addrman.reset(); 306 node.netgroupman.reset(); 307 308 if (node.mempool && node.mempool->GetLoadTried() && ShouldPersistMempool(*node.args)) { 309 DumpMempool(*node.mempool, MempoolPath(*node.args)); 310 } 311 312 // Drop transactions we were still watching, record fee estimations and unregister 313 // fee estimator from validation interface. 314 if (node.fee_estimator) { 315 node.fee_estimator->Flush(); 316 if (node.validation_signals) { 317 node.validation_signals->UnregisterValidationInterface(node.fee_estimator.get()); 318 } 319 } 320 321 // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing 322 if (node.chainman) { 323 LOCK(cs_main); 324 for (Chainstate* chainstate : node.chainman->GetAll()) { 325 if (chainstate->CanFlushToDisk()) { 326 chainstate->ForceFlushStateToDisk(); 327 } 328 } 329 } 330 331 // After there are no more peers/RPC left to give us new data which may generate 332 // CValidationInterface callbacks, flush them... 333 if (node.validation_signals) node.validation_signals->FlushBackgroundCallbacks(); 334 335 // Stop and delete all indexes only after flushing background callbacks. 336 for (auto* index : node.indexes) index->Stop(); 337 if (g_txindex) g_txindex.reset(); 338 if (g_coin_stats_index) g_coin_stats_index.reset(); 339 DestroyAllBlockFilterIndexes(); 340 node.indexes.clear(); // all instances are nullptr now 341 342 // Any future callbacks will be dropped. This should absolutely be safe - if 343 // missing a callback results in an unrecoverable situation, unclean shutdown 344 // would too. The only reason to do the above flushes is to let the wallet catch 345 // up with our current chain to avoid any strange pruning edge cases and make 346 // next startup faster by avoiding rescan. 347 348 if (node.chainman) { 349 LOCK(cs_main); 350 for (Chainstate* chainstate : node.chainman->GetAll()) { 351 if (chainstate->CanFlushToDisk()) { 352 chainstate->ForceFlushStateToDisk(); 353 chainstate->ResetCoinsViews(); 354 } 355 } 356 } 357 for (const auto& client : node.chain_clients) { 358 client->stop(); 359 } 360 361 #if ENABLE_ZMQ 362 if (g_zmq_notification_interface) { 363 if (node.validation_signals) node.validation_signals->UnregisterValidationInterface(g_zmq_notification_interface.get()); 364 g_zmq_notification_interface.reset(); 365 } 366 #endif 367 368 node.chain_clients.clear(); 369 if (node.validation_signals) { 370 node.validation_signals->UnregisterAllValidationInterfaces(); 371 } 372 node.mempool.reset(); 373 node.fee_estimator.reset(); 374 node.chainman.reset(); 375 node.validation_signals.reset(); 376 node.scheduler.reset(); 377 node.kernel.reset(); 378 379 RemovePidFile(*node.args); 380 381 LogPrintf("%s: done\n", __func__); 382 } 383 384 /** 385 * Signal handlers are very limited in what they are allowed to do. 386 * The execution context the handler is invoked in is not guaranteed, 387 * so we restrict handler operations to just touching variables: 388 */ 389 #ifndef WIN32 390 static void HandleSIGTERM(int) 391 { 392 // Return value is intentionally ignored because there is not a better way 393 // of handling this failure in a signal handler. 394 (void)(*Assert(g_shutdown))(); 395 } 396 397 static void HandleSIGHUP(int) 398 { 399 LogInstance().m_reopen_file = true; 400 } 401 #else 402 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType) 403 { 404 if (!(*Assert(g_shutdown))()) { 405 LogPrintf("Error: failed to send shutdown signal on Ctrl-C\n"); 406 return false; 407 } 408 Sleep(INFINITE); 409 return true; 410 } 411 #endif 412 413 #ifndef WIN32 414 static void registerSignalHandler(int signal, void(*handler)(int)) 415 { 416 struct sigaction sa; 417 sa.sa_handler = handler; 418 sigemptyset(&sa.sa_mask); 419 sa.sa_flags = 0; 420 sigaction(signal, &sa, nullptr); 421 } 422 #endif 423 424 static boost::signals2::connection rpc_notify_block_change_connection; 425 static void OnRPCStarted() 426 { 427 rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(std::bind(RPCNotifyBlockChange, std::placeholders::_2)); 428 } 429 430 static void OnRPCStopped() 431 { 432 rpc_notify_block_change_connection.disconnect(); 433 RPCNotifyBlockChange(nullptr); 434 g_best_block_cv.notify_all(); 435 LogPrint(BCLog::RPC, "RPC stopped.\n"); 436 } 437 438 void SetupServerArgs(ArgsManager& argsman) 439 { 440 SetupHelpOptions(argsman); 441 argsman.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now 442 443 init::AddLoggingArgs(argsman); 444 445 const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN); 446 const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET); 447 const auto signetBaseParams = CreateBaseChainParams(ChainType::SIGNET); 448 const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST); 449 const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN); 450 const auto testnetChainParams = CreateChainParams(argsman, ChainType::TESTNET); 451 const auto signetChainParams = CreateChainParams(argsman, ChainType::SIGNET); 452 const auto regtestChainParams = CreateChainParams(argsman, ChainType::REGTEST); 453 454 // Hidden Options 455 std::vector<std::string> hidden_args = { 456 "-dbcrashratio", "-forcecompactdb", 457 // GUI args. These will be overwritten by SetupUIArgs for the GUI 458 "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-splash", "-uiplatform"}; 459 460 argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 461 #if HAVE_SYSTEM 462 argsman.AddArg("-alertnotify=<cmd>", "Execute command when an alert is raised (%s in cmd is replaced by message)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 463 #endif 464 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, testnet: %s, signet: %s)", defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnetChainParams->GetConsensus().defaultAssumeValid.GetHex(), signetChainParams->GetConsensus().defaultAssumeValid.GetHex()), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 465 argsman.AddArg("-blocksdir=<dir>", "Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 466 argsman.AddArg("-fastprune", "Use smaller block files and lower minimum prune height for testing purposes", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 467 #if HAVE_SYSTEM 468 argsman.AddArg("-blocknotify=<cmd>", "Execute command when the best block changes (%s in cmd is replaced by block hash)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 469 #endif 470 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); 471 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); 472 argsman.AddArg("-coinstatsindex", strprintf("Maintain coinstats index used by the gettxoutsetinfo RPC (default: %u)", DEFAULT_COINSTATSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 473 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); 474 argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 475 argsman.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", nDefaultDbBatchSize), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS); 476 argsman.AddArg("-dbcache=<n>", strprintf("Maximum database cache size <n> MiB (%d to %d, default: %d). In addition, unused mempool memory is shared for this cache (see -maxmempool).", nMinDbCache, nMaxDbCache, nDefaultDbCache), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 477 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); 478 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); 479 argsman.AddArg("-loadblock=<file>", "Imports blocks from external file on startup", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 480 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); 481 argsman.AddArg("-maxorphantx=<n>", strprintf("Keep at most <n> unconnectable transactions in memory (default: %u)", DEFAULT_MAX_ORPHAN_TRANSACTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 482 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); 483 argsman.AddArg("-minimumchainwork=<hex>", strprintf("Minimum work assumed to exist on a valid chain in hex (default: %s, testnet: %s, signet: %s)", defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnetChainParams->GetConsensus().nMinimumChainWork.GetHex(), signetChainParams->GetConsensus().nMinimumChainWork.GetHex()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS); 484 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)", 485 MAX_SCRIPTCHECK_THREADS, DEFAULT_SCRIPTCHECK_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 486 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); 487 argsman.AddArg("-persistmempoolv1", 488 strprintf("Whether a mempool.dat file created by -persistmempool or the savemempool RPC will be written in the legacy format " 489 "(version 1) or the current format (version 2). This temporary option will be removed in the future. (default: %u)", 490 DEFAULT_PERSIST_V1_DAT), 491 ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 492 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); 493 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. " 494 "Warning: Reverting this setting requires re-downloading the entire blockchain. " 495 "(default: 0 = disable pruning blocks, 1 = allow manual pruning via RPC, >=%u = automatically prune block files to stay under the specified target size in MiB)", MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 496 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); 497 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); 498 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); 499 #if HAVE_SYSTEM 500 argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 501 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); 502 #endif 503 argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 504 argsman.AddArg("-blockfilterindex=<type>", 505 strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) + 506 " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.", 507 ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 508 509 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); 510 argsman.AddArg("-asmap=<file>", strprintf("Specify asn mapping used for bucketing of the peers (default: %s). Relative paths will be prefixed by the net-specific datadir location.", DEFAULT_ASMAP_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 511 argsman.AddArg("-bantime=<n>", strprintf("Default duration (in seconds) of manually configured bans (default: %u)", DEFAULT_MISBEHAVING_BANTIME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 512 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, testnet: 127.0.0.1:%u=onion, signet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)", defaultBaseParams->OnionServiceTargetPort(), testnetBaseParams->OnionServiceTargetPort(), signetBaseParams->OnionServiceTargetPort(), regtestBaseParams->OnionServiceTargetPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION); 513 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); 514 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); 515 argsman.AddArg("-discover", "Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 516 argsman.AddArg("-dns", strprintf("Allow DNS lookups for -addnode, -seednode and -connect (default: %u)", DEFAULT_NAME_LOOKUP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 517 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); 518 argsman.AddArg("-externalip=<ip>", "Specify your own public address", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 519 argsman.AddArg("-fixedseeds", strprintf("Allow fixed seeds if DNS seeds don't provide peers (default: %u)", DEFAULT_FIXEDSEEDS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 520 argsman.AddArg("-forcednsseed", strprintf("Always query for peer addresses via DNS lookup (default: %u)", DEFAULT_FORCEDNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 521 argsman.AddArg("-listen", strprintf("Accept connections from outside (default: %u if no -proxy, -connect or -maxconnections=0)", DEFAULT_LISTEN), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 522 argsman.AddArg("-listenonion", strprintf("Automatically create Tor onion service (default: %d)", DEFAULT_LISTEN_ONION), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 523 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.", DEFAULT_MAX_PEER_CONNECTIONS, MAX_ADDNODE_CONNECTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 524 argsman.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 525 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); 526 argsman.AddArg("-maxtimeadjustment", strprintf("Maximum allowed median peer time offset adjustment. Local perspective of time may be influenced by outbound peers forward or backward by this amount (default: %u seconds).", DEFAULT_MAX_TIME_ADJUSTMENT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 527 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); 528 #if HAVE_SOCKADDR_UN 529 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); 530 #else 531 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); 532 #endif 533 argsman.AddArg("-i2psam=<ip:port>", "I2P SAM proxy to reach I2P peers and accept I2P connections (default: none)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 534 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); 535 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); 536 argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 537 argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 538 argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 539 argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION); 540 // TODO: remove the sentence "Nodes not using ... incoming connections." once the changes from 541 // https://github.com/bitcoin/bitcoin/pull/23542 have become widespread. 542 argsman.AddArg("-port=<port>", strprintf("Listen for connections on <port>. Nodes not using the default ports (default: %u, testnet: %u, signet: %u, regtest: %u) are unlikely to get incoming connections. Not relevant for I2P (see doc/i2p.md).", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), signetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION); 543 #if HAVE_SOCKADDR_UN 544 argsman.AddArg("-proxy=<ip:port|path>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled). May be a local file path prefixed with 'unix:' if the proxy supports it.", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION, OptionsCategory::CONNECTION); 545 #else 546 argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled)", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION, OptionsCategory::CONNECTION); 547 #endif 548 argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 549 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.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 550 argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 551 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); 552 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); 553 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); 554 argsman.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::CONNECTION); 555 #ifdef USE_UPNP 556 #if USE_UPNP 557 argsman.AddArg("-upnp", "Use UPnP to map the listening port (default: 1 when listening and no -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 558 #else 559 argsman.AddArg("-upnp", strprintf("Use UPnP to map the listening port (default: %u)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 560 #endif 561 #else 562 hidden_args.emplace_back("-upnp"); 563 #endif 564 #ifdef USE_NATPMP 565 argsman.AddArg("-natpmp", strprintf("Use NAT-PMP to map the listening port (default: %s)", DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 566 #else 567 hidden_args.emplace_back("-natpmp"); 568 #endif // USE_NATPMP 569 argsman.AddArg("-whitebind=<[permissions@]addr>", "Bind to the given address and add permission flags to the peers connecting to it. " 570 "Use [host]:port notation for IPv6. Allowed permissions: " + Join(NET_PERMISSIONS_DOC, ", ") + ". " 571 "Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 572 573 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 " 574 "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as " 575 "-whitebind. " 576 "Additional flags \"in\" and \"out\" control whether permissions apply to incoming connections and/or manual (default: incoming only). " 577 "Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION); 578 579 g_wallet_init_interface.AddWalletOptions(argsman); 580 581 #if ENABLE_ZMQ 582 argsman.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ); 583 argsman.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ); 584 argsman.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ); 585 argsman.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ); 586 argsman.AddArg("-zmqpubsequence=<address>", "Enable publish hash block and tx sequence in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ); 587 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); 588 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); 589 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); 590 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); 591 argsman.AddArg("-zmqpubsequencehwm=<n>", strprintf("Set publish hash sequence message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ); 592 #else 593 hidden_args.emplace_back("-zmqpubhashblock=<address>"); 594 hidden_args.emplace_back("-zmqpubhashtx=<address>"); 595 hidden_args.emplace_back("-zmqpubrawblock=<address>"); 596 hidden_args.emplace_back("-zmqpubrawtx=<address>"); 597 hidden_args.emplace_back("-zmqpubsequence=<n>"); 598 hidden_args.emplace_back("-zmqpubhashblockhwm=<n>"); 599 hidden_args.emplace_back("-zmqpubhashtxhwm=<n>"); 600 hidden_args.emplace_back("-zmqpubrawblockhwm=<n>"); 601 hidden_args.emplace_back("-zmqpubrawtxhwm=<n>"); 602 hidden_args.emplace_back("-zmqpubsequencehwm=<n>"); 603 #endif 604 605 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); 606 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); 607 argsman.AddArg("-checkblockindex", strprintf("Do a consistency check for the block tree, chainstate, and other validation data structures occasionally. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 608 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); 609 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); 610 argsman.AddArg("-checkpoints", strprintf("Enable rejection of any forks from the known historical chain until block %s (default: %u)", defaultChainParams->Checkpoints().GetHeight(), DEFAULT_CHECKPOINTS_ENABLED), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 611 argsman.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 612 argsman.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 613 argsman.AddArg("-stopatheight", strprintf("Stop running after reaching the given height in the main chain (default: %u)", DEFAULT_STOPATHEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 614 argsman.AddArg("-limitancestorcount=<n>", strprintf("Do not accept transactions if number of in-mempool ancestors is <n> or more (default: %u)", DEFAULT_ANCESTOR_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 615 argsman.AddArg("-limitancestorsize=<n>", strprintf("Do not accept transactions whose size with all in-mempool ancestors exceeds <n> kilobytes (default: %u)", DEFAULT_ANCESTOR_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 616 argsman.AddArg("-limitdescendantcount=<n>", strprintf("Do not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u)", DEFAULT_DESCENDANT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 617 argsman.AddArg("-limitdescendantsize=<n>", strprintf("Do not accept transactions if any ancestor would have more than <n> kilobytes of in-mempool descendants (default: %u).", DEFAULT_DESCENDANT_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 618 argsman.AddArg("-test=<option>", "Pass a test-only option. Options include : " + Join(TEST_OPTIONS_DOC, ", ") + ".", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 619 argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 620 argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 621 argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_BYTES >> 20), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 622 argsman.AddArg("-maxtipage=<n>", 623 strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)", 624 Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)), 625 ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 626 argsman.AddArg("-printpriority", strprintf("Log transaction fee rate in " + CURRENCY_UNIT + "/kvB when mining blocks (default: %u)", DEFAULT_PRINTPRIORITY), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST); 627 argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); 628 629 SetupChainParamsBaseOptions(argsman); 630 631 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); 632 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); 633 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); 634 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); 635 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); 636 argsman.AddArg("-datacarrier", strprintf("Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY); 637 argsman.AddArg("-datacarriersize", 638 strprintf("Relay and mine transactions whose data-carrying raw scriptPubKey " 639 "is of this size or less (default: %u)", 640 MAX_OP_RETURN_RELAY), 641 ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY); 642 argsman.AddArg("-mempoolfullrbf", strprintf("Accept transaction replace-by-fee without requiring replaceability signaling (default: %u)", DEFAULT_MEMPOOL_FULL_RBF), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY); 643 argsman.AddArg("-permitbaremultisig", strprintf("Relay non-P2SH multisig (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY, 644 OptionsCategory::NODE_RELAY); 645 argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)", 646 CURRENCY_UNIT, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY); 647 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); 648 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); 649 650 651 argsman.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION); 652 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); 653 argsman.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION); 654 655 argsman.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC); 656 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). This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC); 657 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); 658 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); 659 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); 660 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); 661 argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC); 662 argsman.AddArg("-rpcport=<port>", strprintf("Listen for JSON-RPC connections on <port> (default: %u, testnet: %u, signet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), signetBaseParams->RPCPort(), regtestBaseParams->RPCPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC); 663 argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC); 664 argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC); 665 argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC); 666 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); 667 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); 668 argsman.AddArg("-rpcworkqueue=<n>", strprintf("Set the depth of the work queue to service RPC calls (default: %d)", DEFAULT_HTTP_WORKQUEUE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC); 669 argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC); 670 671 #if HAVE_DECL_FORK 672 argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 673 argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 674 #else 675 hidden_args.emplace_back("-daemon"); 676 hidden_args.emplace_back("-daemonwait"); 677 #endif 678 679 // Add the hidden options 680 argsman.AddHiddenArgs(hidden_args); 681 } 682 683 static bool fHaveGenesis = false; 684 static GlobalMutex g_genesis_wait_mutex; 685 static std::condition_variable g_genesis_wait_cv; 686 687 static void BlockNotifyGenesisWait(const CBlockIndex* pBlockIndex) 688 { 689 if (pBlockIndex != nullptr) { 690 { 691 LOCK(g_genesis_wait_mutex); 692 fHaveGenesis = true; 693 } 694 g_genesis_wait_cv.notify_all(); 695 } 696 } 697 698 #if HAVE_SYSTEM 699 static void StartupNotify(const ArgsManager& args) 700 { 701 std::string cmd = args.GetArg("-startupnotify", ""); 702 if (!cmd.empty()) { 703 std::thread t(runCommand, cmd); 704 t.detach(); // thread runs free 705 } 706 } 707 #endif 708 709 static bool AppInitServers(NodeContext& node) 710 { 711 const ArgsManager& args = *Assert(node.args); 712 RPCServer::OnStarted(&OnRPCStarted); 713 RPCServer::OnStopped(&OnRPCStopped); 714 if (!InitHTTPServer(*Assert(node.shutdown))) { 715 return false; 716 } 717 StartRPC(); 718 node.rpc_interruption_point = RpcInterruptionPoint; 719 if (!StartHTTPRPC(&node)) 720 return false; 721 if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) StartREST(&node); 722 StartHTTPServer(); 723 return true; 724 } 725 726 // Parameter interaction based on rules 727 void InitParameterInteraction(ArgsManager& args) 728 { 729 // when specifying an explicit binding address, you want to listen on it 730 // even when -connect or -proxy is specified 731 if (args.IsArgSet("-bind")) { 732 if (args.SoftSetBoolArg("-listen", true)) 733 LogPrintf("%s: parameter interaction: -bind set -> setting -listen=1\n", __func__); 734 } 735 if (args.IsArgSet("-whitebind")) { 736 if (args.SoftSetBoolArg("-listen", true)) 737 LogPrintf("%s: parameter interaction: -whitebind set -> setting -listen=1\n", __func__); 738 } 739 740 if (args.IsArgSet("-connect") || args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS) <= 0) { 741 // when only connecting to trusted nodes, do not seed via DNS, or listen by default 742 if (args.SoftSetBoolArg("-dnsseed", false)) 743 LogPrintf("%s: parameter interaction: -connect or -maxconnections=0 set -> setting -dnsseed=0\n", __func__); 744 if (args.SoftSetBoolArg("-listen", false)) 745 LogPrintf("%s: parameter interaction: -connect or -maxconnections=0 set -> setting -listen=0\n", __func__); 746 } 747 748 std::string proxy_arg = args.GetArg("-proxy", ""); 749 if (proxy_arg != "" && proxy_arg != "0") { 750 // to protect privacy, do not listen by default if a default proxy server is specified 751 if (args.SoftSetBoolArg("-listen", false)) 752 LogPrintf("%s: parameter interaction: -proxy set -> setting -listen=0\n", __func__); 753 // to protect privacy, do not map ports when a proxy is set. The user may still specify -listen=1 754 // to listen locally, so don't rely on this happening through -listen below. 755 if (args.SoftSetBoolArg("-upnp", false)) 756 LogPrintf("%s: parameter interaction: -proxy set -> setting -upnp=0\n", __func__); 757 if (args.SoftSetBoolArg("-natpmp", false)) { 758 LogPrintf("%s: parameter interaction: -proxy set -> setting -natpmp=0\n", __func__); 759 } 760 // to protect privacy, do not discover addresses by default 761 if (args.SoftSetBoolArg("-discover", false)) 762 LogPrintf("%s: parameter interaction: -proxy set -> setting -discover=0\n", __func__); 763 } 764 765 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) { 766 // do not map ports or try to retrieve public IP when not listening (pointless) 767 if (args.SoftSetBoolArg("-upnp", false)) 768 LogPrintf("%s: parameter interaction: -listen=0 -> setting -upnp=0\n", __func__); 769 if (args.SoftSetBoolArg("-natpmp", false)) { 770 LogPrintf("%s: parameter interaction: -listen=0 -> setting -natpmp=0\n", __func__); 771 } 772 if (args.SoftSetBoolArg("-discover", false)) 773 LogPrintf("%s: parameter interaction: -listen=0 -> setting -discover=0\n", __func__); 774 if (args.SoftSetBoolArg("-listenonion", false)) 775 LogPrintf("%s: parameter interaction: -listen=0 -> setting -listenonion=0\n", __func__); 776 if (args.SoftSetBoolArg("-i2pacceptincoming", false)) { 777 LogPrintf("%s: parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n", __func__); 778 } 779 } 780 781 if (args.IsArgSet("-externalip")) { 782 // if an explicit public IP is specified, do not try to find others 783 if (args.SoftSetBoolArg("-discover", false)) 784 LogPrintf("%s: parameter interaction: -externalip set -> setting -discover=0\n", __func__); 785 } 786 787 if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) { 788 // disable whitelistrelay in blocksonly mode 789 if (args.SoftSetBoolArg("-whitelistrelay", false)) 790 LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n", __func__); 791 // Reduce default mempool size in blocksonly mode to avoid unexpected resource usage 792 if (args.SoftSetArg("-maxmempool", ToString(DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB))) 793 LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting -maxmempool=%d\n", __func__, DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB); 794 } 795 796 // Forcing relay from whitelisted hosts implies we will accept relays from them in the first place. 797 if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) { 798 if (args.SoftSetBoolArg("-whitelistrelay", true)) 799 LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n", __func__); 800 } 801 if (args.IsArgSet("-onlynet")) { 802 const auto onlynets = args.GetArgs("-onlynet"); 803 bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](const auto& net) { 804 const auto n = ParseNetwork(net); 805 return n == NET_IPV4 || n == NET_IPV6; 806 }); 807 if (!clearnet_reachable && args.SoftSetBoolArg("-dnsseed", false)) { 808 LogPrintf("%s: parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n", __func__); 809 } 810 } 811 } 812 813 /** 814 * Initialize global loggers. 815 * 816 * Note that this is called very early in the process lifetime, so you should be 817 * careful about what global state you rely on here. 818 */ 819 void InitLogging(const ArgsManager& args) 820 { 821 init::SetLoggingOptions(args); 822 init::LogPackageVersion(); 823 } 824 825 namespace { // Variables internal to initialization process only 826 827 int nMaxConnections; 828 int nUserMaxConnections; 829 int nFD; 830 ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS); 831 int64_t peer_connect_timeout; 832 std::set<BlockFilterType> g_enabled_filter_types; 833 834 } // namespace 835 836 [[noreturn]] static void new_handler_terminate() 837 { 838 // Rather than throwing std::bad-alloc if allocation fails, terminate 839 // immediately to (try to) avoid chain corruption. 840 // Since LogPrintf may itself allocate memory, set the handler directly 841 // to terminate first. 842 std::set_new_handler(std::terminate); 843 LogPrintf("Error: Out of memory. Terminating.\n"); 844 845 // The log was successful, terminate now. 846 std::terminate(); 847 }; 848 849 bool AppInitBasicSetup(const ArgsManager& args, std::atomic<int>& exit_status) 850 { 851 // ********************************************************* Step 1: setup 852 #ifdef _MSC_VER 853 // Turn off Microsoft heap dump noise 854 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE); 855 _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, 0)); 856 // Disable confusing "helpful" text message on abort, Ctrl-C 857 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); 858 #endif 859 #ifdef WIN32 860 // Enable heap terminate-on-corruption 861 HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, 0); 862 #endif 863 if (!SetupNetworking()) { 864 return InitError(Untranslated("Initializing networking failed.")); 865 } 866 867 #ifndef WIN32 868 // Clean shutdown on SIGTERM 869 registerSignalHandler(SIGTERM, HandleSIGTERM); 870 registerSignalHandler(SIGINT, HandleSIGTERM); 871 872 // Reopen debug.log on SIGHUP 873 registerSignalHandler(SIGHUP, HandleSIGHUP); 874 875 // Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly 876 signal(SIGPIPE, SIG_IGN); 877 #else 878 SetConsoleCtrlHandler(consoleCtrlHandler, true); 879 #endif 880 881 std::set_new_handler(new_handler_terminate); 882 883 return true; 884 } 885 886 bool AppInitParameterInteraction(const ArgsManager& args) 887 { 888 const CChainParams& chainparams = Params(); 889 // ********************************************************* Step 2: parameter interactions 890 891 // also see: InitParameterInteraction() 892 893 // Error if network-specific options (-addnode, -connect, etc) are 894 // specified in default section of config file, but not overridden 895 // on the command line or in this chain's section of the config file. 896 ChainType chain = args.GetChainType(); 897 if (chain == ChainType::SIGNET) { 898 LogPrintf("Signet derived magic (message start): %s\n", HexStr(chainparams.MessageStart())); 899 } 900 bilingual_str errors; 901 for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) { 902 errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section.") + Untranslated("\n"), arg, ChainTypeToString(chain), ChainTypeToString(chain)); 903 } 904 905 if (!errors.empty()) { 906 return InitError(errors); 907 } 908 909 // Warn if unrecognized section name are present in the config file. 910 bilingual_str warnings; 911 for (const auto& section : args.GetUnrecognizedSections()) { 912 warnings += strprintf(Untranslated("%s:%i ") + _("Section [%s] is not recognized.") + Untranslated("\n"), section.m_file, section.m_line, section.m_name); 913 } 914 915 if (!warnings.empty()) { 916 InitWarning(warnings); 917 } 918 919 if (!fs::is_directory(args.GetBlocksDirPath())) { 920 return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", ""))); 921 } 922 923 // parse and validate enabled filter types 924 std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX); 925 if (blockfilterindex_value == "" || blockfilterindex_value == "1") { 926 g_enabled_filter_types = AllBlockFilterTypes(); 927 } else if (blockfilterindex_value != "0") { 928 const std::vector<std::string> names = args.GetArgs("-blockfilterindex"); 929 for (const auto& name : names) { 930 BlockFilterType filter_type; 931 if (!BlockFilterTypeByName(name, filter_type)) { 932 return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name)); 933 } 934 g_enabled_filter_types.insert(filter_type); 935 } 936 } 937 938 // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled. 939 if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) { 940 nLocalServices = ServiceFlags(nLocalServices | NODE_P2P_V2); 941 } 942 943 // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled. 944 if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) { 945 if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) { 946 return InitError(_("Cannot set -peerblockfilters without -blockfilterindex.")); 947 } 948 949 nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS); 950 } 951 952 if (args.GetIntArg("-prune", 0)) { 953 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) 954 return InitError(_("Prune mode is incompatible with -txindex.")); 955 if (args.GetBoolArg("-reindex-chainstate", false)) { 956 return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead.")); 957 } 958 } 959 960 // If -forcednsseed is set to true, ensure -dnsseed has not been set to false 961 if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){ 962 return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false.")); 963 } 964 965 // -bind and -whitebind can't be set when not listening 966 size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size(); 967 if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) { 968 return InitError(Untranslated("Cannot set -bind or -whitebind together with -listen=0")); 969 } 970 971 // if listen=0, then disallow listenonion=1 972 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN) && args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) { 973 return InitError(Untranslated("Cannot set -listen=0 together with -listenonion=1")); 974 } 975 976 // Make sure enough file descriptors are available 977 int nBind = std::max(nUserBind, size_t(1)); 978 nUserMaxConnections = args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS); 979 nMaxConnections = std::max(nUserMaxConnections, 0); 980 981 nFD = RaiseFileDescriptorLimit(nMaxConnections + MIN_CORE_FILEDESCRIPTORS + MAX_ADDNODE_CONNECTIONS + nBind + NUM_FDS_MESSAGE_CAPTURE); 982 983 #ifdef USE_POLL 984 int fd_max = nFD; 985 #else 986 int fd_max = FD_SETSIZE; 987 #endif 988 // Trim requested connection counts, to fit into system limitations 989 // <int> in std::min<int>(...) to work around FreeBSD compilation issue described in #2695 990 nMaxConnections = std::max(std::min<int>(nMaxConnections, fd_max - nBind - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE), 0); 991 if (nFD < MIN_CORE_FILEDESCRIPTORS) 992 return InitError(_("Not enough file descriptors available.")); 993 nMaxConnections = std::min(nFD - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE, nMaxConnections); 994 995 if (nMaxConnections < nUserMaxConnections) 996 InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), nUserMaxConnections, nMaxConnections)); 997 998 // ********************************************************* Step 3: parameter-to-internal-flags 999 auto result = init::SetLoggingCategories(args); 1000 if (!result) return InitError(util::ErrorString(result)); 1001 result = init::SetLoggingLevel(args); 1002 if (!result) return InitError(util::ErrorString(result)); 1003 1004 nConnectTimeout = args.GetIntArg("-timeout", DEFAULT_CONNECT_TIMEOUT); 1005 if (nConnectTimeout <= 0) { 1006 nConnectTimeout = DEFAULT_CONNECT_TIMEOUT; 1007 } 1008 1009 peer_connect_timeout = args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT); 1010 if (peer_connect_timeout <= 0) { 1011 return InitError(Untranslated("peertimeout must be a positive integer.")); 1012 } 1013 1014 // Sanity check argument for min fee for including tx in block 1015 // TODO: Harmonize which arguments need sanity checking and where that happens 1016 if (args.IsArgSet("-blockmintxfee")) { 1017 if (!ParseMoney(args.GetArg("-blockmintxfee", ""))) { 1018 return InitError(AmountErrMsg("blockmintxfee", args.GetArg("-blockmintxfee", ""))); 1019 } 1020 } 1021 1022 nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp); 1023 1024 if (!g_wallet_init_interface.ParameterInteraction()) return false; 1025 1026 // Option to startup with mocktime set (used for regression testing): 1027 SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op 1028 1029 if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) 1030 nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM); 1031 1032 if (args.IsArgSet("-test")) { 1033 if (chainparams.GetChainType() != ChainType::REGTEST) { 1034 return InitError(Untranslated("-test=<option> can only be used with regtest")); 1035 } 1036 const std::vector<std::string> options = args.GetArgs("-test"); 1037 for (const std::string& option : options) { 1038 auto it = std::find_if(TEST_OPTIONS_DOC.begin(), TEST_OPTIONS_DOC.end(), [&option](const std::string& doc_option) { 1039 size_t pos = doc_option.find(" ("); 1040 return (pos != std::string::npos) && (doc_option.substr(0, pos) == option); 1041 }); 1042 if (it == TEST_OPTIONS_DOC.end()) { 1043 InitWarning(strprintf(_("Unrecognised option \"%s\" provided in -test=<option>."), option)); 1044 } 1045 } 1046 } 1047 1048 // Also report errors from parsing before daemonization 1049 { 1050 kernel::Notifications notifications{}; 1051 ChainstateManager::Options chainman_opts_dummy{ 1052 .chainparams = chainparams, 1053 .datadir = args.GetDataDirNet(), 1054 .notifications = notifications, 1055 }; 1056 auto chainman_result{ApplyArgsManOptions(args, chainman_opts_dummy)}; 1057 if (!chainman_result) { 1058 return InitError(util::ErrorString(chainman_result)); 1059 } 1060 BlockManager::Options blockman_opts_dummy{ 1061 .chainparams = chainman_opts_dummy.chainparams, 1062 .blocks_dir = args.GetBlocksDirPath(), 1063 .notifications = chainman_opts_dummy.notifications, 1064 }; 1065 auto blockman_result{ApplyArgsManOptions(args, blockman_opts_dummy)}; 1066 if (!blockman_result) { 1067 return InitError(util::ErrorString(blockman_result)); 1068 } 1069 } 1070 1071 return true; 1072 } 1073 1074 static bool LockDataDirectory(bool probeOnly) 1075 { 1076 // Make sure only a single Bitcoin process is using the data directory. 1077 const fs::path& datadir = gArgs.GetDataDirNet(); 1078 switch (util::LockDirectory(datadir, ".lock", probeOnly)) { 1079 case util::LockResult::ErrorWrite: 1080 return InitError(strprintf(_("Cannot write to data directory '%s'; check permissions."), fs::PathToString(datadir))); 1081 case util::LockResult::ErrorLock: 1082 return InitError(strprintf(_("Cannot obtain a lock on data directory %s. %s is probably already running."), fs::PathToString(datadir), PACKAGE_NAME)); 1083 case util::LockResult::Success: return true; 1084 } // no default case, so the compiler can warn about missing cases 1085 assert(false); 1086 } 1087 1088 bool AppInitSanityChecks(const kernel::Context& kernel) 1089 { 1090 // ********************************************************* Step 4: sanity checks 1091 auto result{kernel::SanityChecks(kernel)}; 1092 if (!result) { 1093 InitError(util::ErrorString(result)); 1094 return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), PACKAGE_NAME)); 1095 } 1096 1097 // Probe the data directory lock to give an early error message, if possible 1098 // We cannot hold the data directory lock here, as the forking for daemon() hasn't yet happened, 1099 // and a fork will cause weird behavior to it. 1100 return LockDataDirectory(true); 1101 } 1102 1103 bool AppInitLockDataDirectory() 1104 { 1105 // After daemonization get the data directory lock again and hold on to it until exit 1106 // This creates a slight window for a race condition to happen, however this condition is harmless: it 1107 // will at most make us exit without printing a message to console. 1108 if (!LockDataDirectory(false)) { 1109 // Detailed error printed inside LockDataDirectory 1110 return false; 1111 } 1112 return true; 1113 } 1114 1115 bool AppInitInterfaces(NodeContext& node) 1116 { 1117 node.chain = node.init->makeChain(); 1118 return true; 1119 } 1120 1121 bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info) 1122 { 1123 const ArgsManager& args = *Assert(node.args); 1124 const CChainParams& chainparams = Params(); 1125 1126 auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M); 1127 if (!opt_max_upload) { 1128 return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", ""))); 1129 } 1130 1131 // ********************************************************* Step 4a: application initialization 1132 if (!CreatePidFile(args)) { 1133 // Detailed error printed inside CreatePidFile(). 1134 return false; 1135 } 1136 if (!init::StartLogging(args)) { 1137 // Detailed error printed inside StartLogging(). 1138 return false; 1139 } 1140 1141 LogPrintf("Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, nFD); 1142 1143 // Warn about relative -datadir path. 1144 if (args.IsArgSet("-datadir") && !args.GetPathArg("-datadir").is_absolute()) { 1145 LogPrintf("Warning: relative datadir option '%s' specified, which will be interpreted relative to the " 1146 "current working directory '%s'. This is fragile, because if bitcoin is started in the future " 1147 "from a different location, it will be unable to locate the current data files. There could " 1148 "also be data loss if bitcoin is started while in a temporary directory.\n", 1149 args.GetArg("-datadir", ""), fs::PathToString(fs::current_path())); 1150 } 1151 1152 ValidationCacheSizes validation_cache_sizes{}; 1153 ApplyArgsManOptions(args, validation_cache_sizes); 1154 if (!InitSignatureCache(validation_cache_sizes.signature_cache_bytes) 1155 || !InitScriptExecutionCache(validation_cache_sizes.script_execution_cache_bytes)) 1156 { 1157 return InitError(strprintf(_("Unable to allocate memory for -maxsigcachesize: '%s' MiB"), args.GetIntArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_BYTES >> 20))); 1158 } 1159 1160 assert(!node.scheduler); 1161 node.scheduler = std::make_unique<CScheduler>(); 1162 auto& scheduler = *node.scheduler; 1163 1164 // Start the lightweight task scheduler thread 1165 scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); }); 1166 1167 // Gather some entropy once per minute. 1168 scheduler.scheduleEvery([]{ 1169 RandAddPeriodic(); 1170 }, std::chrono::minutes{1}); 1171 1172 // Check disk space every 5 minutes to avoid db corruption. 1173 scheduler.scheduleEvery([&args, &node]{ 1174 constexpr uint64_t min_disk_space = 50 << 20; // 50 MB 1175 if (!CheckDiskSpace(args.GetBlocksDirPath(), min_disk_space)) { 1176 LogPrintf("Shutting down due to lack of disk space!\n"); 1177 if (!(*Assert(node.shutdown))()) { 1178 LogPrintf("Error: failed to send shutdown signal after disk space check\n"); 1179 } 1180 } 1181 }, std::chrono::minutes{5}); 1182 1183 assert(!node.validation_signals); 1184 node.validation_signals = std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(scheduler)); 1185 auto& validation_signals = *node.validation_signals; 1186 1187 // Create client interfaces for wallets that are supposed to be loaded 1188 // according to -wallet and -disablewallet options. This only constructs 1189 // the interfaces, it doesn't load wallet data. Wallets actually get loaded 1190 // when load() and start() interface methods are called below. 1191 g_wallet_init_interface.Construct(node); 1192 uiInterface.InitWallet(); 1193 1194 /* Register RPC commands regardless of -server setting so they will be 1195 * available in the GUI RPC console even if external calls are disabled. 1196 */ 1197 RegisterAllCoreRPCCommands(tableRPC); 1198 for (const auto& client : node.chain_clients) { 1199 client->registerRpcs(); 1200 } 1201 #if ENABLE_ZMQ 1202 RegisterZMQRPCCommands(tableRPC); 1203 #endif 1204 1205 /* Start the RPC server already. It will be started in "warmup" mode 1206 * and not really process calls already (but it will signify connections 1207 * that the server is there and will be ready later). Warmup mode will 1208 * be disabled when initialisation is finished. 1209 */ 1210 if (args.GetBoolArg("-server", false)) { 1211 uiInterface.InitMessage_connect(SetRPCWarmupStatus); 1212 if (!AppInitServers(node)) 1213 return InitError(_("Unable to start HTTP server. See debug log for details.")); 1214 } 1215 1216 // ********************************************************* Step 5: verify wallet database integrity 1217 for (const auto& client : node.chain_clients) { 1218 if (!client->verify()) { 1219 return false; 1220 } 1221 } 1222 1223 // ********************************************************* Step 6: network initialization 1224 // Note that we absolutely cannot open any actual connections 1225 // until the very end ("start node") as the UTXO/block state 1226 // is not yet setup and may end up being set up twice if we 1227 // need to reindex later. 1228 1229 fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN); 1230 fDiscover = args.GetBoolArg("-discover", true); 1231 1232 PeerManager::Options peerman_opts{}; 1233 ApplyArgsManOptions(args, peerman_opts); 1234 1235 { 1236 1237 // Read asmap file if configured 1238 std::vector<bool> asmap; 1239 if (args.IsArgSet("-asmap")) { 1240 fs::path asmap_path = args.GetPathArg("-asmap", DEFAULT_ASMAP_FILENAME); 1241 if (!asmap_path.is_absolute()) { 1242 asmap_path = args.GetDataDirNet() / asmap_path; 1243 } 1244 if (!fs::exists(asmap_path)) { 1245 InitError(strprintf(_("Could not find asmap file %s"), fs::quoted(fs::PathToString(asmap_path)))); 1246 return false; 1247 } 1248 asmap = DecodeAsmap(asmap_path); 1249 if (asmap.size() == 0) { 1250 InitError(strprintf(_("Could not parse asmap file %s"), fs::quoted(fs::PathToString(asmap_path)))); 1251 return false; 1252 } 1253 const uint256 asmap_version = (HashWriter{} << asmap).GetHash(); 1254 LogPrintf("Using asmap version %s for IP bucketing\n", asmap_version.ToString()); 1255 } else { 1256 LogPrintf("Using /16 prefix for IP bucketing\n"); 1257 } 1258 1259 // Initialize netgroup manager 1260 assert(!node.netgroupman); 1261 node.netgroupman = std::make_unique<NetGroupManager>(std::move(asmap)); 1262 1263 // Initialize addrman 1264 assert(!node.addrman); 1265 uiInterface.InitMessage(_("Loading P2P addresses…").translated); 1266 auto addrman{LoadAddrman(*node.netgroupman, args)}; 1267 if (!addrman) return InitError(util::ErrorString(addrman)); 1268 node.addrman = std::move(*addrman); 1269 } 1270 1271 assert(!node.banman); 1272 node.banman = std::make_unique<BanMan>(args.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME)); 1273 assert(!node.connman); 1274 node.connman = std::make_unique<CConnman>(GetRand<uint64_t>(), 1275 GetRand<uint64_t>(), 1276 *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true)); 1277 1278 assert(!node.fee_estimator); 1279 // Don't initialize fee estimation with old data if we don't relay transactions, 1280 // as they would never get updated. 1281 if (!peerman_opts.ignore_incoming_txs) { 1282 bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES); 1283 if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) { 1284 return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString())); 1285 } 1286 node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates); 1287 1288 // Flush estimates to disk periodically 1289 CBlockPolicyEstimator* fee_estimator = node.fee_estimator.get(); 1290 scheduler.scheduleEvery([fee_estimator] { fee_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL); 1291 validation_signals.RegisterValidationInterface(fee_estimator); 1292 } 1293 1294 // Check port numbers 1295 for (const std::string port_option : { 1296 "-port", 1297 "-rpcport", 1298 }) { 1299 if (args.IsArgSet(port_option)) { 1300 const std::string port = args.GetArg(port_option, ""); 1301 uint16_t n; 1302 if (!ParseUInt16(port, &n) || n == 0) { 1303 return InitError(InvalidPortErrMsg(port_option, port)); 1304 } 1305 } 1306 } 1307 1308 for (const std::string port_option : { 1309 "-i2psam", 1310 "-onion", 1311 "-proxy", 1312 "-rpcbind", 1313 "-torcontrol", 1314 "-whitebind", 1315 "-zmqpubhashblock", 1316 "-zmqpubhashtx", 1317 "-zmqpubrawblock", 1318 "-zmqpubrawtx", 1319 "-zmqpubsequence", 1320 }) { 1321 for (const std::string& socket_addr : args.GetArgs(port_option)) { 1322 std::string host_out; 1323 uint16_t port_out{0}; 1324 if (!SplitHostPort(socket_addr, port_out, host_out)) { 1325 #if HAVE_SOCKADDR_UN 1326 // Allow unix domain sockets for -proxy and -onion e.g. unix:/some/file/path 1327 if ((port_option != "-proxy" && port_option != "-onion") || socket_addr.find(ADDR_PREFIX_UNIX) != 0) { 1328 return InitError(InvalidPortErrMsg(port_option, socket_addr)); 1329 } 1330 #else 1331 return InitError(InvalidPortErrMsg(port_option, socket_addr)); 1332 #endif 1333 } 1334 } 1335 } 1336 1337 for (const std::string& socket_addr : args.GetArgs("-bind")) { 1338 std::string host_out; 1339 uint16_t port_out{0}; 1340 std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind('=')); 1341 if (!SplitHostPort(bind_socket_addr, port_out, host_out)) { 1342 return InitError(InvalidPortErrMsg("-bind", socket_addr)); 1343 } 1344 } 1345 1346 // sanitize comments per BIP-0014, format user agent and check total size 1347 std::vector<std::string> uacomments; 1348 for (const std::string& cmt : args.GetArgs("-uacomment")) { 1349 if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT)) 1350 return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt)); 1351 uacomments.push_back(cmt); 1352 } 1353 strSubVersion = FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, uacomments); 1354 if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) { 1355 return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."), 1356 strSubVersion.size(), MAX_SUBVERSION_LENGTH)); 1357 } 1358 1359 if (args.IsArgSet("-onlynet")) { 1360 g_reachable_nets.RemoveAll(); 1361 for (const std::string& snet : args.GetArgs("-onlynet")) { 1362 enum Network net = ParseNetwork(snet); 1363 if (net == NET_UNROUTABLE) 1364 return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet)); 1365 g_reachable_nets.Add(net); 1366 } 1367 } 1368 1369 if (!args.IsArgSet("-cjdnsreachable")) { 1370 if (args.IsArgSet("-onlynet") && g_reachable_nets.Contains(NET_CJDNS)) { 1371 return InitError( 1372 _("Outbound connections restricted to CJDNS (-onlynet=cjdns) but " 1373 "-cjdnsreachable is not provided")); 1374 } 1375 g_reachable_nets.Remove(NET_CJDNS); 1376 } 1377 // Now g_reachable_nets.Contains(NET_CJDNS) is true if: 1378 // 1. -cjdnsreachable is given and 1379 // 2.1. -onlynet is not given or 1380 // 2.2. -onlynet=cjdns is given 1381 1382 // Requesting DNS seeds entails connecting to IPv4/IPv6, which -onlynet options may prohibit: 1383 // If -dnsseed=1 is explicitly specified, abort. If it's left unspecified by the user, we skip 1384 // the DNS seeds by adjusting -dnsseed in InitParameterInteraction. 1385 if (args.GetBoolArg("-dnsseed") == true && !g_reachable_nets.Contains(NET_IPV4) && !g_reachable_nets.Contains(NET_IPV6)) { 1386 return InitError(strprintf(_("Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6"))); 1387 }; 1388 1389 // Check for host lookup allowed before parsing any network related parameters 1390 fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP); 1391 1392 Proxy onion_proxy; 1393 1394 bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE); 1395 // -proxy sets a proxy for all outgoing network traffic 1396 // -noproxy (or -proxy=0) as well as the empty string can be used to not set a proxy, this is the default 1397 std::string proxyArg = args.GetArg("-proxy", ""); 1398 if (proxyArg != "" && proxyArg != "0") { 1399 Proxy addrProxy; 1400 if (IsUnixSocketPath(proxyArg)) { 1401 addrProxy = Proxy(proxyArg, proxyRandomize); 1402 } else { 1403 const std::optional<CService> proxyAddr{Lookup(proxyArg, 9050, fNameLookup)}; 1404 if (!proxyAddr.has_value()) { 1405 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg)); 1406 } 1407 1408 addrProxy = Proxy(proxyAddr.value(), proxyRandomize); 1409 } 1410 1411 if (!addrProxy.IsValid()) 1412 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg)); 1413 1414 SetProxy(NET_IPV4, addrProxy); 1415 SetProxy(NET_IPV6, addrProxy); 1416 SetProxy(NET_CJDNS, addrProxy); 1417 SetNameProxy(addrProxy); 1418 onion_proxy = addrProxy; 1419 } 1420 1421 const bool onlynet_used_with_onion{args.IsArgSet("-onlynet") && g_reachable_nets.Contains(NET_ONION)}; 1422 1423 // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses 1424 // -noonion (or -onion=0) disables connecting to .onion entirely 1425 // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none) 1426 std::string onionArg = args.GetArg("-onion", ""); 1427 if (onionArg != "") { 1428 if (onionArg == "0") { // Handle -noonion/-onion=0 1429 onion_proxy = Proxy{}; 1430 if (onlynet_used_with_onion) { 1431 return InitError( 1432 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for " 1433 "reaching the Tor network is explicitly forbidden: -onion=0")); 1434 } 1435 } else { 1436 if (IsUnixSocketPath(onionArg)) { 1437 onion_proxy = Proxy(onionArg, proxyRandomize); 1438 } else { 1439 const std::optional<CService> addr{Lookup(onionArg, 9050, fNameLookup)}; 1440 if (!addr.has_value() || !addr->IsValid()) { 1441 return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg)); 1442 } 1443 1444 onion_proxy = Proxy(addr.value(), proxyRandomize); 1445 } 1446 } 1447 } 1448 1449 if (onion_proxy.IsValid()) { 1450 SetProxy(NET_ONION, onion_proxy); 1451 } else { 1452 // If -listenonion is set, then we will (try to) connect to the Tor control port 1453 // later from the torcontrol thread and may retrieve the onion proxy from there. 1454 const bool listenonion_disabled{!args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)}; 1455 if (onlynet_used_with_onion && listenonion_disabled) { 1456 return InitError( 1457 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for " 1458 "reaching the Tor network is not provided: none of -proxy, -onion or " 1459 "-listenonion is given")); 1460 } 1461 g_reachable_nets.Remove(NET_ONION); 1462 } 1463 1464 for (const std::string& strAddr : args.GetArgs("-externalip")) { 1465 const std::optional<CService> addrLocal{Lookup(strAddr, GetListenPort(), fNameLookup)}; 1466 if (addrLocal.has_value() && addrLocal->IsValid()) 1467 AddLocal(addrLocal.value(), LOCAL_MANUAL); 1468 else 1469 return InitError(ResolveErrMsg("externalip", strAddr)); 1470 } 1471 1472 #if ENABLE_ZMQ 1473 g_zmq_notification_interface = CZMQNotificationInterface::Create( 1474 [&chainman = node.chainman](std::vector<uint8_t>& block, const CBlockIndex& index) { 1475 assert(chainman); 1476 return chainman->m_blockman.ReadRawBlockFromDisk(block, WITH_LOCK(cs_main, return index.GetBlockPos())); 1477 }); 1478 1479 if (g_zmq_notification_interface) { 1480 validation_signals.RegisterValidationInterface(g_zmq_notification_interface.get()); 1481 } 1482 #endif 1483 1484 // ********************************************************* Step 7: load block chain 1485 1486 node.notifications = std::make_unique<KernelNotifications>(*Assert(node.shutdown), node.exit_status); 1487 ReadNotificationArgs(args, *node.notifications); 1488 fReindex = args.GetBoolArg("-reindex", false); 1489 bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false); 1490 ChainstateManager::Options chainman_opts{ 1491 .chainparams = chainparams, 1492 .datadir = args.GetDataDirNet(), 1493 .notifications = *node.notifications, 1494 .signals = &validation_signals, 1495 }; 1496 Assert(ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction 1497 1498 BlockManager::Options blockman_opts{ 1499 .chainparams = chainman_opts.chainparams, 1500 .blocks_dir = args.GetBlocksDirPath(), 1501 .notifications = chainman_opts.notifications, 1502 }; 1503 Assert(ApplyArgsManOptions(args, blockman_opts)); // no error can happen, already checked in AppInitParameterInteraction 1504 1505 // cache size calculations 1506 CacheSizes cache_sizes = CalculateCacheSizes(args, g_enabled_filter_types.size()); 1507 1508 LogPrintf("Cache configuration:\n"); 1509 LogPrintf("* Using %.1f MiB for block index database\n", cache_sizes.block_tree_db * (1.0 / 1024 / 1024)); 1510 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) { 1511 LogPrintf("* Using %.1f MiB for transaction index database\n", cache_sizes.tx_index * (1.0 / 1024 / 1024)); 1512 } 1513 for (BlockFilterType filter_type : g_enabled_filter_types) { 1514 LogPrintf("* Using %.1f MiB for %s block filter index database\n", 1515 cache_sizes.filter_index * (1.0 / 1024 / 1024), BlockFilterTypeName(filter_type)); 1516 } 1517 LogPrintf("* Using %.1f MiB for chain state database\n", cache_sizes.coins_db * (1.0 / 1024 / 1024)); 1518 1519 assert(!node.mempool); 1520 assert(!node.chainman); 1521 1522 CTxMemPool::Options mempool_opts{ 1523 .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0, 1524 .signals = &validation_signals, 1525 }; 1526 auto result{ApplyArgsManOptions(args, chainparams, mempool_opts)}; 1527 if (!result) { 1528 return InitError(util::ErrorString(result)); 1529 } 1530 mempool_opts.check_ratio = std::clamp<int>(mempool_opts.check_ratio, 0, 1'000'000); 1531 1532 int64_t descendant_limit_bytes = mempool_opts.limits.descendant_size_vbytes * 40; 1533 if (mempool_opts.max_size_bytes < 0 || mempool_opts.max_size_bytes < descendant_limit_bytes) { 1534 return InitError(strprintf(_("-maxmempool must be at least %d MB"), std::ceil(descendant_limit_bytes / 1'000'000.0))); 1535 } 1536 LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)\n", cache_sizes.coins * (1.0 / 1024 / 1024), mempool_opts.max_size_bytes * (1.0 / 1024 / 1024)); 1537 1538 for (bool fLoaded = false; !fLoaded && !ShutdownRequested(node);) { 1539 node.mempool = std::make_unique<CTxMemPool>(mempool_opts); 1540 1541 node.chainman = std::make_unique<ChainstateManager>(*Assert(node.shutdown), chainman_opts, blockman_opts); 1542 ChainstateManager& chainman = *node.chainman; 1543 1544 // This is defined and set here instead of inline in validation.h to avoid a hard 1545 // dependency between validation and index/base, since the latter is not in 1546 // libbitcoinkernel. 1547 chainman.restart_indexes = [&node]() { 1548 LogPrintf("[snapshot] restarting indexes\n"); 1549 1550 // Drain the validation interface queue to ensure that the old indexes 1551 // don't have any pending work. 1552 Assert(node.validation_signals)->SyncWithValidationInterfaceQueue(); 1553 1554 for (auto* index : node.indexes) { 1555 index->Interrupt(); 1556 index->Stop(); 1557 if (!(index->Init() && index->StartBackgroundSync())) { 1558 LogPrintf("[snapshot] WARNING failed to restart index %s on snapshot chain\n", index->GetName()); 1559 } 1560 } 1561 }; 1562 1563 node::ChainstateLoadOptions options; 1564 options.mempool = Assert(node.mempool.get()); 1565 options.reindex = node::fReindex; 1566 options.reindex_chainstate = fReindexChainState; 1567 options.prune = chainman.m_blockman.IsPruneMode(); 1568 options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS); 1569 options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL); 1570 options.require_full_verification = args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel"); 1571 options.coins_error_cb = [] { 1572 uiInterface.ThreadSafeMessageBox( 1573 _("Error reading from database, shutting down."), 1574 "", CClientUIInterface::MSG_ERROR); 1575 }; 1576 1577 uiInterface.InitMessage(_("Loading block index…").translated); 1578 const auto load_block_index_start_time{SteadyClock::now()}; 1579 auto catch_exceptions = [](auto&& f) { 1580 try { 1581 return f(); 1582 } catch (const std::exception& e) { 1583 LogPrintf("%s\n", e.what()); 1584 return std::make_tuple(node::ChainstateLoadStatus::FAILURE, _("Error opening block database")); 1585 } 1586 }; 1587 auto [status, error] = catch_exceptions([&]{ return LoadChainstate(chainman, cache_sizes, options); }); 1588 if (status == node::ChainstateLoadStatus::SUCCESS) { 1589 uiInterface.InitMessage(_("Verifying blocks…").translated); 1590 if (chainman.m_blockman.m_have_pruned && options.check_blocks > MIN_BLOCKS_TO_KEEP) { 1591 LogWarning("pruned datadir may not have more than %d blocks; only checking available blocks\n", 1592 MIN_BLOCKS_TO_KEEP); 1593 } 1594 std::tie(status, error) = catch_exceptions([&]{ return VerifyLoadedChainstate(chainman, options);}); 1595 if (status == node::ChainstateLoadStatus::SUCCESS) { 1596 fLoaded = true; 1597 LogPrintf(" block index %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - load_block_index_start_time)); 1598 } 1599 } 1600 1601 if (status == node::ChainstateLoadStatus::FAILURE_FATAL || status == node::ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB || status == node::ChainstateLoadStatus::FAILURE_INSUFFICIENT_DBCACHE) { 1602 return InitError(error); 1603 } 1604 1605 if (!fLoaded && !ShutdownRequested(node)) { 1606 // first suggest a reindex 1607 if (!options.reindex) { 1608 bool fRet = uiInterface.ThreadSafeQuestion( 1609 error + Untranslated(".\n\n") + _("Do you want to rebuild the block database now?"), 1610 error.original + ".\nPlease restart with -reindex or -reindex-chainstate to recover.", 1611 "", CClientUIInterface::MSG_ERROR | CClientUIInterface::BTN_ABORT); 1612 if (fRet) { 1613 fReindex = true; 1614 if (!Assert(node.shutdown)->reset()) { 1615 LogPrintf("Internal error: failed to reset shutdown signal.\n"); 1616 } 1617 } else { 1618 LogPrintf("Aborted block database rebuild. Exiting.\n"); 1619 return false; 1620 } 1621 } else { 1622 return InitError(error); 1623 } 1624 } 1625 } 1626 1627 // As LoadBlockIndex can take several minutes, it's possible the user 1628 // requested to kill the GUI during the last operation. If so, exit. 1629 // As the program has not fully started yet, Shutdown() is possibly overkill. 1630 if (ShutdownRequested(node)) { 1631 LogPrintf("Shutdown requested. Exiting.\n"); 1632 return false; 1633 } 1634 1635 ChainstateManager& chainman = *Assert(node.chainman); 1636 1637 assert(!node.peerman); 1638 node.peerman = PeerManager::make(*node.connman, *node.addrman, 1639 node.banman.get(), chainman, 1640 *node.mempool, peerman_opts); 1641 validation_signals.RegisterValidationInterface(node.peerman.get()); 1642 1643 // ********************************************************* Step 8: start indexers 1644 1645 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) { 1646 g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), cache_sizes.tx_index, false, fReindex); 1647 node.indexes.emplace_back(g_txindex.get()); 1648 } 1649 1650 for (const auto& filter_type : g_enabled_filter_types) { 1651 InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, cache_sizes.filter_index, false, fReindex); 1652 node.indexes.emplace_back(GetBlockFilterIndex(filter_type)); 1653 } 1654 1655 if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) { 1656 g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, fReindex); 1657 node.indexes.emplace_back(g_coin_stats_index.get()); 1658 } 1659 1660 // Init indexes 1661 for (auto index : node.indexes) if (!index->Init()) return false; 1662 1663 // ********************************************************* Step 9: load wallet 1664 for (const auto& client : node.chain_clients) { 1665 if (!client->load()) { 1666 return false; 1667 } 1668 } 1669 1670 // ********************************************************* Step 10: data directory maintenance 1671 1672 // if pruning, perform the initial blockstore prune 1673 // after any wallet rescanning has taken place. 1674 if (chainman.m_blockman.IsPruneMode()) { 1675 if (!fReindex) { 1676 LOCK(cs_main); 1677 for (Chainstate* chainstate : chainman.GetAll()) { 1678 uiInterface.InitMessage(_("Pruning blockstore…").translated); 1679 chainstate->PruneAndFlush(); 1680 } 1681 } 1682 } else { 1683 LogPrintf("Setting NODE_NETWORK on non-prune mode\n"); 1684 nLocalServices = ServiceFlags(nLocalServices | NODE_NETWORK); 1685 } 1686 1687 // ********************************************************* Step 11: import blocks 1688 1689 if (!CheckDiskSpace(args.GetDataDirNet())) { 1690 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetDataDirNet())))); 1691 return false; 1692 } 1693 if (!CheckDiskSpace(args.GetBlocksDirPath())) { 1694 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetBlocksDirPath())))); 1695 return false; 1696 } 1697 1698 int chain_active_height = WITH_LOCK(cs_main, return chainman.ActiveChain().Height()); 1699 1700 // On first startup, warn on low block storage space 1701 if (!fReindex && !fReindexChainState && chain_active_height <= 1) { 1702 uint64_t assumed_chain_bytes{chainparams.AssumedBlockchainSize() * 1024 * 1024 * 1024}; 1703 uint64_t additional_bytes_needed{ 1704 chainman.m_blockman.IsPruneMode() ? 1705 std::min(chainman.m_blockman.GetPruneTarget(), assumed_chain_bytes) : 1706 assumed_chain_bytes}; 1707 1708 if (!CheckDiskSpace(args.GetBlocksDirPath(), additional_bytes_needed)) { 1709 InitWarning(strprintf(_( 1710 "Disk space for %s may not accommodate the block files. " \ 1711 "Approximately %u GB of data will be stored in this directory." 1712 ), 1713 fs::quoted(fs::PathToString(args.GetBlocksDirPath())), 1714 chainparams.AssumedBlockchainSize() 1715 )); 1716 } 1717 } 1718 1719 // Either install a handler to notify us when genesis activates, or set fHaveGenesis directly. 1720 // No locking, as this happens before any background thread is started. 1721 boost::signals2::connection block_notify_genesis_wait_connection; 1722 if (WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip() == nullptr)) { 1723 block_notify_genesis_wait_connection = uiInterface.NotifyBlockTip_connect(std::bind(BlockNotifyGenesisWait, std::placeholders::_2)); 1724 } else { 1725 fHaveGenesis = true; 1726 } 1727 1728 #if HAVE_SYSTEM 1729 const std::string block_notify = args.GetArg("-blocknotify", ""); 1730 if (!block_notify.empty()) { 1731 uiInterface.NotifyBlockTip_connect([block_notify](SynchronizationState sync_state, const CBlockIndex* pBlockIndex) { 1732 if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) return; 1733 std::string command = block_notify; 1734 ReplaceAll(command, "%s", pBlockIndex->GetBlockHash().GetHex()); 1735 std::thread t(runCommand, command); 1736 t.detach(); // thread runs free 1737 }); 1738 } 1739 #endif 1740 1741 std::vector<fs::path> vImportFiles; 1742 for (const std::string& strFile : args.GetArgs("-loadblock")) { 1743 vImportFiles.push_back(fs::PathFromString(strFile)); 1744 } 1745 1746 chainman.m_thread_load = std::thread(&util::TraceThread, "initload", [=, &chainman, &args, &node] { 1747 // Import blocks 1748 ImportBlocks(chainman, vImportFiles); 1749 if (args.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) { 1750 LogPrintf("Stopping after block import\n"); 1751 if (!(*Assert(node.shutdown))()) { 1752 LogPrintf("Error: failed to send shutdown signal after finishing block import\n"); 1753 } 1754 return; 1755 } 1756 1757 // Start indexes initial sync 1758 if (!StartIndexBackgroundSync(node)) { 1759 bilingual_str err_str = _("Failed to start indexes, shutting down.."); 1760 chainman.GetNotifications().fatalError(err_str); 1761 return; 1762 } 1763 // Load mempool from disk 1764 if (auto* pool{chainman.ActiveChainstate().GetMempool()}) { 1765 LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {}); 1766 pool->SetLoadTried(!chainman.m_interrupt); 1767 } 1768 }); 1769 1770 // Wait for genesis block to be processed 1771 { 1772 WAIT_LOCK(g_genesis_wait_mutex, lock); 1773 // We previously could hang here if shutdown was requested prior to 1774 // ImportBlocks getting started, so instead we just wait on a timer to 1775 // check ShutdownRequested() regularly. 1776 while (!fHaveGenesis && !ShutdownRequested(node)) { 1777 g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500)); 1778 } 1779 block_notify_genesis_wait_connection.disconnect(); 1780 } 1781 1782 if (ShutdownRequested(node)) { 1783 return false; 1784 } 1785 1786 // ********************************************************* Step 12: start node 1787 1788 //// debug print 1789 int64_t best_block_time{}; 1790 { 1791 LOCK(cs_main); 1792 LogPrintf("block tree size = %u\n", chainman.BlockIndex().size()); 1793 chain_active_height = chainman.ActiveChain().Height(); 1794 best_block_time = chainman.ActiveChain().Tip() ? chainman.ActiveChain().Tip()->GetBlockTime() : chainman.GetParams().GenesisBlock().GetBlockTime(); 1795 if (tip_info) { 1796 tip_info->block_height = chain_active_height; 1797 tip_info->block_time = best_block_time; 1798 tip_info->verification_progress = GuessVerificationProgress(chainman.GetParams().TxData(), chainman.ActiveChain().Tip()); 1799 } 1800 if (tip_info && chainman.m_best_header) { 1801 tip_info->header_height = chainman.m_best_header->nHeight; 1802 tip_info->header_time = chainman.m_best_header->GetBlockTime(); 1803 } 1804 } 1805 LogPrintf("nBestHeight = %d\n", chain_active_height); 1806 if (node.peerman) node.peerman->SetBestBlock(chain_active_height, std::chrono::seconds{best_block_time}); 1807 1808 // Map ports with UPnP or NAT-PMP. 1809 StartMapPort(args.GetBoolArg("-upnp", DEFAULT_UPNP), args.GetBoolArg("-natpmp", DEFAULT_NATPMP)); 1810 1811 CConnman::Options connOptions; 1812 connOptions.nLocalServices = nLocalServices; 1813 connOptions.m_max_automatic_connections = nMaxConnections; 1814 connOptions.uiInterface = &uiInterface; 1815 connOptions.m_banman = node.banman.get(); 1816 connOptions.m_msgproc = node.peerman.get(); 1817 connOptions.nSendBufferMaxSize = 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER); 1818 connOptions.nReceiveFloodSize = 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER); 1819 connOptions.m_added_nodes = args.GetArgs("-addnode"); 1820 connOptions.nMaxOutboundLimit = *opt_max_upload; 1821 connOptions.m_peer_connect_timeout = peer_connect_timeout; 1822 connOptions.whitelist_forcerelay = args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY); 1823 connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY); 1824 1825 // Port to bind to if `-bind=addr` is provided without a `:port` suffix. 1826 const uint16_t default_bind_port = 1827 static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort())); 1828 1829 const auto BadPortWarning = [](const char* prefix, uint16_t port) { 1830 return strprintf(_("%s request to listen on port %u. This port is considered \"bad\" and " 1831 "thus it is unlikely that any peer will connect to it. See " 1832 "doc/p2p-bad-ports.md for details and a full list."), 1833 prefix, 1834 port); 1835 }; 1836 1837 for (const std::string& bind_arg : args.GetArgs("-bind")) { 1838 std::optional<CService> bind_addr; 1839 const size_t index = bind_arg.rfind('='); 1840 if (index == std::string::npos) { 1841 bind_addr = Lookup(bind_arg, default_bind_port, /*fAllowLookup=*/false); 1842 if (bind_addr.has_value()) { 1843 connOptions.vBinds.push_back(bind_addr.value()); 1844 if (IsBadPort(bind_addr.value().GetPort())) { 1845 InitWarning(BadPortWarning("-bind", bind_addr.value().GetPort())); 1846 } 1847 continue; 1848 } 1849 } else { 1850 const std::string network_type = bind_arg.substr(index + 1); 1851 if (network_type == "onion") { 1852 const std::string truncated_bind_arg = bind_arg.substr(0, index); 1853 bind_addr = Lookup(truncated_bind_arg, BaseParams().OnionServiceTargetPort(), false); 1854 if (bind_addr.has_value()) { 1855 connOptions.onion_binds.push_back(bind_addr.value()); 1856 continue; 1857 } 1858 } 1859 } 1860 return InitError(ResolveErrMsg("bind", bind_arg)); 1861 } 1862 1863 for (const std::string& strBind : args.GetArgs("-whitebind")) { 1864 NetWhitebindPermissions whitebind; 1865 bilingual_str error; 1866 if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error); 1867 connOptions.vWhiteBinds.push_back(whitebind); 1868 } 1869 1870 // If the user did not specify -bind= or -whitebind= then we bind 1871 // on any address - 0.0.0.0 (IPv4) and :: (IPv6). 1872 connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty(); 1873 1874 // Emit a warning if a bad port is given to -port= but only if -bind and -whitebind are not 1875 // given, because if they are, then -port= is ignored. 1876 if (connOptions.bind_on_any && args.IsArgSet("-port")) { 1877 const uint16_t port_arg = args.GetIntArg("-port", 0); 1878 if (IsBadPort(port_arg)) { 1879 InitWarning(BadPortWarning("-port", port_arg)); 1880 } 1881 } 1882 1883 CService onion_service_target; 1884 if (!connOptions.onion_binds.empty()) { 1885 onion_service_target = connOptions.onion_binds.front(); 1886 } else { 1887 onion_service_target = DefaultOnionServiceTarget(); 1888 connOptions.onion_binds.push_back(onion_service_target); 1889 } 1890 1891 if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) { 1892 if (connOptions.onion_binds.size() > 1) { 1893 InitWarning(strprintf(_("More than one onion bind address is provided. Using %s " 1894 "for the automatically created Tor onion service."), 1895 onion_service_target.ToStringAddrPort())); 1896 } 1897 StartTorControl(onion_service_target); 1898 } 1899 1900 if (connOptions.bind_on_any) { 1901 // Only add all IP addresses of the machine if we would be listening on 1902 // any address - 0.0.0.0 (IPv4) and :: (IPv6). 1903 Discover(); 1904 } 1905 1906 for (const auto& net : args.GetArgs("-whitelist")) { 1907 NetWhitelistPermissions subnet; 1908 ConnectionDirection connection_direction; 1909 bilingual_str error; 1910 if (!NetWhitelistPermissions::TryParse(net, subnet, connection_direction, error)) return InitError(error); 1911 if (connection_direction & ConnectionDirection::In) { 1912 connOptions.vWhitelistedRangeIncoming.push_back(subnet); 1913 } 1914 if (connection_direction & ConnectionDirection::Out) { 1915 connOptions.vWhitelistedRangeOutgoing.push_back(subnet); 1916 } 1917 } 1918 1919 connOptions.vSeedNodes = args.GetArgs("-seednode"); 1920 1921 // Initiate outbound connections unless connect=0 1922 connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect"); 1923 if (!connOptions.m_use_addrman_outgoing) { 1924 const auto connect = args.GetArgs("-connect"); 1925 if (connect.size() != 1 || connect[0] != "0") { 1926 connOptions.m_specified_outgoing = connect; 1927 } 1928 if (!connOptions.m_specified_outgoing.empty() && !connOptions.vSeedNodes.empty()) { 1929 LogPrintf("-seednode is ignored when -connect is used\n"); 1930 } 1931 1932 if (args.IsArgSet("-dnsseed") && args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED) && args.IsArgSet("-proxy")) { 1933 LogPrintf("-dnsseed is ignored when -connect is used and -proxy is specified\n"); 1934 } 1935 } 1936 1937 const std::string& i2psam_arg = args.GetArg("-i2psam", ""); 1938 if (!i2psam_arg.empty()) { 1939 const std::optional<CService> addr{Lookup(i2psam_arg, 7656, fNameLookup)}; 1940 if (!addr.has_value() || !addr->IsValid()) { 1941 return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg)); 1942 } 1943 SetProxy(NET_I2P, Proxy{addr.value()}); 1944 } else { 1945 if (args.IsArgSet("-onlynet") && g_reachable_nets.Contains(NET_I2P)) { 1946 return InitError( 1947 _("Outbound connections restricted to i2p (-onlynet=i2p) but " 1948 "-i2psam is not provided")); 1949 } 1950 g_reachable_nets.Remove(NET_I2P); 1951 } 1952 1953 connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", DEFAULT_I2P_ACCEPT_INCOMING); 1954 1955 if (!node.connman->Start(scheduler, connOptions)) { 1956 return false; 1957 } 1958 1959 // ********************************************************* Step 13: finished 1960 1961 // At this point, the RPC is "started", but still in warmup, which means it 1962 // cannot yet be called. Before we make it callable, we need to make sure 1963 // that the RPC's view of the best block is valid and consistent with 1964 // ChainstateManager's active tip. 1965 // 1966 // If we do not do this, RPC's view of the best block will be height=0 and 1967 // hash=0x0. This will lead to erroroneous responses for things like 1968 // waitforblockheight. 1969 RPCNotifyBlockChange(WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip())); 1970 SetRPCWarmupFinished(); 1971 1972 uiInterface.InitMessage(_("Done loading").translated); 1973 1974 for (const auto& client : node.chain_clients) { 1975 client->start(scheduler); 1976 } 1977 1978 BanMan* banman = node.banman.get(); 1979 scheduler.scheduleEvery([banman]{ 1980 banman->DumpBanlist(); 1981 }, DUMP_BANS_INTERVAL); 1982 1983 if (node.peerman) node.peerman->StartScheduledTasks(scheduler); 1984 1985 #if HAVE_SYSTEM 1986 StartupNotify(args); 1987 #endif 1988 1989 return true; 1990 } 1991 1992 bool StartIndexBackgroundSync(NodeContext& node) 1993 { 1994 // Find the oldest block among all indexes. 1995 // This block is used to verify that we have the required blocks' data stored on disk, 1996 // starting from that point up to the current tip. 1997 // indexes_start_block='nullptr' means "start from height 0". 1998 std::optional<const CBlockIndex*> indexes_start_block; 1999 std::string older_index_name; 2000 ChainstateManager& chainman = *Assert(node.chainman); 2001 const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.GetChainstateForIndexing()); 2002 const CChain& index_chain = chainstate.m_chain; 2003 2004 for (auto index : node.indexes) { 2005 const IndexSummary& summary = index->GetSummary(); 2006 if (summary.synced) continue; 2007 2008 // Get the last common block between the index best block and the active chain 2009 LOCK(::cs_main); 2010 const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(summary.best_block_hash); 2011 if (!index_chain.Contains(pindex)) { 2012 pindex = index_chain.FindFork(pindex); 2013 } 2014 2015 if (!indexes_start_block || !pindex || pindex->nHeight < indexes_start_block.value()->nHeight) { 2016 indexes_start_block = pindex; 2017 older_index_name = summary.name; 2018 if (!pindex) break; // Starting from genesis so no need to look for earlier block. 2019 } 2020 }; 2021 2022 // Verify all blocks needed to sync to current tip are present. 2023 if (indexes_start_block) { 2024 LOCK(::cs_main); 2025 const CBlockIndex* start_block = *indexes_start_block; 2026 if (!start_block) start_block = chainman.ActiveChain().Genesis(); 2027 if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(start_block))) { 2028 return InitError(strprintf(Untranslated("%s best block of the index goes beyond pruned data. Please disable the index or reindex (which will download the whole blockchain again)"), older_index_name)); 2029 } 2030 } 2031 2032 // Start threads 2033 for (auto index : node.indexes) if (!index->StartBackgroundSync()) return false; 2034 return true; 2035 }