Starting and stopping a Bitcoin Core node

1501    auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M);
1502    if (!opt_max_upload) {
1503        return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", "")));
1504    }
1505
1506    // ********************************************************* Step 4a: application initialization
1507    if (!CreatePidFile(args)) {
1508        // Detailed error printed inside CreatePidFile().
1509        return false;
1510    }
1511    if (!init::StartLogging(args)) {
1512        // Detailed error printed inside StartLogging().
1513        return false;
1514    }
1515
1516    LogInfo("Using at most %i automatic connections (%i file descriptors available)", num_p2p_max_connections, available_fds);
1517
1518    // Warn about relative -datadir path.
1519    if (args.IsArgSet("-datadir") && !args.GetPathArg("-datadir").is_absolute()) {
1520        LogWarning("Relative datadir option '%s' specified, which will be interpreted relative to the "
1521                   "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1522                   "from a different location, it will be unable to locate the current data files. There could "
1523                   "also be data loss if bitcoin is started while in a temporary directory.",
1524                   args.GetArg("-datadir", ""), fs::PathToString(fs::current_path()));
1525    }
1526
1527    assert(!node.scheduler);
1528    node.scheduler = std::make_unique<CScheduler>();
1529    auto& scheduler = *node.scheduler;
1530
1531    // Start the lightweight task scheduler thread
1532    scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); });
1533
1534    // Gather some entropy once per minute.
1535    scheduler.scheduleEvery([]{
1536        RandAddPeriodic();
1537    }, std::chrono::minutes{1});
1538
1539    // Check disk space every 5 minutes to avoid db corruption.
1540    scheduler.scheduleEvery([&args, &node]{
1541        constexpr uint64_t min_disk_space{50_MiB};
1542        if (!CheckDiskSpace(args.GetBlocksDirPath(), min_disk_space)) {
1543            LogError("Shutting down due to lack of disk space!\n");
1544            if (!(Assert(node.shutdown_request))()) {
1545                LogError("Failed to send shutdown signal after disk space check\n");
1546            }
1547        }
1548    }, std::chrono::minutes{5});
1549
1550    if (args.GetBoolArg("-logratelimit", BCLog::DEFAULT_LOGRATELIMIT)) {
1551        LogInstance().SetRateLimiting(BCLog::LogRateLimiter::Create(
1552            [&scheduler](auto func, auto window) { scheduler.scheduleEvery(std::move(func), window); },
1553            BCLog::RATELIMIT_MAX_BYTES,
1554            BCLog::RATELIMIT_WINDOW));
1555    } else {
1556        LogInfo("Log rate limiting disabled");
1557    }
1558
1559    assert(!node.validation_signals);
1560    node.validation_signals = std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(scheduler));
1561    auto& validation_signals = *node.validation_signals;
1562
1563    // Create KernelNotifications object. Important to do this early before
1564    // calling ipc->listenAddress() below so makeMining and other IPC methods
1565    // can use this.
1566    assert(!node.notifications);
1567    node.notifications = std::make_unique<KernelNotifications>(Assert(node.shutdown_request), node.exit_status, *Assert(node.warnings));
1568    ReadNotificationArgs(args, *node.notifications);
1569
1570    // Create client interfaces for wallets that are supposed to be loaded
1571    // according to -wallet and -disablewallet options. This only constructs
1572    // the interfaces, it doesn't load wallet data. Wallets actually get loaded
1573    // when load() and start() interface methods are called below.
1574    g_wallet_init_interface.Construct(node);
1575    uiInterface.InitWallet();
1576
1577    if (interfaces::Ipc* ipc = node.init->ipc()) {
1578        for (std::string address : gArgs.GetArgs("-ipcbind")) {
1579            try {
1580                ipc->listenAddress(address);
1581            } catch (const std::exception& e) {
1582                return InitError(Untranslated(strprintf("Unable to bind to IPC address '%s'. %s", address, e.what())));
1583            }
1584            LogInfo("Listening for IPC requests on address %s", address);
1585        }
1586    }
1587
1588    /* Register RPC commands regardless of -server setting so they will be
1589     * available in the GUI RPC console even if external calls are disabled.
1590     */
1591    RegisterAllCoreRPCCommands(tableRPC);
1592    for (const auto& client : node.chain_clients) {
1593        client->registerRpcs();
1594    }
1595#ifdef ENABLE_ZMQ
1596    RegisterZMQRPCCommands(tableRPC);
1597#endif
1598
1599    // Check port numbers
1600    if (!CheckHostPortOptions(args)) return false;
1601
1602    // Configure reachable networks before we start the RPC server.
1603    // This is necessary for -rpcallowip to distinguish CJDNS from other RFC4193
1604    const auto onlynets = args.GetArgs("-onlynet");
1605    if (!onlynets.empty()) {
1606        g_reachable_nets.RemoveAll();
1607        for (const std::string& snet : onlynets) {
1608            enum Network net = ParseNetwork(snet);
1609            if (net == NET_UNROUTABLE)
1610                return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
1611            g_reachable_nets.Add(net);
1612        }
1613    }
1614
1615    if (!args.IsArgSet("-cjdnsreachable")) {
1616        if (!onlynets.empty() && g_reachable_nets.Contains(NET_CJDNS)) {
1617            return InitError(
1618                _("Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1619                  "-cjdnsreachable is not provided"));
1620        }
1621        g_reachable_nets.Remove(NET_CJDNS);
1622    }
1623    // Now g_reachable_nets.Contains(NET_CJDNS) is true if:
1624    // 1. -cjdnsreachable is given and
1625    // 2.1. -onlynet is not given or
1626    // 2.2. -onlynet=cjdns is given
1627
1628    /* Start the RPC server already.  It will be started in "warmup" mode
1629     * and not really process calls already (but it will signify connections
1630     * that the server is there and will be ready later).  Warmup mode will
1631     * be disabled when initialisation is finished.
1632     */
1633    if (args.GetBoolArg("-server", false)) {
1634        uiInterface.InitMessage.connect(SetRPCWarmupStatus);
1635        if (!AppInitServers(node))
1636            return InitError(_("Unable to start HTTP server. See debug log for details."));
1637    }
1638
1639    // ********************************************************* Step 5: verify wallet database integrity
1640    for (const auto& client : node.chain_clients) {
1641        if (!client->verify()) {
1642            return false;
1643        }
1644    }
1645
1646    // ********************************************************* Step 6: network initialization
1647    // Note that we absolutely cannot open any actual connections
1648    // until the very end ("start node") as the UTXO/block state
1649    // is not yet setup and may end up being set up twice if we
1650    // need to reindex later.
1651
1652    fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
1653    fDiscover = args.GetBoolArg("-discover", true);
1654
1655    PeerManager::Options peerman_opts{};
1656    ApplyArgsManOptions(args, peerman_opts);
1657
1658    {
1659        // Read asmap file if configured or embedded asmap data and initialize
1660        // Netgroupman with or without it
1661        assert(!node.netgroupman);
1662        if (args.IsArgSet("-asmap") && !args.IsArgNegated("-asmap")) {
1663            if (!args.GetBoolArg("-asmap", false)) {
1664                fs::path asmap_path = args.GetPathArg("-asmap");
1665                if (!asmap_path.is_absolute()) {
1666                    asmap_path = args.GetDataDirNet() / asmap_path;
1667                }
1668
1669                // If a specific path was passed with the asmap argument check if
1670                // the file actually exists in that location
1671                if (!fs::exists(asmap_path)) {
1672                    InitError(strprintf(_("Could not find asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1673                    return false;
1674                }
1675
1676                // If a file exists at the path, try to read the file
1677                std::vector<std::byte> asmap{DecodeAsmap(asmap_path)};
1678                if (asmap.empty()) {
1679                    InitError(strprintf(_("Could not parse asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1680                    return false;
1681                }
1682                node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::WithLoadedAsmap(std::move(asmap)));
1683            } else {
1684                #ifdef ENABLE_EMBEDDED_ASMAP
1685                    // Use the embedded asmap data
1686                    std::span<const std::byte> asmap{node::data::ip_asn};
1687                    if (asmap.empty() || !CheckStandardAsmap(asmap)) {
1688                        InitError(strprintf(_("Could not read embedded asmap data")));
1689                        return false;
1690                    }
1691                    node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::WithEmbeddedAsmap(asmap));
1692                    LogInfo("Opened asmap data (%zu bytes) from embedded byte array\n", asmap.size());
1693                #else
1694                    // If there is no embedded data, fail and report it since
1695                    // the user tried to use it
1696                    InitError(strprintf(_("Embedded asmap data not available")));
1697                    return false;
1698                #endif
1699            }
1700            LogInfo("Using asmap version %s for IP bucketing", HexStr(node.netgroupman->GetAsmapVersion()));
1701        } else {
1702            node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::NoAsmap());
1703            LogInfo("Using /16 prefix for IP bucketing");
1704        }
1705
1706        // Initialize addrman
1707        assert(!node.addrman);
1708        uiInterface.InitMessage(_("Loading P2P addresses…"));
1709        auto addrman{LoadAddrman(*node.netgroupman, args)};
1710        if (!addrman) return InitError(util::ErrorString(addrman));
1711        node.addrman = std::move(*addrman);
1712    }
1713
1714    FastRandomContext rng;
1715    assert(!node.banman);
1716    node.banman = std::make_unique<BanMan>(args.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
1717    assert(!node.connman);
1718    node.connman = std::make_unique<CConnman>(rng.rand64(),
1719                                              rng.rand64(),
1720                                              *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true));
1721
1722    for (const std::string& socket_addr : args.GetArgs("-bind")) {
1723        std::string host_out;
1724        uint16_t port_out{0};
1725        std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind('='));
1726        if (!SplitHostPort(bind_socket_addr, port_out, host_out)) {
1727            return InitError(InvalidPortErrMsg("-bind", socket_addr));
1728        }
1729    }
1730
1731    // sanitize comments per BIP-0014, format user agent and check total size
1732    std::vector<std::string> uacomments;
1733    for (const std::string& cmt : args.GetArgs("-uacomment")) {
1734        if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT))
1735            return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt));
1736        uacomments.push_back(cmt);
1737    }
1738    strSubVersion = FormatSubVersion(UA_NAME, CLIENT_VERSION, uacomments);
1739    if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
1740        return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1741            strSubVersion.size(), MAX_SUBVERSION_LENGTH));
1742    }
1743
1744    // Requesting DNS seeds entails connecting to IPv4/IPv6, which -onlynet options may prohibit:
1745    // If -dnsseed=1 is explicitly specified, abort. If it's left unspecified by the user, we skip
1746    // the DNS seeds by adjusting -dnsseed in InitParameterInteraction.
1747    if (args.GetBoolArg("-dnsseed") == true && !g_reachable_nets.Contains(NET_IPV4) && !g_reachable_nets.Contains(NET_IPV6)) {
1748        return InitError(strprintf(_("Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1749    };
1750