native_app_config.c

Go to the documentation of this file.

/**
 * @file
 * @brief Loads app-local runtime configuration and resolves app-relative override paths from local config and manifest data.
 */
 
#include "native_app_config.h"
 
#include "native_json_config.h"
#include "native_support.h"
 
#include <stdlib.h>
#include <string.h>
 
#ifdef _WIN32
#define pharos_app_config_strdup _strdup
#else
#define pharos_app_config_strdup strdup
#endif
 
char *resolve_conf_relative_path_native(const char *conf_path, const char *raw_value) {
  char *conf_dir;
  char *resolved;
  if (raw_value == NULL || raw_value[0] == '\0') {
    return pharos_app_config_strdup("");
  }
#ifdef _WIN32
  if ((strlen(raw_value) > 2 && raw_value[1] == ':') || raw_value[0] == '\\' || raw_value[0] == '/') {
    return pharos_app_config_strdup(raw_value);
  }
#else
  if (raw_value[0] == '/') {
    return pharos_app_config_strdup(raw_value);
  }
#endif
  conf_dir = path_dirname(conf_path);
  if (conf_dir == NULL) {
    return NULL;
  }
  resolved = path_join(conf_dir, raw_value);
  free(conf_dir);
  return resolved;
}
 
char *app_local_conf_path_native(const char *app_root) {
  char *path = path_join(app_root, "app.conf");
  if (path != NULL && path_exists(path)) {
    return path;
  }
  free(path);
  path = path_join(app_root, "pharos.conf");
  if (path == NULL) {
    return NULL;
  }
  if (!path_exists(path)) {
    free(path);
    return NULL;
  }
  return path;
}
 
 
 
static char *resolve_conf_value_key_native(const char *conf_path, const char *key, const char *value) {
  if (value == NULL) {
    return NULL;
  }
  if (streq(key, "app_dir") || streq(key, "build_dir") || streq(key, "state_dir") || streq(key, "state_path") || streq(key, "log_path") || streq(key, "socket_path") || streq(key, "error_report_path")) {
    return resolve_conf_relative_path_native(conf_path, value);
  }
  return pharos_app_config_strdup(value);
}
 
static char *duplicate_config_field_native(const AppLocalConfigNative *config, size_t offset) {
  const char *const *field;
  if (config == NULL) {
    return NULL;
  }
  field = (const char *const *)((const char *)config + offset);
  if (field == NULL || *field == NULL) {
    return NULL;
  }
  return pharos_app_config_strdup(*field);
}
 
char *app_local_conf_value_native(const char *app_root, const char *key) {
  static const struct {
    const char *key;
    size_t offset;
  } key_map[] = {
    { "build_dir", offsetof(AppLocalConfigNative, build_dir) },
    { "state_dir", offsetof(AppLocalConfigNative, state_dir) },
    { "state_path", offsetof(AppLocalConfigNative, state_path) },
    { "base_path", offsetof(AppLocalConfigNative, base_path) },
    { "log_path", offsetof(AppLocalConfigNative, log_path) },
    { "socket_path", offsetof(AppLocalConfigNative, socket_path) },
    { "error_report_path", offsetof(AppLocalConfigNative, error_report_path) },
    { "debug", offsetof(AppLocalConfigNative, debug) },
    { "conf_path", offsetof(AppLocalConfigNative, conf_path) }
  };
  AppLocalConfigNative config;
  char *value = NULL;
  size_t index;
  if (key != NULL && streq(key, "app_dir")) {
    return NULL;
  }
  if (load_app_local_config_native(app_root, &config) != 0) {
    return NULL;
  }
  for (index = 0; index < sizeof(key_map) / sizeof(key_map[0]); index++) {
    if (!streq(key, key_map[index].key)) {
      continue;
    }
    value = duplicate_config_field_native(&config, key_map[index].offset);
    break;
  }
  free_app_local_config_native(&config);
  return value;
}
 
int load_app_local_config_native(const char *app_root, AppLocalConfigNative *config) {
  char *conf_path;
  char *conf_text = NULL;
  char *manifest_path = NULL;
  char *manifest_text = NULL;
 
  if (config == NULL) {
    return -1;
  }
  memset(config, 0, sizeof(*config));
  if (app_root == NULL || app_root[0] == '\0') {
    return -1;
  }
  conf_path = app_local_conf_path_native(app_root);
  if (conf_path != NULL) {
    conf_text = read_file_text(conf_path);
    config->conf_path = conf_path;
  }
  manifest_path = path_join(app_root, "pharos.app.json");
  if (manifest_path != NULL && path_exists(manifest_path)) {
    manifest_text = read_file_text(manifest_path);
  }
  free(manifest_path);
  if (config->conf_path != NULL && conf_text != NULL) {
    char *raw;
    raw = conf_lookup_value_in_text(conf_text, "build_dir");
    config->build_dir = resolve_conf_value_key_native(config->conf_path, "build_dir", raw);
    free(raw);
    raw = conf_lookup_value_in_text(conf_text, "state_dir");
    config->state_dir = resolve_conf_value_key_native(config->conf_path, "state_dir", raw);
    free(raw);
    raw = conf_lookup_value_in_text(conf_text, "state_path");
    config->state_path = resolve_conf_value_key_native(config->conf_path, "state_path", raw);
    free(raw);
    raw = conf_lookup_value_in_text(conf_text, "base_path");
    config->base_path = resolve_conf_value_key_native(config->conf_path, "base_path", raw);
    free(raw);
    raw = conf_lookup_value_in_text(conf_text, "log_path");
    config->log_path = resolve_conf_value_key_native(config->conf_path, "log_path", raw);
    free(raw);
    raw = conf_lookup_value_in_text(conf_text, "socket_path");
    config->socket_path = resolve_conf_value_key_native(config->conf_path, "socket_path", raw);
    free(raw);
    raw = conf_lookup_value_in_text(conf_text, "error_report_path");
    config->error_report_path = resolve_conf_value_key_native(config->conf_path, "error_report_path", raw);
    free(raw);
    raw = conf_lookup_value_in_text(conf_text, "debug");
    config->debug = resolve_conf_value_key_native(config->conf_path, "debug", raw);
    free(raw);
  }
  if (manifest_text != NULL) {
    config->manifest_build_artifact_dir = json_find_string_in_section(manifest_text, "runtime", "build_artifact_dir");
    config->manifest_state_path = json_find_string_in_section(manifest_text, "runtime", "state_path");
    config->manifest_base_path = json_find_string_in_section(manifest_text, "runtime", "base_path");
  }
  free(conf_text);
  free(manifest_text);
  return 0;
}
 
void free_app_local_config_native(AppLocalConfigNative *config) {
  if (config == NULL) {
    return;
  }
  free(config->conf_path);
  free(config->build_dir);
  free(config->state_dir);
  free(config->state_path);
  free(config->base_path);
  free(config->log_path);
  free(config->socket_path);
  free(config->error_report_path);
  free(config->debug);
  free(config->manifest_build_artifact_dir);
  free(config->manifest_state_path);
  free(config->manifest_base_path);
  memset(config, 0, sizeof(*config));
}
 
char *normalize_base_path_native(const char *raw_value) {
  char *copy;
  char *trimmed;
  size_t len;
  if (raw_value == NULL || raw_value[0] == '\0' || streq(raw_value, "/") || streq(raw_value, "null")) {
    return pharos_app_config_strdup("");
  }
  copy = pharos_app_config_strdup(raw_value);
  if (copy == NULL) {
    return NULL;
  }
  trimmed = copy;
  while (*trimmed == '/') {
    trimmed++;
  }
  len = strlen(trimmed);
  while (len > 0 && trimmed[len - 1] == '/') {
    trimmed[--len] = '\0';
  }
  if (len == 0) {
    free(copy);
    return pharos_app_config_strdup("");
  }
  {
    char *normalized = (char *)malloc(len + 2);
    if (normalized == NULL) {
      free(copy);
      return NULL;
    }
    normalized[0] = '/';
    memcpy(normalized + 1, trimmed, len + 1);
    free(copy);
    return normalized;
  }
}