options.h

Go to the documentation of this file.

#ifndef CVMFS_OPTIONS_H_
#define CVMFS_OPTIONS_H_

#include <stdint.h>

#include <cassert>
#include <map>
#include <string>
#include <vector>

#ifdef CVMFS_NAMESPACE_GUARD
namespace CVMFS_NAMESPACE_GUARD {
#endif

class OptionsTemplateManager {
 public:
  void SetTemplate(std::string name, std::string val);
  std::string GetTemplate(std::string name);
  bool HasTemplate(std::string name);
  bool ParseString(std::string *input);

 private:
  std::map<std::string, std::string> templates_;
};

class DefaultOptionsTemplateManager : public OptionsTemplateManager {
 public:
  explicit DefaultOptionsTemplateManager(std::string fqrn);

 private:
  static const char *kTemplateIdentFqrn;
  static const char *kTemplateIdentOrg;
};

class OptionsManager {
 public:
  explicit OptionsManager(OptionsTemplateManager *opt_templ_mgr_param)
      : taint_environment_(true) {
    if (opt_templ_mgr_param != NULL) {
      opt_templ_mgr_ = opt_templ_mgr_param;
    } else {
      opt_templ_mgr_ = new OptionsTemplateManager();
    }
  }

  OptionsManager(const OptionsManager &opt_mgr) {
    config_ = opt_mgr.config_;
    protected_parameters_ = opt_mgr.protected_parameters_;
    templatable_values_ = opt_mgr.templatable_values_;
    taint_environment_ = opt_mgr.taint_environment_;

    opt_templ_mgr_ = new OptionsTemplateManager(*(opt_mgr.opt_templ_mgr_));
  }

  virtual ~OptionsManager() { delete opt_templ_mgr_; }

  void SwitchTemplateManager(OptionsTemplateManager *opt_templ_mgr_param);

  virtual void ParsePath(const std::string &config_file,
                         const bool external) = 0;

  void ParseDefault(const std::string &fqrn);

  void ClearConfig();

  bool IsDefined(const std::string &key);

  bool GetValue(const std::string &key, std::string *value) const;

  std::string GetValueOrDie(const std::string &key);

  bool GetSource(const std::string &key, std::string *value);

  bool IsOn(const std::string &param_value) const;

  bool IsOff(const std::string &param_value) const;

  std::vector<std::string> GetAllKeys();

  std::vector<std::string> GetEnvironmentSubset(const std::string &key_prefix,
                                                bool strip_prefix);

  std::string Dump();

  bool HasConfigRepository(const std::string &fqrn, std::string *config_path);

  void ProtectParameter(const std::string &param);

  void SetValue(const std::string &key, const std::string &value);

  void SetValueFromTalk(const std::string &key, const std::string &value);

  void UnsetValue(const std::string &key);

  void set_taint_environment(bool value) { taint_environment_ = value; }

 protected:
  struct ConfigValue {
    std::string value;
    std::string source;
  };

  std::string TrimParameter(const std::string &parameter);
  std::string SanitizeParameterAssignment(std::string *line,
                                          std::vector<std::string> *tokens);
  void PopulateParameter(const std::string &param, const ConfigValue val);
  void ParseValue(const std::string param, ConfigValue *val);
  void UpdateEnvironment(const std::string &param, ConfigValue val);
  std::map<std::string, ConfigValue> config_;
  std::map<std::string, std::string> protected_parameters_;
  std::map<std::string, std::string> templatable_values_;

  OptionsTemplateManager *opt_templ_mgr_;
  bool taint_environment_;

 private:
  // NOLINTNEXTLINE(bugprone-unhandled-self-assignment,cert-oop54-cpp)
  OptionsManager &operator=(const OptionsManager & /* other */) {
    assert(false);
  }
};  // class OptionManager


class SimpleOptionsParser : public OptionsManager {
 public:
  explicit SimpleOptionsParser(
      OptionsTemplateManager *opt_templ_mgr_param = NULL)
      : OptionsManager(opt_templ_mgr_param) { }
  virtual void ParsePath(const std::string &config_file,
                         const bool external __attribute__((unused))) {
    (void)TryParsePath(config_file);
  }
  // Libcvmfs returns success or failure, the fuse module fails silently
  bool TryParsePath(const std::string &config_file);
};  // class SimpleOptionsManager


class BashOptionsManager : public OptionsManager {
 public:
  explicit BashOptionsManager(
      OptionsTemplateManager *opt_templ_mgr_param = NULL)
      : OptionsManager(opt_templ_mgr_param) { }
  void ParsePath(const std::string &config_file, const bool external);
};  // class BashOptionsManager


#ifdef CVMFS_NAMESPACE_GUARD
}  // namespace CVMFS_NAMESPACE_GUARD
#endif

#endif  // CVMFS_OPTIONS_H_