LCOV - code coverage report
Current view: top level - src/common - args.h (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 0 18 0.0 %
Date: 2024-01-03 14:57:27 Functions: 0 20 0.0 %
Branches: 0 12 0.0 %

           Branch data     Line data    Source code
       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                 :            : #ifndef BITCOIN_COMMON_ARGS_H
       6                 :            : #define BITCOIN_COMMON_ARGS_H
       7                 :            : 
       8                 :            : #include <common/settings.h>
       9                 :            : #include <compat/compat.h>
      10                 :            : #include <sync.h>
      11                 :            : #include <util/chaintype.h>
      12                 :            : #include <util/fs.h>
      13                 :            : 
      14                 :            : #include <iosfwd>
      15                 :            : #include <list>
      16                 :            : #include <map>
      17                 :            : #include <optional>
      18                 :            : #include <set>
      19                 :            : #include <stdint.h>
      20                 :            : #include <string>
      21                 :            : #include <variant>
      22                 :            : #include <vector>
      23                 :            : 
      24                 :            : class ArgsManager;
      25                 :            : 
      26                 :            : extern const char * const BITCOIN_CONF_FILENAME;
      27                 :            : extern const char * const BITCOIN_SETTINGS_FILENAME;
      28                 :            : 
      29                 :            : // Return true if -datadir option points to a valid directory or is not specified.
      30                 :            : bool CheckDataDirOption(const ArgsManager& args);
      31                 :            : 
      32                 :            : /**
      33                 :            :  * Most paths passed as configuration arguments are treated as relative to
      34                 :            :  * the datadir if they are not absolute.
      35                 :            :  *
      36                 :            :  * @param args Parsed arguments and settings.
      37                 :            :  * @param path The path to be conditionally prefixed with datadir.
      38                 :            :  * @param net_specific Use network specific datadir variant
      39                 :            :  * @return The normalized path.
      40                 :            :  */
      41                 :            : fs::path AbsPathForConfigVal(const ArgsManager& args, const fs::path& path, bool net_specific = true);
      42                 :            : 
      43                 :          0 : inline bool IsSwitchChar(char c)
      44                 :            : {
      45                 :            : #ifdef WIN32
      46                 :            :     return c == '-' || c == '/';
      47                 :            : #else
      48                 :          0 :     return c == '-';
      49                 :            : #endif
      50                 :            : }
      51                 :            : 
      52                 :            : enum class OptionsCategory {
      53                 :            :     OPTIONS,
      54                 :            :     CONNECTION,
      55                 :            :     WALLET,
      56                 :            :     WALLET_DEBUG_TEST,
      57                 :            :     ZMQ,
      58                 :            :     DEBUG_TEST,
      59                 :            :     CHAINPARAMS,
      60                 :            :     NODE_RELAY,
      61                 :            :     BLOCK_CREATION,
      62                 :            :     RPC,
      63                 :            :     GUI,
      64                 :            :     COMMANDS,
      65                 :            :     REGISTER_COMMANDS,
      66                 :            : 
      67                 :            :     HIDDEN // Always the last option to avoid printing these in the help
      68                 :            : };
      69                 :            : 
      70                 :          0 : struct KeyInfo {
      71                 :            :     std::string name;
      72                 :            :     std::string section;
      73                 :          0 :     bool negated{false};
      74                 :            : };
      75                 :            : 
      76                 :            : KeyInfo InterpretKey(std::string key);
      77                 :            : 
      78                 :            : std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, const std::string* value,
      79                 :            :                                                          unsigned int flags, std::string& error);
      80                 :            : 
      81                 :          0 : struct SectionInfo {
      82                 :            :     std::string m_name;
      83                 :            :     std::string m_file;
      84                 :            :     int m_line;
      85                 :            : };
      86                 :            : 
      87                 :            : std::string SettingToString(const common::SettingsValue&, const std::string&);
      88                 :            : std::optional<std::string> SettingToString(const common::SettingsValue&);
      89                 :            : 
      90                 :            : int64_t SettingToInt(const common::SettingsValue&, int64_t);
      91                 :            : std::optional<int64_t> SettingToInt(const common::SettingsValue&);
      92                 :            : 
      93                 :            : bool SettingToBool(const common::SettingsValue&, bool);
      94                 :            : std::optional<bool> SettingToBool(const common::SettingsValue&);
      95                 :            : 
      96                 :            : class ArgsManager
      97                 :            : {
      98                 :            : public:
      99                 :            :     /**
     100                 :            :      * Flags controlling how config and command line arguments are validated and
     101                 :            :      * interpreted.
     102                 :            :      */
     103                 :            :     enum Flags : uint32_t {
     104                 :            :         ALLOW_ANY = 0x01,         //!< disable validation
     105                 :            :         // ALLOW_BOOL = 0x02,     //!< unimplemented, draft implementation in #16545
     106                 :            :         // ALLOW_INT = 0x04,      //!< unimplemented, draft implementation in #16545
     107                 :            :         // ALLOW_STRING = 0x08,   //!< unimplemented, draft implementation in #16545
     108                 :            :         // ALLOW_LIST = 0x10,     //!< unimplemented, draft implementation in #16545
     109                 :            :         DISALLOW_NEGATION = 0x20, //!< disallow -nofoo syntax
     110                 :            :         DISALLOW_ELISION = 0x40,  //!< disallow -foo syntax that doesn't assign any value
     111                 :            : 
     112                 :            :         DEBUG_ONLY = 0x100,
     113                 :            :         /* Some options would cause cross-contamination if values for
     114                 :            :          * mainnet were used while running on regtest/testnet (or vice-versa).
     115                 :            :          * Setting them as NETWORK_ONLY ensures that sharing a config file
     116                 :            :          * between mainnet and regtest/testnet won't cause problems due to these
     117                 :            :          * parameters by accident. */
     118                 :            :         NETWORK_ONLY = 0x200,
     119                 :            :         // This argument's value is sensitive (such as a password).
     120                 :            :         SENSITIVE = 0x400,
     121                 :            :         COMMAND = 0x800,
     122                 :            :     };
     123                 :            : 
     124                 :            : protected:
     125                 :          0 :     struct Arg
     126                 :            :     {
     127                 :            :         std::string m_help_param;
     128                 :            :         std::string m_help_text;
     129                 :            :         unsigned int m_flags;
     130                 :            :     };
     131                 :            : 
     132                 :            :     mutable RecursiveMutex cs_args;
     133                 :            :     common::Settings m_settings GUARDED_BY(cs_args);
     134                 :            :     std::vector<std::string> m_command GUARDED_BY(cs_args);
     135                 :            :     std::string m_network GUARDED_BY(cs_args);
     136                 :            :     std::set<std::string> m_network_only_args GUARDED_BY(cs_args);
     137                 :            :     std::map<OptionsCategory, std::map<std::string, Arg>> m_available_args GUARDED_BY(cs_args);
     138                 :            :     bool m_accept_any_command GUARDED_BY(cs_args){true};
     139                 :            :     std::list<SectionInfo> m_config_sections GUARDED_BY(cs_args);
     140                 :            :     std::optional<fs::path> m_config_path GUARDED_BY(cs_args);
     141                 :            :     mutable fs::path m_cached_blocks_path GUARDED_BY(cs_args);
     142                 :            :     mutable fs::path m_cached_datadir_path GUARDED_BY(cs_args);
     143                 :            :     mutable fs::path m_cached_network_datadir_path GUARDED_BY(cs_args);
     144                 :            : 
     145                 :            :     [[nodiscard]] bool ReadConfigStream(std::istream& stream, const std::string& filepath, std::string& error, bool ignore_invalid_keys = false);
     146                 :            : 
     147                 :            :     /**
     148                 :            :      * Returns true if settings values from the default section should be used,
     149                 :            :      * depending on the current network and whether the setting is
     150                 :            :      * network-specific.
     151                 :            :      */
     152                 :            :     bool UseDefaultSection(const std::string& arg) const EXCLUSIVE_LOCKS_REQUIRED(cs_args);
     153                 :            : 
     154                 :            :  public:
     155                 :            :     /**
     156                 :            :      * Get setting value.
     157                 :            :      *
     158                 :            :      * Result will be null if setting was unset, true if "-setting" argument was passed
     159                 :            :      * false if "-nosetting" argument was passed, and a string if a "-setting=value"
     160                 :            :      * argument was passed.
     161                 :            :      */
     162                 :            :     common::SettingsValue GetSetting(const std::string& arg) const;
     163                 :            : 
     164                 :            :     /**
     165                 :            :      * Get list of setting values.
     166                 :            :      */
     167                 :            :     std::vector<common::SettingsValue> GetSettingsList(const std::string& arg) const;
     168                 :            : 
     169                 :            :     ArgsManager();
     170                 :            :     ~ArgsManager();
     171                 :            : 
     172                 :            :     /**
     173                 :            :      * Select the network in use
     174                 :            :      */
     175                 :            :     void SelectConfigNetwork(const std::string& network);
     176                 :            : 
     177                 :            :     [[nodiscard]] bool ParseParameters(int argc, const char* const argv[], std::string& error);
     178                 :            : 
     179                 :            :     /**
     180                 :            :      * Return config file path (read-only)
     181                 :            :      */
     182                 :            :     fs::path GetConfigFilePath() const;
     183                 :            :     void SetConfigFilePath(fs::path);
     184                 :            :     [[nodiscard]] bool ReadConfigFiles(std::string& error, bool ignore_invalid_keys = false);
     185                 :            : 
     186                 :            :     /**
     187                 :            :      * Log warnings for options in m_section_only_args when
     188                 :            :      * they are specified in the default section but not overridden
     189                 :            :      * on the command line or in a network-specific section in the
     190                 :            :      * config file.
     191                 :            :      */
     192                 :            :     std::set<std::string> GetUnsuitableSectionOnlyArgs() const;
     193                 :            : 
     194                 :            :     /**
     195                 :            :      * Log warnings for unrecognized section names in the config file.
     196                 :            :      */
     197                 :            :     std::list<SectionInfo> GetUnrecognizedSections() const;
     198                 :            : 
     199                 :          0 :     struct Command {
     200                 :            :         /** The command (if one has been registered with AddCommand), or empty */
     201                 :            :         std::string command;
     202                 :            :         /**
     203                 :            :          * If command is non-empty: Any args that followed it
     204                 :            :          * If command is empty: The unregistered command and any args that followed it
     205                 :            :          */
     206                 :            :         std::vector<std::string> args;
     207                 :            :     };
     208                 :            :     /**
     209                 :            :      * Get the command and command args (returns std::nullopt if no command provided)
     210                 :            :      */
     211                 :            :     std::optional<const Command> GetCommand() const;
     212                 :            : 
     213                 :            :     /**
     214                 :            :      * Get blocks directory path
     215                 :            :      *
     216                 :            :      * @return Blocks path which is network specific
     217                 :            :      */
     218                 :            :     fs::path GetBlocksDirPath() const;
     219                 :            : 
     220                 :            :     /**
     221                 :            :      * Get data directory path
     222                 :            :      *
     223                 :            :      * @return Absolute path on success, otherwise an empty path when a non-directory path would be returned
     224                 :            :      */
     225                 :          0 :     fs::path GetDataDirBase() const { return GetDataDir(false); }
     226                 :            : 
     227                 :            :     /**
     228                 :            :      * Get data directory path with appended network identifier
     229                 :            :      *
     230                 :            :      * @return Absolute path on success, otherwise an empty path when a non-directory path would be returned
     231                 :            :      */
     232                 :          0 :     fs::path GetDataDirNet() const { return GetDataDir(true); }
     233                 :            : 
     234                 :            :     /**
     235                 :            :      * Clear cached directory paths
     236                 :            :      */
     237                 :            :     void ClearPathCache();
     238                 :            : 
     239                 :            :     /**
     240                 :            :      * Return a vector of strings of the given argument
     241                 :            :      *
     242                 :            :      * @param strArg Argument to get (e.g. "-foo")
     243                 :            :      * @return command-line arguments
     244                 :            :      */
     245                 :            :     std::vector<std::string> GetArgs(const std::string& strArg) const;
     246                 :            : 
     247                 :            :     /**
     248                 :            :      * Return true if the given argument has been manually set
     249                 :            :      *
     250                 :            :      * @param strArg Argument to get (e.g. "-foo")
     251                 :            :      * @return true if the argument has been set
     252                 :            :      */
     253                 :            :     bool IsArgSet(const std::string& strArg) const;
     254                 :            : 
     255                 :            :     /**
     256                 :            :      * Return true if the argument was originally passed as a negated option,
     257                 :            :      * i.e. -nofoo.
     258                 :            :      *
     259                 :            :      * @param strArg Argument to get (e.g. "-foo")
     260                 :            :      * @return true if the argument was passed negated
     261                 :            :      */
     262                 :            :     bool IsArgNegated(const std::string& strArg) const;
     263                 :            : 
     264                 :            :     /**
     265                 :            :      * Return string argument or default value
     266                 :            :      *
     267                 :            :      * @param strArg Argument to get (e.g. "-foo")
     268                 :            :      * @param strDefault (e.g. "1")
     269                 :            :      * @return command-line argument or default value
     270                 :            :      */
     271                 :            :     std::string GetArg(const std::string& strArg, const std::string& strDefault) const;
     272                 :            :     std::optional<std::string> GetArg(const std::string& strArg) const;
     273                 :            : 
     274                 :            :     /**
     275                 :            :      * Return path argument or default value
     276                 :            :      *
     277                 :            :      * @param arg Argument to get a path from (e.g., "-datadir", "-blocksdir" or "-walletdir")
     278                 :            :      * @param default_value Optional default value to return instead of the empty path.
     279                 :            :      * @return normalized path if argument is set, with redundant "." and ".."
     280                 :            :      * path components and trailing separators removed (see patharg unit test
     281                 :            :      * for examples or implementation for details). If argument is empty or not
     282                 :            :      * set, default_value is returned unchanged.
     283                 :            :      */
     284                 :            :     fs::path GetPathArg(std::string arg, const fs::path& default_value = {}) const;
     285                 :            : 
     286                 :            :     /**
     287                 :            :      * Return integer argument or default value
     288                 :            :      *
     289                 :            :      * @param strArg Argument to get (e.g. "-foo")
     290                 :            :      * @param nDefault (e.g. 1)
     291                 :            :      * @return command-line argument (0 if invalid number) or default value
     292                 :            :      */
     293                 :            :     int64_t GetIntArg(const std::string& strArg, int64_t nDefault) const;
     294                 :            :     std::optional<int64_t> GetIntArg(const std::string& strArg) const;
     295                 :            : 
     296                 :            :     /**
     297                 :            :      * Return boolean argument or default value
     298                 :            :      *
     299                 :            :      * @param strArg Argument to get (e.g. "-foo")
     300                 :            :      * @param fDefault (true or false)
     301                 :            :      * @return command-line argument or default value
     302                 :            :      */
     303                 :            :     bool GetBoolArg(const std::string& strArg, bool fDefault) const;
     304                 :            :     std::optional<bool> GetBoolArg(const std::string& strArg) const;
     305                 :            : 
     306                 :            :     /**
     307                 :            :      * Set an argument if it doesn't already have a value
     308                 :            :      *
     309                 :            :      * @param strArg Argument to set (e.g. "-foo")
     310                 :            :      * @param strValue Value (e.g. "1")
     311                 :            :      * @return true if argument gets set, false if it already had a value
     312                 :            :      */
     313                 :            :     bool SoftSetArg(const std::string& strArg, const std::string& strValue);
     314                 :            : 
     315                 :            :     /**
     316                 :            :      * Set a boolean argument if it doesn't already have a value
     317                 :            :      *
     318                 :            :      * @param strArg Argument to set (e.g. "-foo")
     319                 :            :      * @param fValue Value (e.g. false)
     320                 :            :      * @return true if argument gets set, false if it already had a value
     321                 :            :      */
     322                 :            :     bool SoftSetBoolArg(const std::string& strArg, bool fValue);
     323                 :            : 
     324                 :            :     // Forces an arg setting. Called by SoftSetArg() if the arg hasn't already
     325                 :            :     // been set. Also called directly in testing.
     326                 :            :     void ForceSetArg(const std::string& strArg, const std::string& strValue);
     327                 :            : 
     328                 :            :     /**
     329                 :            :      * Returns the appropriate chain type from the program arguments.
     330                 :            :      * @return ChainType::MAIN by default; raises runtime error if an invalid
     331                 :            :      * combination, or unknown chain is given.
     332                 :            :      */
     333                 :            :     ChainType GetChainType() const;
     334                 :            : 
     335                 :            :     /**
     336                 :            :      * Returns the appropriate chain type string from the program arguments.
     337                 :            :      * @return ChainType::MAIN string by default; raises runtime error if an
     338                 :            :      * invalid combination is given.
     339                 :            :      */
     340                 :            :     std::string GetChainTypeString() const;
     341                 :            : 
     342                 :            :     /**
     343                 :            :      * Add argument
     344                 :            :      */
     345                 :            :     void AddArg(const std::string& name, const std::string& help, unsigned int flags, const OptionsCategory& cat);
     346                 :            : 
     347                 :            :     /**
     348                 :            :      * Add subcommand
     349                 :            :      */
     350                 :            :     void AddCommand(const std::string& cmd, const std::string& help);
     351                 :            : 
     352                 :            :     /**
     353                 :            :      * Add many hidden arguments
     354                 :            :      */
     355                 :            :     void AddHiddenArgs(const std::vector<std::string>& args);
     356                 :            : 
     357                 :            :     /**
     358                 :            :      * Clear available arguments
     359                 :            :      */
     360                 :          0 :     void ClearArgs() {
     361                 :          0 :         LOCK(cs_args);
     362                 :          0 :         m_available_args.clear();
     363                 :          0 :         m_network_only_args.clear();
     364                 :          0 :     }
     365                 :            : 
     366                 :            :     /**
     367                 :            :      * Get the help string
     368                 :            :      */
     369                 :            :     std::string GetHelpMessage() const;
     370                 :            : 
     371                 :            :     /**
     372                 :            :      * Return Flags for known arg.
     373                 :            :      * Return nullopt for unknown arg.
     374                 :            :      */
     375                 :            :     std::optional<unsigned int> GetArgFlags(const std::string& name) const;
     376                 :            : 
     377                 :            :     /**
     378                 :            :      * Get settings file path, or return false if read-write settings were
     379                 :            :      * disabled with -nosettings.
     380                 :            :      */
     381                 :            :     bool GetSettingsPath(fs::path* filepath = nullptr, bool temp = false, bool backup = false) const;
     382                 :            : 
     383                 :            :     /**
     384                 :            :      * Read settings file. Push errors to vector, or log them if null.
     385                 :            :      */
     386                 :            :     bool ReadSettingsFile(std::vector<std::string>* errors = nullptr);
     387                 :            : 
     388                 :            :     /**
     389                 :            :      * Write settings file or backup settings file. Push errors to vector, or
     390                 :            :      * log them if null.
     391                 :            :      */
     392                 :            :     bool WriteSettingsFile(std::vector<std::string>* errors = nullptr, bool backup = false) const;
     393                 :            : 
     394                 :            :     /**
     395                 :            :      * Get current setting from config file or read/write settings file,
     396                 :            :      * ignoring nonpersistent command line or forced settings values.
     397                 :            :      */
     398                 :            :     common::SettingsValue GetPersistentSetting(const std::string& name) const;
     399                 :            : 
     400                 :            :     /**
     401                 :            :      * Access settings with lock held.
     402                 :            :      */
     403                 :            :     template <typename Fn>
     404                 :          0 :     void LockSettings(Fn&& fn)
     405                 :            :     {
     406                 :          0 :         LOCK(cs_args);
     407 [ #  # ][ #  # ]:          0 :         fn(m_settings);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     408                 :          0 :     }
     409                 :            : 
     410                 :            :     /**
     411                 :            :      * Log the config file options and the command line arguments,
     412                 :            :      * useful for troubleshooting.
     413                 :            :      */
     414                 :            :     void LogArgs() const;
     415                 :            : 
     416                 :            : private:
     417                 :            :     /**
     418                 :            :      * Get data directory path
     419                 :            :      *
     420                 :            :      * @param net_specific Append network identifier to the returned path
     421                 :            :      * @return Absolute path on success, otherwise an empty path when a non-directory path would be returned
     422                 :            :      */
     423                 :            :     fs::path GetDataDir(bool net_specific) const;
     424                 :            : 
     425                 :            :     /**
     426                 :            :      * Return -regtest/-signet/-testnet/-chain= setting as a ChainType enum if a
     427                 :            :      * recognized chain type was set, or as a string if an unrecognized chain
     428                 :            :      * name was set. Raise an exception if an invalid combination of flags was
     429                 :            :      * provided.
     430                 :            :      */
     431                 :            :     std::variant<ChainType, std::string> GetChainArg() const;
     432                 :            : 
     433                 :            :     // Helper function for LogArgs().
     434                 :            :     void logArgsPrefix(
     435                 :            :         const std::string& prefix,
     436                 :            :         const std::string& section,
     437                 :            :         const std::map<std::string, std::vector<common::SettingsValue>>& args) const;
     438                 :            : };
     439                 :            : 
     440                 :            : extern ArgsManager gArgs;
     441                 :            : 
     442                 :            : /**
     443                 :            :  * @return true if help has been requested via a command-line arg
     444                 :            :  */
     445                 :            : bool HelpRequested(const ArgsManager& args);
     446                 :            : 
     447                 :            : /** Add help options to the args manager */
     448                 :            : void SetupHelpOptions(ArgsManager& args);
     449                 :            : 
     450                 :            : /**
     451                 :            :  * Format a string to be used as group of options in help messages
     452                 :            :  *
     453                 :            :  * @param message Group name (e.g. "RPC server options:")
     454                 :            :  * @return the formatted string
     455                 :            :  */
     456                 :            : std::string HelpMessageGroup(const std::string& message);
     457                 :            : 
     458                 :            : /**
     459                 :            :  * Format a string to be used as option description in help messages
     460                 :            :  *
     461                 :            :  * @param option Option message (e.g. "-rpcuser=<user>")
     462                 :            :  * @param message Option description (e.g. "Username for JSON-RPC connections")
     463                 :            :  * @return the formatted string
     464                 :            :  */
     465                 :            : std::string HelpMessageOpt(const std::string& option, const std::string& message);
     466                 :            : 
     467                 :            : namespace common {
     468                 :            : #ifdef WIN32
     469                 :            : class WinCmdLineArgs
     470                 :            : {
     471                 :            : public:
     472                 :            :     WinCmdLineArgs();
     473                 :            :     ~WinCmdLineArgs();
     474                 :            :     std::pair<int, char**> get();
     475                 :            : 
     476                 :            : private:
     477                 :            :     int argc;
     478                 :            :     char** argv;
     479                 :            :     std::vector<std::string> args;
     480                 :            : };
     481                 :            : #endif
     482                 :            : } // namespace common
     483                 :            : 
     484                 :            : #endif // BITCOIN_COMMON_ARGS_H

Generated by: LCOV version 1.14