Inside Bitcoin

751                break;
752            case OptionsCategory::NODE_RELAY:
753                usage += HelpMessageGroup("Node relay options:");
754                break;
755            case OptionsCategory::BLOCK_CREATION:
756                usage += HelpMessageGroup("Block creation options:");
757                break;
758            case OptionsCategory::RPC:
759                usage += HelpMessageGroup("RPC server options:");
760                break;
761            case OptionsCategory::IPC:
762                usage += HelpMessageGroup("IPC interprocess connection options:");
763                break;
764            case OptionsCategory::WALLET:
765                usage += HelpMessageGroup("Wallet options:");
766                break;
767            case OptionsCategory::WALLET_DEBUG_TEST:
768                if (show_debug) usage += HelpMessageGroup("Wallet debugging/testing options:");
769                break;
770            case OptionsCategory::CHAINPARAMS:
771                usage += HelpMessageGroup("Chain selection options:");
772                break;
773            case OptionsCategory::GUI:
774                usage += HelpMessageGroup("UI Options:");
775                break;
776            case OptionsCategory::COMMANDS:
777                usage += HelpMessageGroup("Commands:");
778                break;
779            case OptionsCategory::REGISTER_COMMANDS:
780                usage += HelpMessageGroup("Register Commands:");
781                break;
782            case OptionsCategory::CLI_COMMANDS:
783                usage += HelpMessageGroup("CLI Commands:");
784                break;
785            case OptionsCategory::COMMAND_OPTIONS:
786            case OptionsCategory::HIDDEN:
787                break;
788        } // no default case, so the compiler can warn about missing cases
789
790        if (category == OptionsCategory::COMMAND_OPTIONS) continue;
791
792        // When we get to the hidden options, stop
793        if (category == OptionsCategory::HIDDEN) break;
794
795        for (const auto& [arg_name, arg_info] : category_args) {
796            if (show_debug || !(arg_info.m_flags & ArgsManager::DEBUG_ONLY)) {
797                usage += HelpMessageOpt(arg_name, arg_info.m_help_param, arg_info.m_help_text);
798
799                if (category == OptionsCategory::COMMANDS) {
800                    const auto cmd_args = m_command_args.find(arg_name);
801                    if (cmd_args == m_command_args.end()) continue;
802                    for_matching_cmd_opts(cmd_args->second, [&](const auto& cmdopt_name, const auto& cmdopt_info) {
803                        usage += HelpMessageOpt(cmdopt_name, cmdopt_info.m_help_param, cmdopt_info.m_help_text, /*subopt=*/true);
804                    });
805                }
806            }
807        }
808    }
809    return usage;
810}
811
812bool HelpRequested(const ArgsManager& args)
813{
814    return args.IsArgSet("-?") || args.IsArgSet("-h") || args.IsArgSet("-help") || args.IsArgSet("-help-debug");
815}
816
817void SetupHelpOptions(ArgsManager& args)
818{
819    args.AddArg("-help", "Print this help message and exit (also -h or -?)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
820    args.AddHiddenArgs({"-h", "-?"});
821}
822
823std::string HelpMessageGroup(const std::string &message) {
824    return std::string(message) + std::string("\n\n");
825}
826
827std::string HelpMessageOpt(std::string_view option, std::string_view help_param, std::string_view message, bool subopt)
828{
829    constexpr int screen_width = 79;
830    int opt_indent = 2;
831    int msg_indent = 7;
832
833    if (subopt) {
834        int bump = msg_indent - opt_indent;
835        opt_indent += bump; // opt_indent now at the old msg_indent level
836        msg_indent += bump; // indent by the same amount
837    }
838    int msg_width = screen_width - msg_indent;
839
840    return strprintf("%*s%s%s\n%*s%s\n\n",
841                     opt_indent, "", option, help_param,
842                     msg_indent, "", FormatParagraph(message, msg_width, msg_indent));
843}
844
845const std::vector<std::string> TEST_OPTIONS_DOC{
846    "addrman (use deterministic addrman)",
847    "reindex_after_failure_noninteractive_yes (When asked for a reindex after failure interactively, simulate as-if answered with 'yes')",
848    "bip94 (enforce BIP94 consensus rules)",
849};
850
851bool HasTestOption(const ArgsManager& args, const std::string& test_option)
852{
853    const auto options = args.GetArgs("-test");
854    return std::any_of(options.begin(), options.end(), [test_option](const auto& option) {
855        return option == test_option;
856    });
857}
858
859fs::path GetDefaultDataDir()
860{
861    // Windows:
862    //   old: C:\Users\Username\AppData\Roaming\Bitcoin
863    //   new: C:\Users\Username\AppData\Local\Bitcoin
864    // macOS: ~/Library/Application Support/Bitcoin
865    // Unix-like: ~/.bitcoin
866#ifdef WIN32
867    // Windows
868    // Check for existence of datadir in old location and keep it there
869    fs::path legacy_path = GetSpecialFolderPath(CSIDL_APPDATA) / "Bitcoin";
870    if (fs::exists(legacy_path)) return legacy_path;
871
872    // Otherwise, fresh installs can start in the new, "proper" location
873    return GetSpecialFolderPath(CSIDL_LOCAL_APPDATA) / "Bitcoin";
874#else
875    fs::path pathRet;
876    char* pszHome = getenv("HOME");
877    if (pszHome == nullptr || strlen(pszHome) == 0)
878        pathRet = fs::path("/");
879    else
880        pathRet = fs::path(pszHome);
881#ifdef __APPLE__
882    // macOS
883    return pathRet / "Library/Application Support/Bitcoin";
884#else
885    // Unix-like
886    return pathRet / ".bitcoin";
887#endif
888#endif
889}
890
891bool CheckDataDirOption(const ArgsManager& args)
892{
893    const fs::path datadir{args.GetPathArg("-datadir")};
894    return datadir.empty() || fs::is_directory(fs::absolute(datadir));
895}
896
897fs::path ArgsManager::GetConfigFilePath() const
898{
899    LOCK(cs_args);
900    return *Assert(m_config_path);
901}
902
903void ArgsManager::SetConfigFilePath(fs::path path)
904{
905    LOCK(cs_args);
906    assert(!m_config_path);
907    m_config_path = path;
908}
909
910ChainType ArgsManager::GetChainType() const
911{
912    std::variant<ChainType, std::string> arg = GetChainArg();
913    if (auto* parsed = std::get_if<ChainType>(&arg)) return *parsed;
914    throw std::runtime_error(strprintf("Unknown chain %s.", std::get<std::string>(arg)));
915}
916
917std::string ArgsManager::GetChainTypeString() const
918{
919    auto arg = GetChainArg();
920    if (auto* parsed = std::get_if<ChainType>(&arg)) return ChainTypeToString(*parsed);
921    return std::get<std::string>(arg);
922}
923
924std::variant<ChainType, std::string> ArgsManager::GetChainArg() const
925{
926    auto get_net = [&](const std::string& arg) {
927        LOCK(cs_args);
928        common::SettingsValue value = common::GetSetting(m_settings, /* section= */ "", SettingName(arg),
929            /* ignore_default_section_config= */ false,
930            /*ignore_nonpersistent=*/false,
931            /* get_chain_type= */ true);
932        return value.isNull() ? false : value.isBool() ? value.get_bool() : InterpretBool(value.get_str());
933    };
934
935    const bool fRegTest = get_net("-regtest");
936    const bool fSigNet  = get_net("-signet");
937    const bool fTestNet = get_net("-testnet");
938    const bool fTestNet4 = get_net("-testnet4");
939    const auto chain_arg = GetArg("-chain");
940
941    if ((int)chain_arg.has_value() + (int)fRegTest + (int)fSigNet + (int)fTestNet + (int)fTestNet4 > 1) {
942        throw std::runtime_error("Invalid combination of -regtest, -signet, -testnet, -testnet4 and -chain. Can use at most one.");
943    }
944    if (chain_arg) {
945        if (auto parsed = ChainTypeFromString(*chain_arg)) return *parsed;
946        // Not a known string, so return original string
947        return *chain_arg;
948    }
949    if (fRegTest) return ChainType::REGTEST;
950    if (fSigNet) return ChainType::SIGNET;
951    if (fTestNet) return ChainType::TESTNET;
952    if (fTestNet4) return ChainType::TESTNET4;
953    return ChainType::MAIN;
954}
955
956bool ArgsManager::UseDefaultSection(const std::string& arg) const
957{
958    AssertLockHeld(cs_args);
959    return m_network == ChainTypeToString(ChainType::MAIN) || !m_network_only_args.contains(arg);
960}
961
962common::SettingsValue ArgsManager::GetSetting_(const std::string& arg) const
963{
964    AssertLockHeld(cs_args);
965    return common::GetSetting(
966        m_settings, m_network, SettingName(arg), !UseDefaultSection(arg),
967        /*ignore_nonpersistent=*/false, /*get_chain_type=*/false);
968}
969
970common::SettingsValue ArgsManager::GetSetting(const std::string& arg) const
971{
972    LOCK(cs_args);
973    return GetSetting_(arg);
974}
975
976std::vector<common::SettingsValue> ArgsManager::GetSettingsList(const std::string& arg) const
977{
978    LOCK(cs_args);
979    return common::GetSettingsList(m_settings, m_network, SettingName(arg), !UseDefaultSection(arg));
980}
981
982void ArgsManager::logArgsPrefix(
983    const std::string& prefix,
984    const std::string& section,
985    const std::map<std::string, std::vector<common::SettingsValue>>& args) const
986{
987    AssertLockHeld(cs_args);
988    std::string section_str = section.empty() ? "" : "[" + section + "] ";
989    for (const auto& arg : args) {
990        for (const auto& value : arg.second) {
991            std::optional<unsigned int> flags = GetArgFlags_('-' + arg.first);
992            if (flags) {
993                std::string value_str = (*flags & SENSITIVE) ? "****" : value.write();
994                LogInfo("%s %s%s=%s\n", prefix, section_str, arg.first, value_str);
995            }
996        }
997    }
998}
999
1000void ArgsManager::LogArgs() const