Starting and stopping a Bitcoin Core node

1251    auto result{kernel::SanityChecks(kernel)};
1252    if (!result) {
1253        InitError(util::ErrorString(result));
1254        return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), CLIENT_NAME));
1255    }
1256
1257    if (!ECC_InitSanityCheck()) {
1258        return InitError(strprintf(_("Elliptic curve cryptography sanity check failure. %s is shutting down."), CLIENT_NAME));
1259    }
1260
1261    // Probe the directory locks to give an early error message, if possible
1262    // We cannot hold the directory locks here, as the forking for daemon() hasn't yet happened,
1263    // and a fork will cause weird behavior to them.
1264    return LockDirectories(true);
1265}
1266
1267bool AppInitLockDirectories()
1268{
1269    // After daemonization get the directory locks again and hold on to them until exit
1270    // This creates a slight window for a race condition to happen, however this condition is harmless: it
1271    // will at most make us exit without printing a message to console.
1272    if (!LockDirectories(false)) {
1273        // Detailed error printed inside LockDirectory
1274        return false;
1275    }
1276    return true;
1277}
1278
1279bool AppInitInterfaces(NodeContext& node)
1280{
1281    node.chain = interfaces::MakeChain(node);
1282    // Specify wait_loaded=false so internal mining interface can be initialized
1283    // on early startup and does not need to be tied to chainstate loading.
1284    node.mining = interfaces::MakeMining(node, /*wait_loaded=*/false);
1285    return true;
1286}
1287
1288bool CheckHostPortOptions(const ArgsManager& args) {
1289    for (const std::string port_option : {
1290        "-port",
1291        "-rpcport",
1292    }) {
1293        if (const auto port{args.GetArg(port_option)}) {
1294            const auto n{ToIntegral<uint16_t>(*port)};
1295            if (!n || *n == 0) {
1296                return InitError(InvalidPortErrMsg(port_option, *port));
1297            }
1298        }
1299    }
1300
1301    for ([[maybe_unused]] const auto& [param_name, unix, suffix_allowed] : std::vector<std::tuple<std::string, bool, bool>>{
1302        // arg name          UNIX socket support  =suffix allowed
1303        {"-i2psam",          false,               false},
1304        {"-onion",           true,                false},
1305        {"-proxy",           true,                true},
1306        {"-bind",            false,               true},
1307        {"-rpcbind",         false,               false},
1308        {"-torcontrol",      false,               false},
1309        {"-whitebind",       false,               false},
1310        {"-zmqpubhashblock", true,                false},
1311        {"-zmqpubhashtx",    true,                false},
1312        {"-zmqpubrawblock",  true,                false},
1313        {"-zmqpubrawtx",     true,                false},
1314        {"-zmqpubsequence",  true,                false},
1315    }) {
1316        for (const std::string& param_value : args.GetArgs(param_name)) {
1317            const std::string param_value_hostport{
1318                suffix_allowed ? param_value.substr(0, param_value.rfind('=')) : param_value};
1319            std::string host_out;
1320            uint16_t port_out{0};
1321            if (!SplitHostPort(param_value_hostport, port_out, host_out)) {
1322#ifdef HAVE_SOCKADDR_UN
1323                // Allow unix domain sockets for some options e.g. unix:/some/file/path
1324                if (!unix || !param_value.starts_with(ADDR_PREFIX_UNIX)) {
1325                    return InitError(InvalidPortErrMsg(param_name, param_value));
1326                }
1327#else
1328                return InitError(InvalidPortErrMsg(param_name, param_value));
1329#endif
1330            }
1331        }
1332    }
1333
1334    return true;
1335}
1336
1337/**
1338 * @brief Checks for duplicate bindings across all binding configurations.
1339 *
1340 * @param[in] conn_options Connection options containing the binding vectors to check
1341 * @return std::optional<CService> containing the first duplicate found, or std::nullopt if no duplicates
1342 */
1343static std::optional<CService> CheckBindingConflicts(const CConnman::Options& conn_options)
1344{
1345    std::set<CService> seen;
1346
1347    // Check all whitelisted bindings
1348    for (const auto& wb : conn_options.vWhiteBinds) {
1349        if (!seen.insert(wb.m_service).second) {
1350            return wb.m_service;
1351        }
1352    }
1353
1354    // Check regular bindings
1355    for (const auto& bind : conn_options.vBinds) {
1356        if (!seen.insert(bind).second) {
1357            return bind;
1358        }
1359    }
1360
1361    // Check onion bindings
1362    for (const auto& onion_bind : conn_options.onion_binds) {
1363        if (!seen.insert(onion_bind).second) {
1364            return onion_bind;
1365        }
1366    }
1367
1368    return std::nullopt;
1369}
1370
1371// A GUI user may opt to retry once with do_reindex set if there is a failure during chainstate initialization.
1372// The function therefore has to support re-entry.
1373static ChainstateLoadResult InitAndLoadChainstate(
1374    NodeContext& node,
1375    bool do_reindex,
1376    const bool do_reindex_chainstate,
1377    const kernel::CacheSizes& cache_sizes,
1378    const ArgsManager& args)
1379{
1380    // This function may be called twice, so any dirty state must be reset.
1381    node.notifications->setChainstateLoaded(false); // Drop state, such as a cached tip block
1382    node.mempool.reset();
1383    node.chainman.reset(); // Drop state, such as an initialized m_block_tree_db
1384
1385    const CChainParams& chainparams = Params();
1386
1387    CTxMemPool::Options mempool_opts{
1388        .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
1389        .signals = node.validation_signals.get(),
1390    };
1391    Assert(ApplyArgsManOptions(args, chainparams, mempool_opts)); // no error can happen, already checked in AppInitParameterInteraction
1392    bilingual_str mempool_error;
1393    Assert(!node.mempool); // Was reset above
1394    node.mempool = std::make_unique<CTxMemPool>(mempool_opts, mempool_error);
1395    if (!mempool_error.empty()) {
1396        return {ChainstateLoadStatus::FAILURE_FATAL, mempool_error};
1397    }
1398    auto mining_args{node::ReadMiningArgs(args)};
1399    Assert(mining_args); // no error can happen, already checked in AppInitParameterInteraction
1400    node.mining_args = std::move(*mining_args);
1401    LogInfo("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)",
1402            cache_sizes.coins / double(1_MiB),
1403            mempool_opts.max_size_bytes / double(1_MiB));
1404    ChainstateManager::Options chainman_opts{
1405        .chainparams = chainparams,
1406        .datadir = args.GetDataDirNet(),
1407        .notifications = *node.notifications,
1408        .signals = node.validation_signals.get(),
1409    };
1410    Assert(ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1411
1412    BlockManager::Options blockman_opts{
1413        .chainparams = chainman_opts.chainparams,
1414        .blocks_dir = args.GetBlocksDirPath(),
1415        .notifications = chainman_opts.notifications,
1416        .block_tree_db_params = DBParams{
1417            .path = args.GetDataDirNet() / "blocks" / "index",
1418            .cache_bytes = cache_sizes.block_tree_db,
1419            .wipe_data = do_reindex,
1420        },
1421    };
1422    Assert(ApplyArgsManOptions(args, blockman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1423
1424    // Creating the chainstate manager internally creates a BlockManager, opens
1425    // the blocks tree db, and wipes existing block files in case of a reindex.
1426    // The coinsdb is opened at a later point on LoadChainstate.
1427    Assert(!node.chainman); // Was reset above
1428    try {
1429        node.chainman = std::make_unique<ChainstateManager>(*Assert(node.shutdown_signal), chainman_opts, blockman_opts);
1430    } catch (dbwrapper_error& e) {
1431        LogError("%s", e.what());
1432        return {ChainstateLoadStatus::FAILURE, _("Error opening block database")};
1433    } catch (std::exception& e) {
1434        return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated(strprintf("Failed to initialize ChainstateManager: %s", e.what()))};
1435    }
1436    ChainstateManager& chainman = *node.chainman;
1437    if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
1438
1439    // This is defined and set here instead of inline in validation.h to avoid a hard
1440    // dependency between validation and index/base, since the latter is not in
1441    // libbitcoinkernel.
1442    chainman.snapshot_download_completed = [&node]() {
1443        if (!node.chainman->m_blockman.IsPruneMode()) {
1444            LogInfo("[snapshot] re-enabling NODE_NETWORK services");
1445            node.connman->AddLocalServices(NODE_NETWORK);
1446        }
1447        LogInfo("[snapshot] restarting indexes");
1448        // Drain the validation interface queue to ensure that the old indexes
1449        // don't have any pending work.
1450        Assert(node.validation_signals)->SyncWithValidationInterfaceQueue();
1451        for (auto* index : node.indexes) {
1452            index->Interrupt();
1453            index->Stop();
1454            if (!(index->Init() && index->StartBackgroundSync())) {
1455                LogWarning("[snapshot] Failed to restart index %s on snapshot chain", index->GetName());
1456            }
1457        }
1458    };
1459    node::ChainstateLoadOptions options;
1460    options.mempool = Assert(node.mempool.get());
1461    options.wipe_chainstate_db = do_reindex || do_reindex_chainstate;
1462    options.prune = chainman.m_blockman.IsPruneMode();
1463    options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
1464    options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
1465    options.require_full_verification = args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
1466    options.coins_error_cb = [] {
1467        uiInterface.ThreadSafeMessageBox(
1468            _("Error reading from database, shutting down."),
1469            CClientUIInterface::MSG_ERROR);
1470    };
1471    uiInterface.InitMessage(_("Loading block index…"));
1472    auto catch_exceptions = [](auto&& f) -> ChainstateLoadResult {
1473        try {
1474            return f();
1475        } catch (const std::exception& e) {
1476            LogError("%s\n", e.what());
1477            return std::make_tuple(node::ChainstateLoadStatus::FAILURE, _("Error loading databases"));
1478        }
1479    };
1480    auto [status, error] = catch_exceptions([&] { return LoadChainstate(chainman, cache_sizes, options); });
1481    if (status == node::ChainstateLoadStatus::SUCCESS) {
1482        uiInterface.InitMessage(_("Verifying blocks…"));
1483        if (chainman.m_blockman.m_have_pruned && options.check_blocks > MIN_BLOCKS_TO_KEEP) {
1484            LogWarning("pruned datadir may not have more than %d blocks; only checking available blocks\n",
1485                       MIN_BLOCKS_TO_KEEP);
1486        }
1487        std::tie(status, error) = catch_exceptions([&] { return VerifyLoadedChainstate(chainman, options); });
1488        if (status == node::ChainstateLoadStatus::SUCCESS) {
1489            LogInfo("Block index and chainstate loaded");
1490            node.notifications->setChainstateLoaded(true);
1491        }
1492    }
1493    return {status, error};
1494};
1495
1496bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
1497{
1498    const ArgsManager& args = *Assert(node.args);
1499    const CChainParams& chainparams = Params();
1500