Inside Bitcoin

501    }
502    return true;
503}
504
505common::SettingsValue ArgsManager::GetPersistentSetting(const std::string& name) const
506{
507    LOCK(cs_args);
508    return common::GetSetting(m_settings, m_network, name, !UseDefaultSection("-" + name),
509        /*ignore_nonpersistent=*/true, /*get_chain_type=*/false);
510}
511
512bool ArgsManager::IsArgNegated(const std::string& strArg) const
513{
514    return GetSetting(strArg).isFalse();
515}
516
517std::string ArgsManager::GetArg(const std::string& strArg, const std::string& strDefault) const
518{
519    return GetArg(strArg).value_or(strDefault);
520}
521
522std::optional<std::string> ArgsManager::GetArg(const std::string& strArg) const
523{
524    const common::SettingsValue value = GetSetting(strArg);
525    return SettingToString(value);
526}
527
528std::optional<std::string> SettingToString(const common::SettingsValue& value)
529{
530    if (value.isNull()) return std::nullopt;
531    if (value.isFalse()) return "0";
532    if (value.isTrue()) return "1";
533    if (value.isNum()) return value.getValStr();
534    return value.get_str();
535}
536
537std::string SettingToString(const common::SettingsValue& value, const std::string& strDefault)
538{
539    return SettingToString(value).value_or(strDefault);
540}
541
542template <std::integral Int>
543Int ArgsManager::GetArg(const std::string& strArg, Int nDefault) const
544{
545    return GetArg<Int>(strArg).value_or(nDefault);
546}
547
548template <std::integral Int>
549std::optional<Int> ArgsManager::GetArg(const std::string& strArg) const
550{
551    const common::SettingsValue value = GetSetting(strArg);
552    return SettingTo<Int>(value);
553}
554
555template <std::integral Int>
556std::optional<Int> SettingTo(const common::SettingsValue& value)
557{
558    if (value.isNull()) return std::nullopt;
559    if (value.isFalse()) return 0;
560    if (value.isTrue()) return 1;
561    if (value.isNum()) return value.getInt<Int>();
562    return LocaleIndependentAtoi<Int>(value.get_str());
563}
564
565template <std::integral Int>
566Int SettingTo(const common::SettingsValue& value, Int nDefault)
567{
568    return SettingTo<Int>(value).value_or(nDefault);
569}
570
571bool ArgsManager::GetBoolArg(const std::string& strArg, bool fDefault) const
572{
573    return GetBoolArg(strArg).value_or(fDefault);
574}
575
576std::optional<bool> ArgsManager::GetBoolArg(const std::string& strArg) const
577{
578    const common::SettingsValue value = GetSetting(strArg);
579    return SettingToBool(value);
580}
581
582std::optional<bool> SettingToBool(const common::SettingsValue& value)
583{
584    if (value.isNull()) return std::nullopt;
585    if (value.isBool()) return value.get_bool();
586    return InterpretBool(value.get_str());
587}
588
589bool SettingToBool(const common::SettingsValue& value, bool fDefault)
590{
591    return SettingToBool(value).value_or(fDefault);
592}
593
594#define INSTANTIATE_INT_TYPE(Type)                                                    \
595    template Type ArgsManager::GetArg<Type>(const std::string&, Type) const;          \
596    template std::optional<Type> ArgsManager::GetArg<Type>(const std::string&) const; \
597    template Type SettingTo<Type>(const common::SettingsValue&, Type);                \
598    template std::optional<Type> SettingTo<Type>(const common::SettingsValue&)
599
600INSTANTIATE_INT_TYPE(int8_t);
601INSTANTIATE_INT_TYPE(uint8_t);
602INSTANTIATE_INT_TYPE(int16_t);
603INSTANTIATE_INT_TYPE(uint16_t);
604INSTANTIATE_INT_TYPE(int32_t);
605INSTANTIATE_INT_TYPE(uint32_t);
606INSTANTIATE_INT_TYPE(int64_t);
607INSTANTIATE_INT_TYPE(uint64_t);
608
609#undef INSTANTIATE_INT_TYPE
610
611bool ArgsManager::SoftSetArg(const std::string& strArg, const std::string& strValue)
612{
613    LOCK(cs_args);
614    if (!GetSetting_(strArg).isNull()) return false;
615    m_settings.forced_settings[SettingName(strArg)] = strValue;
616    return true;
617}
618
619bool ArgsManager::SoftSetBoolArg(const std::string& strArg, bool fValue)
620{
621    if (fValue)
622        return SoftSetArg(strArg, std::string("1"));
623    else
624        return SoftSetArg(strArg, std::string("0"));
625}
626
627void ArgsManager::ForceSetArg(const std::string& strArg, const std::string& strValue)
628{
629    LOCK(cs_args);
630    m_settings.forced_settings[SettingName(strArg)] = strValue;
631}
632
633void ArgsManager::AddCommand(const std::string& cmd, const std::string& help, std::set<std::string> options)
634{
635    Assert(cmd.find('=') == std::string::npos);
636    Assert(cmd.at(0) != '-');
637
638    LOCK(cs_args);
639    m_accept_any_command = false; // latch to false
640    std::map<std::string, Arg>& arg_map = m_available_args[OptionsCategory::COMMANDS];
641    auto ret = arg_map.emplace(cmd, Arg{"", help, ArgsManager::COMMAND});
642    if (!options.empty()) {
643        auto& cmdopts = m_available_args[OptionsCategory::COMMAND_OPTIONS];
644        bool command_has_all_options_defined = true;
645        for (const auto& opt : options) {
646            if (!cmdopts.contains(opt)) {
647                command_has_all_options_defined = false;
648            }
649        }
650        Assert(command_has_all_options_defined);
651
652        m_command_args.try_emplace(cmd, std::move(options));
653    }
654    Assert(ret.second); // Fail on duplicate commands
655}
656
657void ArgsManager::AddArg(const std::string& name, const std::string& help, unsigned int flags, const OptionsCategory& cat)
658{
659    Assert((flags & ArgsManager::COMMAND) == 0); // use AddCommand
660
661    // Split arg name from its help param
662    size_t eq_index = name.find('=');
663    if (eq_index == std::string::npos) {
664        eq_index = name.size();
665    }
666    std::string arg_name = name.substr(0, eq_index);
667
668    LOCK(cs_args);
669
670    // Allow duplicates involving HIDDEN — it is used as a placeholder for args
671    // unavailable in this binary but tolerated for shared config files (see #13441).
672    for (const auto& arg_map : m_available_args) {
673        if (arg_map.first == OptionsCategory::HIDDEN || cat == OptionsCategory::HIDDEN) continue;
674        Assert(!arg_map.second.contains(arg_name));
675    }
676
677    std::map<std::string, Arg>& arg_map = m_available_args[cat];
678    auto ret = arg_map.emplace(arg_name, Arg{name.substr(eq_index, name.size() - eq_index), help, flags});
679    assert(ret.second); // Make sure an insertion actually happened
680
681    if (flags & ArgsManager::NETWORK_ONLY) {
682        m_network_only_args.emplace(arg_name);
683    }
684}
685
686void ArgsManager::AddHiddenArgs(const std::vector<std::string>& names)
687{
688    for (const std::string& name : names) {
689        AddArg(name, "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
690    }
691}
692
693void ArgsManager::ClearArgs()
694{
695    LOCK(cs_args);
696    m_settings = {};
697    m_available_args.clear();
698    m_command_args.clear();
699    m_network_only_args.clear();
700    m_config_sections.clear();
701}
702
703void ArgsManager::CheckMultipleCLIArgs() const
704{
705    LOCK(cs_args);
706    std::vector<std::string> found{};
707    auto cmds = m_available_args.find(OptionsCategory::CLI_COMMANDS);
708    if (cmds != m_available_args.end()) {
709        for (const auto& [cmd, argspec] : cmds->second) {
710            if (!GetSetting_(cmd).isNull()) {
711                found.push_back(cmd);
712            }
713        }
714        if (found.size() > 1) {
715            throw std::runtime_error(strprintf("Only one of %s may be specified.", util::Join(found, ", ")));
716        }
717    }
718}
719
720std::string ArgsManager::GetHelpMessage() const
721{
722    const bool show_debug = GetBoolArg("-help-debug", false);
723
724    std::string usage;
725    LOCK(cs_args);
726
727    const auto command_options = m_available_args.find(OptionsCategory::COMMAND_OPTIONS);
728    const auto for_matching_cmd_opts = [&](const std::set<std::string>& select, auto&& fn) EXCLUSIVE_LOCKS_REQUIRED(cs_args) {
729        if (select.empty()) return;
730        if (command_options == m_available_args.end()) return;
731        for (const auto& [name, info] : command_options->second) {
732            if (!show_debug && (info.m_flags & ArgsManager::DEBUG_ONLY)) continue;
733            if (!select.contains(name)) continue;
734            fn(name, info);
735        }
736    };
737
738    for (const auto& [category, category_args] : m_available_args) {
739        switch(category) {
740            case OptionsCategory::OPTIONS:
741                usage += HelpMessageGroup("Options:");
742                break;
743            case OptionsCategory::CONNECTION:
744                usage += HelpMessageGroup("Connection options:");
745                break;
746            case OptionsCategory::ZMQ:
747                usage += HelpMessageGroup("ZeroMQ notification options:");
748                break;
749            case OptionsCategory::DEBUG_TEST:
750                usage += HelpMessageGroup("Debugging/Testing options:");