config.cc

#include <fcntl.h>
#include <unistd.h>
#include <iomanip>
#include <sstream>

#include "bootstrap/bootstrap.h"
#include "libaktualizr/config.h"
#include "utilities/config_utils.h"
#include "utilities/exceptions.h"
#include "utilities/utils.h"

std::ostream& operator<<(std::ostream& os, ProvisionMode mode) {
  std::string mode_s;
  switch (mode) {
    case ProvisionMode::kSharedCred:
      mode_s = "SharedCred";
      break;
    case ProvisionMode::kDeviceCred:
      mode_s = "DeviceCred";
      break;
    case ProvisionMode::kSharedCredReuse:
      mode_s = "SharedCredReuse";
      break;
    default:
      mode_s = "Default";
      break;
  }
  os << '"' << mode_s << '"';
  return os;
}

template <>
inline void CopyFromConfig(ProvisionMode& dest, const std::string& option_name, const boost::property_tree::ptree& pt) {
  boost::optional<std::string> value = pt.get_optional<std::string>(option_name);
  if (value.is_initialized()) {
    std::string provision_mode{StripQuotesFromStrings(value.get())};
    if (provision_mode == "SharedCred") {
      dest = ProvisionMode::kSharedCred;
    } else if (provision_mode == "DeviceCred") {
      dest = ProvisionMode::kDeviceCred;
    } else if (provision_mode == "SharedCredReuse") {
      dest = ProvisionMode::kSharedCredReuse;
    } else {
      dest = ProvisionMode::kDefault;
    }
  }
}

void TlsConfig::updateFromPropertyTree(const boost::property_tree::ptree& pt) {
  CopyFromConfig(server, "server", pt);
  CopyFromConfig(server_url_path, "server_url_path", pt);
  CopyFromConfig(ca_source, "ca_source", pt);
  CopyFromConfig(cert_source, "cert_source", pt);
  CopyFromConfig(pkey_source, "pkey_source", pt);
}

void TlsConfig::writeToStream(std::ostream& out_stream) const {
  writeOption(out_stream, server, "server");
  writeOption(out_stream, server_url_path, "server_url_path");
  writeOption(out_stream, ca_source, "ca_source");
  writeOption(out_stream, pkey_source, "pkey_source");
  writeOption(out_stream, cert_source, "cert_source");
}

void ProvisionConfig::updateFromPropertyTree(const boost::property_tree::ptree& pt) {
  CopyFromConfig(server, "server", pt);
  CopyFromConfig(p12_password, "p12_password", pt);
  CopyFromConfig(expiry_days, "expiry_days", pt);
  CopyFromConfig(provision_path, "provision_path", pt);
  CopyFromConfig(device_id, "device_id", pt);
  CopyFromConfig(primary_ecu_serial, "primary_ecu_serial", pt);
  CopyFromConfig(primary_ecu_hardware_id, "primary_ecu_hardware_id", pt);
  CopyFromConfig(ecu_registration_endpoint, "ecu_registration_endpoint", pt);
  CopyFromConfig(mode, "mode", pt);
}

void ProvisionConfig::writeToStream(std::ostream& out_stream) const {
  writeOption(out_stream, server, "server");
  writeOption(out_stream, p12_password, "p12_password");
  writeOption(out_stream, expiry_days, "expiry_days");
  writeOption(out_stream, provision_path, "provision_path");
  writeOption(out_stream, device_id, "device_id");
  writeOption(out_stream, primary_ecu_serial, "primary_ecu_serial");
  writeOption(out_stream, primary_ecu_hardware_id, "primary_ecu_hardware_id");
  writeOption(out_stream, ecu_registration_endpoint, "ecu_registration_endpoint");
  writeOption(out_stream, mode, "mode");
}

void UptaneConfig::updateFromPropertyTree(const boost::property_tree::ptree& pt) {
  CopyFromConfig(polling_sec, "polling_sec", pt);
  CopyFromConfig(director_server, "director_server", pt);
  CopyFromConfig(repo_server, "repo_server", pt);
  CopyFromConfig(key_source, "key_source", pt);
  CopyFromConfig(key_type, "key_type", pt);
  CopyFromConfig(force_install_completion, "force_install_completion", pt);
  CopyFromConfig(secondary_config_file, "secondary_config_file", pt);
  CopyFromConfig(secondary_preinstall_wait_sec, "secondary_preinstall_wait_sec", pt);
}

void UptaneConfig::writeToStream(std::ostream& out_stream) const {
  writeOption(out_stream, polling_sec, "polling_sec");
  writeOption(out_stream, director_server, "director_server");
  writeOption(out_stream, repo_server, "repo_server");
  writeOption(out_stream, key_source, "key_source");
  writeOption(out_stream, key_type, "key_type");
  writeOption(out_stream, force_install_completion, "force_install_completion");
  writeOption(out_stream, secondary_config_file, "secondary_config_file");
  writeOption(out_stream, secondary_preinstall_wait_sec, "secondary_preinstall_wait_sec");
}

void P11Config::updateFromPropertyTree(const boost::property_tree::ptree& pt) {
  CopyFromConfig(module, "module", pt);
  CopyFromConfig(pass, "pass", pt);
  CopyFromConfig(uptane_key_id, "uptane_key_id", pt);
  CopyFromConfig(tls_cacert_id, "tls_cacert_id", pt);
  CopyFromConfig(tls_pkey_id, "tls_pkey_id", pt);
  CopyFromConfig(tls_clientcert_id, "tls_clientcert_id", pt);
}

void P11Config::writeToStream(std::ostream& out_stream) const {
  writeOption(out_stream, module, "module");
  writeOption(out_stream, pass, "pass");
  writeOption(out_stream, uptane_key_id, "uptane_key_id");
  writeOption(out_stream, tls_cacert_id, "tls_ca_id");
  writeOption(out_stream, tls_pkey_id, "tls_pkey_id");
  writeOption(out_stream, tls_clientcert_id, "tls_clientcert_id");
}

void BaseConfig::updateFromToml(const boost::filesystem::path& filename) {
  LOG_INFO << "Reading config: " << filename;
  if (!boost::filesystem::exists(filename)) {
    throw std::runtime_error("Config file " + filename.string() + " does not exist.");
  }
  boost::property_tree::ptree pt;
  boost::property_tree::ini_parser::read_ini(filename.string(), pt);
  updateFromPropertyTree(pt);
}

void BaseConfig::updateFromDirs(const std::vector<boost::filesystem::path>& configs) {
  std::map<std::string, boost::filesystem::path> configs_map;
  for (const auto& config : configs) {
    if (!boost::filesystem::exists(config)) {
      continue;
    }
    if (boost::filesystem::is_directory(config)) {
      for (const auto& config_file : Utils::getDirEntriesByExt(config, ".toml")) {
        configs_map[config_file.filename().string()] = config_file;
      }
    } else {
      configs_map[config.filename().string()] = config;
    }
  }
  for (const auto& config_file : configs_map) {
    updateFromToml(config_file.second);
  }
}

/**
 * \par Description:
 *    Overload the << operator for the configuration class allowing
 *    us to print its content, i.e. for logging purposes.
 */
std::ostream& operator<<(std::ostream& os, const Config& cfg) {
  cfg.writeToStream(os);
  return os;
}

Config::Config() { postUpdateValues(); }

Config::Config(const boost::filesystem::path& filename) {
  updateFromToml(filename);
  postUpdateValues();
}

Config::Config(const std::vector<boost::filesystem::path>& config_dirs) {
  checkDirs(config_dirs);
  updateFromDirs(config_dirs);
  postUpdateValues();
}

Config::Config(const boost::program_options::variables_map& cmd) {
  // Redundantly check and set the loglevel from the commandline prematurely so
  // that it is taken account while processing the config.
  if (cmd.count("loglevel") != 0) {
    logger.loglevel = cmd["loglevel"].as<int>();
    logger_set_threshold(logger);
    loglevel_from_cmdline = true;
  }

  if (cmd.count("config") > 0) {
    const auto configs = cmd["config"].as<std::vector<boost::filesystem::path>>();
    checkDirs(configs);
    updateFromDirs(configs);
  } else {
    updateFromDirs(config_dirs_);
  }
  updateFromCommandLine(cmd);
  postUpdateValues();
}

KeyManagerConfig Config::keymanagerConfig() const {
  return KeyManagerConfig{p11, tls.ca_source, tls.pkey_source, tls.cert_source, uptane.key_type, uptane.key_source};
}

void Config::postUpdateValues() {
  logger_set_threshold(logger);

  if (provision.mode == ProvisionMode::kDefault) {
    provision.mode = provision.provision_path.empty() ? ProvisionMode::kDeviceCred : ProvisionMode::kSharedCred;
  } else if (provision.mode == ProvisionMode::kSharedCredReuse) {
    LOG_INFO << "Provisioning mode is set to reuse shared credentials. This should only be used for testing!";
  }

  if (tls.server.empty()) {
    if (!tls.server_url_path.empty()) {
      try {
        tls.server = Utils::readFile(tls.server_url_path, true);
      } catch (const std::exception& e) {
        LOG_ERROR << "Couldn't read gateway URL: " << e.what();
        tls.server = "";
      }
    } else if (!provision.provision_path.empty()) {
      if (boost::filesystem::exists(provision.provision_path)) {
        tls.server = Bootstrap::readServerUrl(provision.provision_path);
      } else {
        LOG_ERROR << "Provided provision archive " << provision.provision_path << " does not exist!";
      }
    }
  }

  if (!tls.server.empty()) {
    if (provision.server.empty()) {
      provision.server = tls.server;
    }

    if (uptane.repo_server.empty()) {
      uptane.repo_server = tls.server + "/repo";
    }

    if (uptane.director_server.empty()) {
      uptane.director_server = tls.server + "/director";
    }

    if (pacman.ostree_server.empty()) {
      pacman.ostree_server = tls.server + "/treehub";
    }
  }

  if (!uptane.director_server.empty()) {
    if (provision.ecu_registration_endpoint.empty()) {
      provision.ecu_registration_endpoint = uptane.director_server + "/ecus";
    }
  }

  LOG_TRACE << "Final configuration that will be used: \n" << (*this);
}

// For testing
void Config::updateFromTomlString(const std::string& contents) {
  boost::property_tree::ptree pt;
  std::stringstream stream(contents);
  boost::property_tree::ini_parser::read_ini(stream, pt);
  updateFromPropertyTree(pt);
}

void Config::updateFromPropertyTree(const boost::property_tree::ptree& pt) {
  // Keep this order the same as in config.h and Config::writeToStream().
  if (!loglevel_from_cmdline) {
    CopySubtreeFromConfig(logger, "logger", pt);
    // If not already set from the commandline, set the loglevel now so that it
    // affects the rest of the config processing.
    logger_set_threshold(logger);
  }
  CopySubtreeFromConfig(p11, "p11", pt);
  CopySubtreeFromConfig(tls, "tls", pt);
  CopySubtreeFromConfig(provision, "provision", pt);
  CopySubtreeFromConfig(uptane, "uptane", pt);
  CopySubtreeFromConfig(pacman, "pacman", pt);
  CopySubtreeFromConfig(storage, "storage", pt);
  CopySubtreeFromConfig(import, "import", pt);
  CopySubtreeFromConfig(telemetry, "telemetry", pt);
  CopySubtreeFromConfig(bootloader, "bootloader", pt);
}

void Config::updateFromCommandLine(const boost::program_options::variables_map& cmd) {
  // Try to keep these options in the same order as parse_options() in main.cc.
  if (cmd.count("loglevel") != 0) {
    logger.loglevel = cmd["loglevel"].as<int>();
  }
  if (cmd.count("tls-server") != 0) {
    tls.server = cmd["tls-server"].as<std::string>();
  }
  if (cmd.count("repo-server") != 0) {
    uptane.repo_server = cmd["repo-server"].as<std::string>();
  }
  if (cmd.count("director-server") != 0) {
    uptane.director_server = cmd["director-server"].as<std::string>();
  }
  if (cmd.count("primary-ecu-serial") != 0) {
    provision.primary_ecu_serial = cmd["primary-ecu-serial"].as<std::string>();
  }
  if (cmd.count("primary-ecu-hardware-id") != 0) {
    provision.primary_ecu_hardware_id = cmd["primary-ecu-hardware-id"].as<std::string>();
  }
  if (cmd.count("secondary-config-file") != 0) {
    uptane.secondary_config_file = cmd["secondary_config_file"].as<boost::filesystem::path>();
  }
}

void Config::writeToStream(std::ostream& sink) const {
  // Keep this order the same as in config.h and
  // Config::updateFromPropertyTree().
  WriteSectionToStream(logger, "logger", sink);
  WriteSectionToStream(p11, "p11", sink);
  WriteSectionToStream(tls, "tls", sink);
  WriteSectionToStream(provision, "provision", sink);
  WriteSectionToStream(uptane, "uptane", sink);
  WriteSectionToStream(pacman, "pacman", sink);
  WriteSectionToStream(storage, "storage", sink);
  WriteSectionToStream(import, "import", sink);
  WriteSectionToStream(telemetry, "telemetry", sink);
  WriteSectionToStream(bootloader, "bootloader", sink);
}