Main.cpp

#include <xrpld/app/main/Application.h>
#include <xrpld/core/Config.h>
#include <xrpld/core/TimeKeeper.h>
#include <xrpld/rpc/RPCCall.h>
#include <xrpld/rpc/handlers/server_info/ServerDefinitions.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/SlabAllocator.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/core/CurrentThreadName.h>
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/beast/unit_test/suite_info.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/config/Constants.h>
#include <xrpl/core/StartUpType.h>
#include <xrpl/git/Git.h>
#include <xrpl/json/json_writer.h>
#include <xrpl/protocol/BuildInfo.h>
#include <xrpl/protocol/SystemParameters.h>
#include <xrpl/server/Vacuum.h>
 
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/process/v1/args.hpp>
#include <boost/process/v1/child.hpp>  // IWYU pragma: keep
#include <boost/process/v1/exe.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/positional_options.hpp>
#include <boost/program_options/value_semantic.hpp>
#include <boost/program_options/variables_map.hpp>
 
#include <algorithm>
#include <atomic>
#include <cstdint>
#include <exception>
#include <iostream>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
#ifdef ENABLE_TESTS
#include <test/unit_test/multi_runner.h>
 
#include <xrpl/beast/unit_test/match.h>
#endif  // ENABLE_TESTS
 
#include <google/protobuf/stubs/common.h>
 
#include <cstdlib>
#include <stdexcept>
#include <utility>
 
#if BOOST_OS_WINDOWS
#include <sys/timeb.h>
#include <sys/types.h>
#endif
 
// Do we know the platform we're compiling on? If you're adding new platforms
// modify this check accordingly.
#if !BOOST_OS_LINUX && !BOOST_OS_WINDOWS && !BOOST_OS_MACOS
#error Supported platforms are: Linux, Windows and MacOS
#endif
 
// Ensure that precisely one platform is detected.
#if (BOOST_OS_LINUX && (BOOST_OS_WINDOWS || BOOST_OS_MACOS)) || \
    (BOOST_OS_MACOS && (BOOST_OS_WINDOWS || BOOST_OS_LINUX)) || \
    (BOOST_OS_WINDOWS && (BOOST_OS_LINUX || BOOST_OS_MACOS))
#error Multiple supported platforms appear active at once
#endif
 
#ifdef ENABLE_VOIDSTAR
#include <antithesis_instrumentation.h>
#endif
 
namespace po = boost::program_options;
 
namespace xrpl {
 
bool
adjustDescriptorLimit(int needed, beast::Journal j)
{
#ifdef RLIMIT_NOFILE
    // Get the current limit, then adjust it to what we need.
    struct rlimit rl{};
 
    int available = 0;
 
    if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
    {
        // If the limit is infinite, then we are good.
        if (rl.rlim_cur == RLIM_INFINITY)
        {
            available = needed;
        }
        else
        {
            available = rl.rlim_cur;
        }
 
        if (available < needed)
        {
            // Ignore the rlimit_max_, as the process may
            // be configured to override it anyways. We
            // ask for the number descriptors we need.
            rl.rlim_cur = needed;
 
            if (setrlimit(RLIMIT_NOFILE, &rl) == 0)
                available = rl.rlim_cur;
        }
    }
 
    if (needed > available)
    {
        j.fatal() << "Insufficient number of file descriptors: " << needed
                  << " are needed, but only " << available << " are available.";
 
        std::cerr << "Insufficient number of file descriptors: " << needed
                  << " are needed, but only " << available << " are available.\n";
 
        return false;
    }
#endif
 
    return true;
}
 
void
printHelp(po::options_description const& desc)
{
    std::cerr << systemName() << " [options] <command> <params>\n"
              << desc << std::endl
              << "Commands: \n"
                 "     account_currencies <account> [<ledger>]\n"
                 "     account_info <account>|<key> [<ledger>]\n"
                 "     account_lines <account> <account>|\"\" [<ledger>]\n"
                 "     account_channels <account> <account>|\"\" [<ledger>]\n"
                 "     account_objects <account> [<ledger>]\n"
                 "     account_offers <account>|<account_public_key> [<ledger>]\n"
                 "     account_tx accountID [ledger_index_min [ledger_index_max "
                 "[limit "
                 "]]] [binary]\n"
                 "     book_changes [<ledger hash|id>]\n"
                 "     book_offers <taker_pays> <taker_gets> [<taker [<ledger> "
                 "[<limit> [<proof> [<marker>]]]]]\n"
                 "     can_delete [<ledgerid>|<ledgerhash>|now|always|never]\n"
                 "     channel_authorize <private_key> <channel_id> <drops>\n"
                 "     channel_verify <public_key> <channel_id> <drops> <signature>\n"
                 "     connect <ip> [<port>]\n"
                 "     consensus_info\n"
                 "     deposit_authorized <source_account> <destination_account> "
                 "[<ledger> [<credentials>, ...]]\n"
                 "     feature [<feature> [accept|reject]]\n"
                 "     fetch_info [clear]\n"
                 "     gateway_balances [<ledger>] <issuer_account> [ <hotwallet> [ "
                 "<hotwallet> ]]\n"
                 "     get_counts\n"
                 "     json <method> <json>\n"
                 "     ledger [<id>|current|closed|validated] [full]\n"
                 "     ledger_accept\n"
                 "     ledger_cleaner\n"
                 "     ledger_closed\n"
                 "     ledger_current\n"
                 "     ledger_request <ledger>\n"
                 "     log_level [[<partition>] <severity>]\n"
                 "     logrotate\n"
                 "     manifest <public_key>\n"
                 "     peers\n"
                 "     ping\n"
                 "     random\n"
                 "     peer_reservations_add <public_key> [<description>]\n"
                 "     peer_reservations_del <public_key>\n"
                 "     peer_reservations_list\n"
                 "     ripple ...\n"
                 "     ripple_path_find <json> [<ledger>]\n"
                 "     server_definitions [<hash>]\n"
                 "     server_info [counters]\n"
                 "     server_state [counters]\n"
                 "     sign <private_key> <tx_json> [offline]\n"
                 "     sign_for <signer_address> <signer_private_key> <tx_json> "
                 "[offline] [<signature_field>]\n"
                 "     stop\n"
                 "     simulate [<tx_blob>|<tx_json>] [<binary>]\n"
                 "     submit <tx_blob>|[<private_key> <tx_json>]\n"
                 "     submit_multisigned <tx_json>\n"
                 "     tx <id>\n"
                 "     validation_create [<seed>|<pass_phrase>|<key>]\n"
                 "     validator_info\n"
                 "     validators\n"
                 "     validator_list_sites\n"
                 "     version\n"
                 "     wallet_propose [<passphrase>]\n";
}
 
//------------------------------------------------------------------------------
 
#ifdef ENABLE_TESTS
/* simple unit test selector that allows a comma separated list
 * of selectors
 */
class MultiSelector
{
private:
    std::vector<beast::unit_test::Selector> selectors_;
 
public:
    explicit MultiSelector(std::string const& patterns = "")
    {
        std::vector<std::string> v;
        boost::split(v, patterns, boost::algorithm::is_any_of(","));
        selectors_.reserve(v.size());
        std::ranges::for_each(v, [this](std::string s) {
            boost::trim(s);
            if (selectors_.empty() || !s.empty())
                selectors_.emplace_back(beast::unit_test::Selector::ModeT::Automatch, s);
        });
    }
 
    bool
    operator()(beast::unit_test::SuiteInfo const& s)
    {
        for (auto& sel : selectors_)
        {
            if (sel(s))
                return true;
        }
        return false;
    }
 
    [[nodiscard]] std::size_t
    size() const
    {
        return selectors_.size();
    }
};
 
namespace test {
extern std::atomic<bool> gEnvUseIPv4;
}  // namespace test
 
template <class Runner>
static bool
anyMissing(Runner& runner, MultiSelector const& pred)
{
    if (runner.tests() == 0)
    {
        runner.addFailures(1);
        std::cout << "Failed: No tests run" << std::endl;
        return true;
    }
    if (runner.suites() < pred.size())
    {
        auto const missing = pred.size() - runner.suites();
        runner.addFailures(missing);
        std::cout << "Failed: " << missing << " filters did not match any existing test suites"
                  << std::endl;
        return true;
    }
    return false;
}
 
static int
runUnitTests(
    std::string const& pattern,
    std::string const& argument,
    bool quiet,
    bool log,
    bool child,
    bool ipv6,
    std::size_t numJobs,
    int argc,
    char** argv)
{
    using namespace beast::unit_test;
    using namespace xrpl::test;
 
    xrpl::test::gEnvUseIPv4 = (!ipv6);
 
    if (!child && numJobs == 1)
    {
        MultiRunnerParent const parentRunner;
 
        MultiRunnerChild childRunner{numJobs, quiet, log};
        childRunner.arg(argument);
        MultiSelector const pred(pattern);
        auto const anyFailed = childRunner.runMulti(pred) || anyMissing(childRunner, pred);
 
        if (anyFailed)
            return EXIT_FAILURE;
        return EXIT_SUCCESS;
    }
    if (!child)
    {
        MultiRunnerParent parentRunner;
        std::vector<boost::process::v1::child> children;
 
        std::string const exeName = argv[0];
        std::vector<std::string> args;
        {
            args.reserve(argc);
            for (int i = 1; i < argc; ++i)
                args.emplace_back(argv[i]);
            args.emplace_back("--unittest-child");
        }
 
        children.reserve(numJobs);
        for (std::size_t i = 0; i < numJobs; ++i)
        {
            children.emplace_back(
                boost::process::v1::exe = exeName, boost::process::v1::args = args);
        }
 
        int badChildExits = 0;
        int terminatedChildExits = 0;
        for (auto& c : children)
        {
            try
            {
                c.wait();
                if (c.exit_code() != 0)
                    ++badChildExits;
            }
            catch (...)
            {
                // wait throws if process was terminated with a signal
                ++badChildExits;
                ++terminatedChildExits;
            }
        }
 
        parentRunner.addFailures(terminatedChildExits);
        anyMissing(parentRunner, MultiSelector(pattern));
 
        if (parentRunner.anyFailed() || (badChildExits != 0))
            return EXIT_FAILURE;
        return EXIT_SUCCESS;
    }
 
    // child
    MultiRunnerChild runner{numJobs, quiet, log};
    runner.arg(argument);
    auto const anyFailed = runner.runMulti(MultiSelector(pattern));
 
    if (anyFailed)
        return EXIT_FAILURE;
    return EXIT_SUCCESS;
}
 
#endif  // ENABLE_TESTS
//------------------------------------------------------------------------------
 
int
run(int argc, char** argv)
{
    using namespace std;
 
    beast::setCurrentThreadName("xrpld-main");
 
    po::variables_map vm;
 
    std::string importText;
    {
        importText += "Import an existing node database (specified in the [";
        importText += Sections::kImportNodeDatabase;
        importText += "] configuration file section) into the current ";
        importText += "node database (specified in the [";
        importText += Sections::kNodeDatabase;
        importText += "] configuration file section).";
    }
 
    // Set up option parsing.
    //
    po::options_description gen("General Options");
    gen.add_options()("conf", po::value<std::string>(), "Specify the configuration file.")(
        "debug", "Enable normally suppressed debug logging")("help,h", "Display this message.")(
        "newnodeid", "Generate a new node identity for this server.")(
        "nodeid", po::value<std::string>(), "Specify the node identity for this server.")(
        "quorum", po::value<std::size_t>(), "Override the minimum validation quorum.")(
        "silent", "No output to the console after startup.")("standalone,a", "Run with no peers.")(
        "verbose,v", "Verbose logging.")(
        "definitions", "Output server definitions as JSON and exit.")(
        "force_ledger_present_range",
        po::value<std::string>(),
        "Specify the range of present ledgers for testing purposes. Min and "
        "max values are comma separated.")("version", "Display the build version.");
 
    po::options_description data("Ledger/Data Options");
    data.add_options()("import", importText.c_str())(
        "ledger",
        po::value<std::string>(),
        "Load the specified ledger and start from the value given.")(
        "ledgerfile", po::value<std::string>(), "Load the specified ledger file.")(
        "load", "Load the current ledger from the local DB.")(
        "net", "Get the initial ledger from the network.")("replay", "Replay a ledger close.")(
        "trap_tx_hash", po::value<std::string>(), "Trap a specific transaction during replay.")(
        "start", "Start from a fresh Ledger.")("vacuum", "VACUUM the transaction db.")(
        "valid", "Consider the initial ledger a valid network ledger.");
 
    po::options_description rpc("RPC Client Options");
    rpc.add_options()(
        "rpc",
        "Perform rpc command - see below for available commands. "
        "This is assumed if any positional parameters are provided.")(
        "rpc_ip",
        po::value<std::string>(),
        "Specify the IP address for RPC command. "
        "Format: <ip-address>[':'<port-number>]")(
        "rpc_port",
        po::value<std::uint16_t>(),
        "DEPRECATED: include with rpc_ip instead. "
        "Specify the port number for RPC command.");
 
#ifdef ENABLE_TESTS
    po::options_description test("Unit Test Options");
    test.add_options()(
        "quiet,q",
        "Suppress test suite messages, "
        "including suite/case name (at start) and test log messages.")(
        "unittest,u",
        po::value<std::string>()->implicit_value(""),
        "Perform unit tests. The optional argument specifies one or "
        "more comma-separated selectors. Each selector specifies a suite name, "
        "suite name prefix, full-name (lib.module.suite), module, or library "
        "(checked in that order).")(
        "unittest-arg",
        po::value<std::string>()->implicit_value(""),
        "Supplies an argument string to unit tests. If provided, this argument "
        "is made available to each suite that runs. Interpretation of the "
        "argument is handled individually by any suite that accesses it -- "
        "as such, it typically only make sense to provide this when running "
        "a single suite.")(
        "unittest-ipv6", "Use IPv6 localhost when running unittests (default is IPv4).")(
        "unittest-log",
        "Force unit test log message output. Only useful in combination with "
        "--quiet, in which case log messages will print but suite/case names "
        "will not.")(
        "unittest-jobs",
        po::value<std::size_t>(),
        "Number of unittest jobs to run in parallel (child processes).");
#endif  // ENABLE_TESTS
 
    // These are hidden options, not intended to be shown in the usage/help
    // message
    po::options_description hidden("Hidden Options");
    hidden.add_options()(
        "parameters",
        po::value<vector<string>>(),
        "Specify rpc command and parameters. This option must be repeated "
        "for each command/param. Positional parameters also serve this "
        "purpose, "
        "so this option is not needed for users")
#ifdef ENABLE_TESTS
        ("unittest-child", "For internal use only when spawning child unit test processes.")
#else
        ("unittest", "Disabled in this build.")("unittest-child", "Disabled in this build.")
#endif  // ENABLE_TESTS
            ("fg", "Deprecated: server always in foreground mode.");
 
    // Interpret positional arguments as --parameters.
    po::positional_options_description p;
    p.add("parameters", -1);
 
    po::options_description all;
    all.add(gen)
        .add(rpc)
        .add(data)
#ifdef ENABLE_TESTS
        .add(test)
#endif  // ENABLE_TESTS
        .add(hidden);
 
    po::options_description desc;
    desc.add(gen)
        .add(rpc)
        .add(data)
#ifdef ENABLE_TESTS
        .add(test)
#endif  // ENABLE_TESTS
        ;
 
    // Parse options, if no error.
    try
    {
        po::store(
            po::command_line_parser(argc, argv)
                .options(all)   // Parse options.
                .positional(p)  // Remainder as --parameters.
                .run(),
            vm);
        po::notify(vm);  // Invoke option notify functions.
    }
    catch (std::exception const& ex)
    {
        std::cerr << "xrpld: " << ex.what() << std::endl;
        std::cerr << "Try 'xrpld --help' for a list of options." << std::endl;
        return 1;
    }
 
    if (vm.contains("help"))
    {
        printHelp(desc);
        return 0;
    }
 
    if (vm.contains("version"))
    {
        // LCOV_EXCL_START
        std::cout << "xrpld version " << BuildInfo::getVersionString() << std::endl;
        std::cout << "Git commit hash: " << xrpl::git::getCommitHash() << std::endl;
        std::cout << "Git build branch: " << xrpl::git::getBuildBranch() << std::endl;
        return 0;
        // LCOV_EXCL_STOP
    }
 
    if (vm.contains("definitions"))
    {
        // LCOV_EXCL_START
        std::cout << json::FastWriter().write(getServerDefinitionsJson());
        return 0;
        // LCOV_EXCL_STOP
    }
 
#ifndef ENABLE_TESTS
    if (vm.count("unittest") || vm.count("unittest-child"))
    {
        std::cerr << "xrpld: Tests disabled in this build." << std::endl;
        std::cerr << "Try 'xrpld --help' for a list of options." << std::endl;
        return 1;
    }
#else
    // Run the unit tests if requested.
    // The unit tests will exit the application with an appropriate return code.
    //
    if (vm.contains("unittest"))
    {
        std::string argument;
 
        if (vm.contains("unittest-arg"))
            argument = vm["unittest-arg"].as<std::string>();
 
        std::size_t numJobs = 1;
        bool unittestChild = false;
        if (vm.contains("unittest-jobs"))
            numJobs = std::max(numJobs, vm["unittest-jobs"].as<std::size_t>());
        unittestChild = vm.contains("unittest-child");
 
        return runUnitTests(
            vm["unittest"].as<std::string>(),
            argument,
            vm.contains("quiet"),
            vm.contains("unittest-log"),
            unittestChild,
            vm.contains("unittest-ipv6"),
            numJobs,
            argc,
            argv);
    }
    // LCOV_EXCL_START
 
    if (vm.contains("unittest-jobs"))
    {
        // unittest jobs only makes sense with `unittest`
        std::cerr << "xrpld: '--unittest-jobs' specified without "
                     "'--unittest'.\n";
        std::cerr << "To run the unit tests the '--unittest' option must "
                     "be present.\n";
        return 1;
    }
 
#endif  // ENABLE_TESTS
 
    auto config = std::make_unique<Config>();
 
    auto configFile = vm.contains("conf") ? vm["conf"].as<std::string>() : std::string();
 
    // config file, quiet flag.
    config->setup(
        configFile, vm.contains("quiet"), vm.contains("silent"), vm.contains("standalone"));
 
    if (vm.contains("vacuum"))
    {
        if (config->standalone())
        {
            std::cerr << "vacuum not applicable in standalone mode.\n";
            return -1;
        }
 
        try
        {
            auto setup = setupDatabaseCon(*config);
            if (!doVacuumDB(setup, config->journal()))
                return -1;
        }
        catch (std::exception const& e)
        {
            std::cerr << "exception " << e.what() << " in function " << __func__ << std::endl;
            return -1;
        }
 
        return 0;
    }
 
    if (vm.contains("force_ledger_present_range"))
    {
        try
        {
            auto const r = [&vm]() -> std::vector<std::uint32_t> {
                std::vector<std::string> strVec;
                boost::split(
                    strVec,
                    vm["force_ledger_present_range"].as<std::string>(),
                    boost::algorithm::is_any_of(","));
                std::vector<std::uint32_t> result;
                for (auto& s : strVec)
                {
                    boost::trim(s);
                    if (!s.empty())
                        result.push_back(std::stoi(s));
                }
                return result;
            }();
 
            if (r.size() == 2)
            {
                if (r[0] > r[1])
                {
                    throw std::runtime_error("Invalid force_ledger_present_range parameter");
                }
                config->forcedLedgerRangePresent.emplace(r[0], r[1]);
            }
            else
            {
                throw std::runtime_error("Invalid force_ledger_present_range parameter");
            }
        }
        catch (std::exception const& e)
        {
            std::cerr << "invalid 'force_ledger_present_range' parameter. The "
                         "parameter must be two numbers separated by a comma. "
                         "The first number must be <= the second."
                      << std::endl;
            return -1;
        }
    }
 
    if (vm.contains("start"))
    {
        config->startUp = StartUpType::Fresh;
    }
 
    if (vm.contains("import"))
        config->doImport = true;
 
    if (vm.contains("ledger"))
    {
        config->startLedger = vm["ledger"].as<std::string>();
        if (vm.contains("replay"))
        {
            config->startUp = StartUpType::Replay;
            if (vm.contains("trap_tx_hash"))
            {
                uint256 tmp = {};
                auto hash = vm["trap_tx_hash"].as<std::string>();
                if (tmp.parseHex(hash))
                {
                    config->trapTxHash = tmp;
                }
                else
                {
                    std::cerr << "Trap parameter was ill-formed, expected "
                                 "valid transaction hash but received: "
                              << hash << std::endl;
                    return -1;
                }
            }
        }
        else
        {
            config->startUp = StartUpType::Load;
        }
    }
    else if (vm.contains("ledgerfile"))
    {
        config->startLedger = vm["ledgerfile"].as<std::string>();
        config->startUp = StartUpType::LoadFile;
    }
    else if (vm.contains("load") || config->fastLoad)
    {
        config->startUp = StartUpType::Load;
    }
 
    if (vm.contains("trap_tx_hash") && !vm.contains("replay"))
    {
        std::cerr << "Cannot use trap option without replay option" << std::endl;
        return -1;
    }
 
    if (vm.contains("net") && !config->fastLoad)
    {
        if ((config->startUp == StartUpType::Load) || (config->startUp == StartUpType::Replay))
        {
            std::cerr << "Net and load/replay options are incompatible" << std::endl;
            return -1;
        }
 
        config->startUp = StartUpType::Network;
    }
 
    if (vm.contains("valid"))
    {
        config->startValid = true;
    }
 
    // Override the RPC destination IP address. This must
    // happen after the config file is loaded.
    if (vm.contains("rpc_ip"))
    {
        auto endpoint = beast::IP::Endpoint::fromStringChecked(vm["rpc_ip"].as<std::string>());
        if (!endpoint)
        {
            std::cerr << "Invalid rpc_ip = " << vm["rpc_ip"].as<std::string>() << "\n";
            return -1;
        }
 
        if (endpoint->port() == 0)
        {
            std::cerr << "No port specified in rpc_ip.\n";
            if (vm.contains("rpc_port"))
            {
                std::cerr << "WARNING: using deprecated rpc_port param.\n";
                try
                {
                    endpoint = endpoint->atPort(vm["rpc_port"].as<std::uint16_t>());
                    if (endpoint->port() == 0)
                        throw std::domain_error("0");
                }
                catch (std::exception const& e)
                {
                    std::cerr << "Invalid rpc_port = " << e.what() << "\n";
                    return -1;
                }
            }
            else
            {
                return -1;
            }
        }
 
        config->rpcIp = std::move(*endpoint);
    }
 
    if (vm.contains("quorum"))
    {
        try
        {
            config->validationQuorum = vm["quorum"].as<std::size_t>();
            if (config->validationQuorum == std::size_t{})
            {
                throw std::domain_error("0");
            }
        }
        catch (std::exception const& e)
        {
            std::cerr << "Invalid value specified for --quorum (" << e.what() << ")\n";
            return -1;
        }
    }
 
    // Construct the logs object at the configured severity
    using beast::Severity;
    Severity thresh = Severity::Info;
 
    if (vm.contains("quiet"))
    {
        thresh = Severity::Fatal;
    }
    else if (vm.contains("verbose"))
    {
        thresh = Severity::Trace;
    }
 
    auto logs = std::make_unique<Logs>(thresh);
 
    // No arguments. Run server.
    if (!vm.contains("parameters"))
    {
        if (config->hadTrailingComments())
        {
            JLOG(logs->journal("Application").warn())
                << "Trailing comments were seen in your config file. "
                << "The treatment of inline/trailing comments has changed "
                   "recently. "
                << "Any `#` characters NOT intended to delimit comments should "
                   "be "
                << "preceded by a \\";
        }
 
        // We want at least 1024 file descriptors. We'll
        // tweak this further.
        if (!adjustDescriptorLimit(1024, logs->journal("Application")))
            return -1;
 
        if (vm.contains("debug"))
            setDebugLogSink(logs->makeSink("Debug", beast::Severity::Trace));
 
        auto app =
            makeApplication(std::move(config), std::move(logs), std::make_unique<TimeKeeper>());
 
        if (!app->setup(vm))
            return -1;
 
        // With our configuration parsed, ensure we have
        // enough file descriptors available:
        if (!adjustDescriptorLimit(app->fdRequired(), app->getJournal("Application")))
            return -1;
 
        // Start the server
        app->start(true /*start timers*/);
 
        // Block until we get a stop RPC.
        app->run();
 
        return 0;
    }
 
    // We have an RPC command to process:
    beast::setCurrentThreadName("xrpld: rpc");
    return RPCCall::fromCommandLine(
        *config, vm["parameters"].as<std::vector<std::string>>(), *logs);
    // LCOV_EXCL_STOP
}
 
}  // namespace xrpl
 
int
main(int argc, char** argv)
{
#if BOOST_OS_WINDOWS
    {
        // Work around for https://svn.boost.org/trac/boost/ticket/10657
        // Reported against boost version 1.56.0.  If an application's
        // first call to GetTimeZoneInformation is from a coroutine, an
        // unhandled exception is generated.  A workaround is to call
        // GetTimeZoneInformation at least once before launching any
        // coroutines.  At the time of this writing the _ftime call is
        // used to initialize the timezone information.
        struct _timeb t;
#ifdef _INC_TIME_INL
        _ftime_s(&t);
#else
        _ftime(&t);
#endif
    }
#endif
 
    atexit(&google::protobuf::ShutdownProtobufLibrary);
 
    return xrpl::run(argc, argv);
}