config.cpp
1 // Copyright (c) 2023 The Bitcoin Core developers 2 // Distributed under the MIT software license, see the accompanying 3 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 4 5 #include <common/args.h> 6 7 #include <common/settings.h> 8 #include <logging.h> 9 #include <sync.h> 10 #include <tinyformat.h> 11 #include <univalue.h> 12 #include <util/chaintype.h> 13 #include <util/fs.h> 14 #include <util/string.h> 15 16 #include <algorithm> 17 #include <cassert> 18 #include <cstdlib> 19 #include <fstream> 20 #include <iostream> 21 #include <list> 22 #include <map> 23 #include <memory> 24 #include <optional> 25 #include <string> 26 #include <string_view> 27 #include <utility> 28 #include <vector> 29 30 static bool GetConfigOptions(std::istream& stream, const std::string& filepath, std::string& error, std::vector<std::pair<std::string, std::string>>& options, std::list<SectionInfo>& sections) 31 { 32 std::string str, prefix; 33 std::string::size_type pos; 34 int linenr = 1; 35 while (std::getline(stream, str)) { 36 bool used_hash = false; 37 if ((pos = str.find('#')) != std::string::npos) { 38 str = str.substr(0, pos); 39 used_hash = true; 40 } 41 const static std::string pattern = " \t\r\n"; 42 str = TrimString(str, pattern); 43 if (!str.empty()) { 44 if (*str.begin() == '[' && *str.rbegin() == ']') { 45 const std::string section = str.substr(1, str.size() - 2); 46 sections.emplace_back(SectionInfo{section, filepath, linenr}); 47 prefix = section + '.'; 48 } else if (*str.begin() == '-') { 49 error = strprintf("parse error on line %i: %s, options in configuration file must be specified without leading -", linenr, str); 50 return false; 51 } else if ((pos = str.find('=')) != std::string::npos) { 52 std::string name = prefix + TrimString(std::string_view{str}.substr(0, pos), pattern); 53 std::string_view value = TrimStringView(std::string_view{str}.substr(pos + 1), pattern); 54 if (used_hash && name.find("rpcpassword") != std::string::npos) { 55 error = strprintf("parse error on line %i, using # in rpcpassword can be ambiguous and should be avoided", linenr); 56 return false; 57 } 58 options.emplace_back(name, value); 59 if ((pos = name.rfind('.')) != std::string::npos && prefix.length() <= pos) { 60 sections.emplace_back(SectionInfo{name.substr(0, pos), filepath, linenr}); 61 } 62 } else { 63 error = strprintf("parse error on line %i: %s", linenr, str); 64 if (str.size() >= 2 && str.substr(0, 2) == "no") { 65 error += strprintf(", if you intended to specify a negated option, use %s=1 instead", str); 66 } 67 return false; 68 } 69 } 70 ++linenr; 71 } 72 return true; 73 } 74 75 bool IsConfSupported(KeyInfo& key, std::string& error) { 76 if (key.name == "conf") { 77 error = "conf cannot be set in the configuration file; use includeconf= if you want to include additional config files"; 78 return false; 79 } 80 if (key.name == "reindex") { 81 // reindex can be set in a config file but it is strongly discouraged as this will cause the node to reindex on 82 // every restart. Allow the config but throw a warning 83 LogPrintf("Warning: reindex=1 is set in the configuration file, which will significantly slow down startup. Consider removing or commenting out this option for better performance, unless there is currently a condition which makes rebuilding the indexes necessary\n"); 84 return true; 85 } 86 return true; 87 } 88 89 bool ArgsManager::ReadConfigStream(std::istream& stream, const std::string& filepath, std::string& error, bool ignore_invalid_keys) 90 { 91 LOCK(cs_args); 92 std::vector<std::pair<std::string, std::string>> options; 93 if (!GetConfigOptions(stream, filepath, error, options, m_config_sections)) { 94 return false; 95 } 96 for (const std::pair<std::string, std::string>& option : options) { 97 KeyInfo key = InterpretKey(option.first); 98 std::optional<unsigned int> flags = GetArgFlags('-' + key.name); 99 if (!IsConfSupported(key, error)) return false; 100 if (flags) { 101 std::optional<common::SettingsValue> value = InterpretValue(key, &option.second, *flags, error); 102 if (!value) { 103 return false; 104 } 105 m_settings.ro_config[key.section][key.name].push_back(*value); 106 } else { 107 if (ignore_invalid_keys) { 108 LogPrintf("Ignoring unknown configuration value %s\n", option.first); 109 } else { 110 error = strprintf("Invalid configuration value %s", option.first); 111 return false; 112 } 113 } 114 } 115 return true; 116 } 117 118 bool ArgsManager::ReadConfigFiles(std::string& error, bool ignore_invalid_keys) 119 { 120 { 121 LOCK(cs_args); 122 m_settings.ro_config.clear(); 123 m_config_sections.clear(); 124 m_config_path = AbsPathForConfigVal(*this, GetPathArg("-conf", BITCOIN_CONF_FILENAME), /*net_specific=*/false); 125 } 126 127 const auto conf_path{GetConfigFilePath()}; 128 std::ifstream stream{conf_path}; 129 130 // not ok to have a config file specified that cannot be opened 131 if (IsArgSet("-conf") && !stream.good()) { 132 error = strprintf("specified config file \"%s\" could not be opened.", fs::PathToString(conf_path)); 133 return false; 134 } 135 // ok to not have a config file 136 if (stream.good()) { 137 if (!ReadConfigStream(stream, fs::PathToString(conf_path), error, ignore_invalid_keys)) { 138 return false; 139 } 140 // `-includeconf` cannot be included in the command line arguments except 141 // as `-noincludeconf` (which indicates that no included conf file should be used). 142 bool use_conf_file{true}; 143 { 144 LOCK(cs_args); 145 if (auto* includes = common::FindKey(m_settings.command_line_options, "includeconf")) { 146 // ParseParameters() fails if a non-negated -includeconf is passed on the command-line 147 assert(common::SettingsSpan(*includes).last_negated()); 148 use_conf_file = false; 149 } 150 } 151 if (use_conf_file) { 152 std::string chain_id = GetChainTypeString(); 153 std::vector<std::string> conf_file_names; 154 155 auto add_includes = [&](const std::string& network, size_t skip = 0) { 156 size_t num_values = 0; 157 LOCK(cs_args); 158 if (auto* section = common::FindKey(m_settings.ro_config, network)) { 159 if (auto* values = common::FindKey(*section, "includeconf")) { 160 for (size_t i = std::max(skip, common::SettingsSpan(*values).negated()); i < values->size(); ++i) { 161 conf_file_names.push_back((*values)[i].get_str()); 162 } 163 num_values = values->size(); 164 } 165 } 166 return num_values; 167 }; 168 169 // We haven't set m_network yet (that happens in SelectParams()), so manually check 170 // for network.includeconf args. 171 const size_t chain_includes = add_includes(chain_id); 172 const size_t default_includes = add_includes({}); 173 174 for (const std::string& conf_file_name : conf_file_names) { 175 std::ifstream conf_file_stream{AbsPathForConfigVal(*this, fs::PathFromString(conf_file_name), /*net_specific=*/false)}; 176 if (conf_file_stream.good()) { 177 if (!ReadConfigStream(conf_file_stream, conf_file_name, error, ignore_invalid_keys)) { 178 return false; 179 } 180 LogPrintf("Included configuration file %s\n", conf_file_name); 181 } else { 182 error = "Failed to include configuration file " + conf_file_name; 183 return false; 184 } 185 } 186 187 // Warn about recursive -includeconf 188 conf_file_names.clear(); 189 add_includes(chain_id, /* skip= */ chain_includes); 190 add_includes({}, /* skip= */ default_includes); 191 std::string chain_id_final = GetChainTypeString(); 192 if (chain_id_final != chain_id) { 193 // Also warn about recursive includeconf for the chain that was specified in one of the includeconfs 194 add_includes(chain_id_final); 195 } 196 for (const std::string& conf_file_name : conf_file_names) { 197 tfm::format(std::cerr, "warning: -includeconf cannot be used from included files; ignoring -includeconf=%s\n", conf_file_name); 198 } 199 } 200 } 201 202 // If datadir is changed in .conf file: 203 ClearPathCache(); 204 if (!CheckDataDirOption(*this)) { 205 error = strprintf("specified data directory \"%s\" does not exist.", GetArg("-datadir", "")); 206 return false; 207 } 208 return true; 209 } 210 211 fs::path AbsPathForConfigVal(const ArgsManager& args, const fs::path& path, bool net_specific) 212 { 213 if (path.is_absolute()) { 214 return path; 215 } 216 return fsbridge::AbsPathJoin(net_specific ? args.GetDataDirNet() : args.GetDataDirBase(), path); 217 }