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_