system.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_UTIL_SYSTEM_H
#define BITCOIN_UTIL_SYSTEM_H
 
#if defined(HAVE_CONFIG_H)
#include <config/bitcoin-config.h>
#endif
 
#include <compat.h>
#include <compat/assumptions.h>
#include <fs.h>
#include <logging.h>
#include <sync.h>
#include <tinyformat.h>
#include <util/settings.h>
#include <util/time.h>
 
#include <any>
#include <cstdint>
#include <exception>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
// Application startup time (used for uptime calculation)
int64_t GetStartupTime();
 
extern const char *const BITCOIN_CONF_FILENAME;
extern const char *const BITCOIN_SETTINGS_FILENAME;
 
void SetupEnvironment();
bool SetupNetworking();
 
template <typename... Args> bool error(const char *fmt, const Args &...args) {
    LogPrintf("ERROR: %s\n", tfm::format(fmt, args...));
    return false;
}
 
void PrintExceptionContinue(const std::exception *pex, const char *pszThread);
bool FileCommit(FILE *file);
bool TruncateFile(FILE *file, unsigned int length);
int RaiseFileDescriptorLimit(int nMinFD);
void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length);
[[nodiscard]] bool RenameOver(fs::path src, fs::path dest);
bool LockDirectory(const fs::path &directory, const std::string lockfile_name,
                   bool probe_only = false);
void UnlockDirectory(const fs::path &directory,
                     const std::string &lockfile_name);
bool DirIsWritable(const fs::path &directory);
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes = 0);
 
std::streampos
GetFileSize(const char *path,
            std::streamsize max = std::numeric_limits<std::streamsize>::max());
 
void ReleaseDirectoryLocks();
 
bool TryCreateDirectories(const fs::path &p);
fs::path GetDefaultDataDir();
// Return true if -datadir option points to a valid directory or is not
// specified.
bool CheckDataDirOption();
fs::path GetConfigFile(const std::string &confPath);
#ifdef WIN32
fs::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
#endif
#ifndef WIN32
std::string ShellEscape(const std::string &arg);
#endif
#if defined(HAVE_SYSTEM)
void runCommand(const std::string &strCommand);
#endif
 
[[nodiscard]] bool ParseKeyValue(std::string &key, std::string &val);
 
fs::path AbsPathForConfigVal(const fs::path &path, bool net_specific = true);
 
inline bool IsSwitchChar(char c) {
#ifdef WIN32
    return c == '-' || c == '/';
#else
    return c == '-';
#endif
}
 
enum class OptionsCategory {
    OPTIONS,
    CONNECTION,
    WALLET,
    WALLET_DEBUG_TEST,
    ZMQ,
    DEBUG_TEST,
    CHAINPARAMS,
    NODE_RELAY,
    BLOCK_CREATION,
    RPC,
    GUI,
    COMMANDS,
    REGISTER_COMMANDS,
    AVALANCHE,
 
    // Always the last option to avoid printing these in the help
    HIDDEN,
 
    // Hide Chronik for now
    CHRONIK,
};
 
struct SectionInfo {
    std::string m_name;
    std::string m_file;
    int m_line;
};
 
class ArgsManager {
public:
    enum Flags {
        // Boolean options can accept negation syntax -noOPTION or -noOPTION=1
        ALLOW_BOOL = 0x01,
        ALLOW_INT = 0x02,
        ALLOW_STRING = 0x04,
        ALLOW_ANY = ALLOW_BOOL | ALLOW_INT | ALLOW_STRING,
        DEBUG_ONLY = 0x100,
        /* Some options would cause cross-contamination if values for
         * mainnet were used while running on regtest/testnet (or vice-versa).
         * Setting them as NETWORK_ONLY ensures that sharing a config file
         * between mainnet and regtest/testnet won't cause problems due to these
         * parameters by accident. */
        NETWORK_ONLY = 0x200,
        // This argument's value is sensitive (such as a password).
        SENSITIVE = 0x400,
    };
 
protected:
    struct Arg {
        std::string m_help_param;
        std::string m_help_text;
        unsigned int m_flags;
    };
 
    mutable RecursiveMutex cs_args;
    util::Settings m_settings GUARDED_BY(cs_args);
    std::string m_network GUARDED_BY(cs_args);
    std::set<std::string> m_network_only_args GUARDED_BY(cs_args);
    std::map<OptionsCategory, std::map<std::string, Arg>>
        m_available_args GUARDED_BY(cs_args);
    std::list<SectionInfo> m_config_sections GUARDED_BY(cs_args);
    mutable fs::path m_cached_blocks_path GUARDED_BY(cs_args);
    mutable fs::path m_cached_datadir_path GUARDED_BY(cs_args);
    mutable fs::path m_cached_network_datadir_path GUARDED_BY(cs_args);
 
    [[nodiscard]] bool ReadConfigStream(std::istream &stream,
                                        const std::string &filepath,
                                        std::string &error,
                                        bool ignore_invalid_keys = false);
 
    bool UseDefaultSection(const std::string &arg) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_args);
 
    util::SettingsValue GetSetting(const std::string &arg) const;
 
    std::vector<util::SettingsValue>
    GetSettingsList(const std::string &arg) const;
 
public:
    ArgsManager();
    ~ArgsManager();
 
    void SelectConfigNetwork(const std::string &network);
 
    [[nodiscard]] bool ParseParameters(int argc, const char *const argv[],
                                       std::string &error);
    [[nodiscard]] bool ReadConfigFiles(std::string &error,
                                       bool ignore_invalid_keys = false);
 
    const std::set<std::string> GetUnsuitableSectionOnlyArgs() const;
 
    const std::list<SectionInfo> GetUnrecognizedSections() const;
 
    const fs::path &GetBlocksDirPath() const;
 
    const fs::path &GetDataDirBase() const { return GetDataDir(false); }
 
    const fs::path &GetDataDirNet() const { return GetDataDir(true); }
 
    void ClearPathCache();
 
    std::vector<std::string> GetArgs(const std::string &strArg) const;
 
    bool IsArgSet(const std::string &strArg) const;
 
    bool IsArgNegated(const std::string &strArg) const;
 
    std::string GetArg(const std::string &strArg,
                       const std::string &strDefault) const;
 
    int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const;
 
    bool GetBoolArg(const std::string &strArg, bool fDefault) const;
 
    bool SoftSetArg(const std::string &strArg, const std::string &strValue);
 
    bool SoftSetBoolArg(const std::string &strArg, bool fValue);
 
    // Forces an arg setting. Called by SoftSetArg() if the arg hasn't already
    // been set. Also called directly in testing.
    void ForceSetArg(const std::string &strArg, const std::string &strValue);
 
    // Forces a multi arg setting, used only in testing
    void ForceSetMultiArg(const std::string &strArg,
                          const std::vector<std::string> &values);
 
    std::string GetChainName() const;
 
    void AddArg(const std::string &name, const std::string &help,
                unsigned int flags, const OptionsCategory &cat);
 
    void ClearForcedArg(const std::string &strArg);
 
    void AddHiddenArgs(const std::vector<std::string> &args);
 
    void ClearArgs() {
        LOCK(cs_args);
        m_available_args.clear();
        m_network_only_args.clear();
    }
 
    std::string GetHelpMessage() const;
 
    std::optional<unsigned int> GetArgFlags(const std::string &name) const;
 
    bool InitSettings(std::string &error);
 
    bool GetSettingsPath(fs::path *filepath = nullptr, bool temp = false) const;
 
    bool ReadSettingsFile(std::vector<std::string> *errors = nullptr);
 
    bool WriteSettingsFile(std::vector<std::string> *errors = nullptr) const;
 
    template <typename Fn> void LockSettings(Fn &&fn) {
        LOCK(cs_args);
        fn(m_settings);
    }
 
    void LogArgs() const;
 
private:
    const fs::path &GetDataDir(bool net_specific) const;
 
    // Helper function for LogArgs().
    void
    logArgsPrefix(const std::string &prefix, const std::string &section,
                  const std::map<std::string, std::vector<util::SettingsValue>>
                      &args) const;
};
 
extern ArgsManager gArgs;
 
bool HelpRequested(const ArgsManager &args);
 
void SetupHelpOptions(ArgsManager &args);
 
std::string HelpMessageGroup(const std::string &message);
 
std::string HelpMessageOpt(const std::string &option,
                           const std::string &message);
 
int GetNumCores();
 
std::string CopyrightHolders(const std::string &strPrefix);
 
void ScheduleBatchPriority();
 
namespace util {
 
template <typename Tdst, typename Tsrc>
inline void insert(Tdst &dst, const Tsrc &src) {
    dst.insert(dst.begin(), src.begin(), src.end());
}
template <typename TsetT, typename Tsrc>
inline void insert(std::set<TsetT> &dst, const Tsrc &src) {
    dst.insert(src.begin(), src.end());
}
 
template <typename T> T *AnyPtr(const std::any &any) noexcept {
    T *const *ptr = std::any_cast<T *>(&any);
    return ptr ? *ptr : nullptr;
}
 
#ifdef WIN32
class WinCmdLineArgs {
public:
    WinCmdLineArgs();
    ~WinCmdLineArgs();
    std::pair<int, char **> get();
 
private:
    int argc;
    char **argv;
    std::vector<std::string> args;
};
#endif
 
} // namespace util
 
#endif // BITCOIN_UTIL_SYSTEM_H