/src/dovecot/src/lib-settings/settings-parser.c

Source
/* Copyright (c) 2002-2018 Dovecot authors, see the included COPYING file */

#include "lib.h"
#include "array.h"
#include "crc32.h"
#include "str.h"
#include "str-parse.h"
#include "read-full.h"
#include "var-expand.h"
#include "unichar.h"
#include "settings-parser.h"

#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

struct boollist_removal {
  ARRAY_TYPE(const_string) *array;
  const char *key_suffix;
};

struct setting_parser_context {
  pool_t set_pool, parser_pool;
  int refcount;
        enum settings_parser_flags flags;

  const struct setting_parser_info *info;

  /* Pointer to structure containing the values */
  void *set_struct;
  ARRAY(struct boollist_removal) boollist_removals;

  char *error;
};

const char *set_value_unknown = "UNKNOWN_VALUE_WITH_VARIABLES";

#ifdef DEBUG_FAST
static const char *boollist_eol_sentry = "boollist-eol";
#endif
static const char *set_array_stop = "array-stop";

static void
setting_parser_copy_defaults(struct setting_parser_context *ctx,
           const struct setting_parser_info *info)
{
  const struct setting_define *def;
  const char *p, **strp;

  if (info->defaults == NULL)
    return;

  memcpy(ctx->set_struct, info->defaults, info->struct_size);
  for (def = info->defines; def->key != NULL; def++) {
    switch (def->type) {
    case SET_ENUM: {
      /* fix enums by dropping everything after the
         first ':' */
      strp = PTR_OFFSET(ctx->set_struct, def->offset);
      p = strchr(*strp, ':');
      if (p != NULL)
        *strp = p_strdup_until(ctx->set_pool, *strp, p);
      break;
    }
    default:
      break;
    }
  }
}

struct setting_parser_context *
settings_parser_init(pool_t set_pool, const struct setting_parser_info *root,
         enum settings_parser_flags flags)
{
  struct setting_parser_context *ctx;
  pool_t parser_pool;

  parser_pool = pool_alloconly_create(MEMPOOL_GROWING"settings parser",
              1024);
  ctx = p_new(parser_pool, struct setting_parser_context, 1);
  ctx->refcount = 1;
  ctx->set_pool = set_pool;
  ctx->parser_pool = parser_pool;
  ctx->flags = flags;

  ctx->info = root;
  if (root->struct_size > 0) {
    ctx->set_struct =
      p_malloc(ctx->set_pool, root->struct_size);
    setting_parser_copy_defaults(ctx, root);
  }

  pool_ref(ctx->set_pool);
  return ctx;
}

void settings_parser_ref(struct setting_parser_context *ctx)
{
  i_assert(ctx->refcount > 0);
  ctx->refcount++;
}

void settings_parser_unref(struct setting_parser_context **_ctx)
{
  struct setting_parser_context *ctx = *_ctx;

  if (ctx == NULL)
    return;
  *_ctx = NULL;

  i_assert(ctx->refcount > 0);
  if (--ctx->refcount > 0)
    return;
  i_free(ctx->error);
  pool_unref(&ctx->set_pool);
  pool_unref(&ctx->parser_pool);
}

unsigned int
setting_parser_info_get_define_count(const struct setting_parser_info *info)
{
  unsigned int count = 0;
  while (info->defines[count].key != NULL)
    count++;
  return count;
}

bool setting_parser_info_find_key(const struct setting_parser_info *info,
          const char *key, unsigned int *idx_r)
{
  const char *suffix;

  for (unsigned int i = 0; info->defines[i].key != NULL; i++) {
    if (!str_begins(key, info->defines[i].key, &suffix))
      ; /* mismatch */
    else if (suffix[0] == '\0') {
      /* full setting */
      while (i > 0 && info->defines[i].type == SET_ALIAS)
        i--;
      *idx_r = i;
      return TRUE;
    } else if (suffix[0] == '/' &&
         (info->defines[i].type == SET_STRLIST ||
          info->defines[i].type == SET_BOOLLIST)) {
      /* strlist key */
      *idx_r = i;
      return TRUE;
    }
  }
  return FALSE;
}

void *settings_parser_get_set(const struct setting_parser_context *ctx)
{
  return ctx->set_struct;
}

static void settings_parser_set_error(struct setting_parser_context *ctx,
              const char *error)
{
  i_free(ctx->error);
  ctx->error = i_strdup(error);
}

const char *settings_parser_get_error(struct setting_parser_context *ctx)
{
  return ctx->error;
}

static const struct setting_define *
setting_define_find(const struct setting_parser_info *info, const char *key)
{
  const struct setting_define *list;

  for (list = info->defines; list->key != NULL; list++) {
    if (strcmp(list->key, key) == 0)
      return list;
  }
  return NULL;
}

static int
get_bool(struct setting_parser_context *ctx, const char *value, bool *result_r)
{
  const char *error;
  int ret;
  if ((ret = str_parse_get_bool(value, result_r, &error)) < 0)
    settings_parser_set_error(ctx, error);
  return ret;
}

static int
get_uintmax(struct setting_parser_context *ctx, const char *value,
      uintmax_t *result_r)
{
  if (str_to_uintmax(value, result_r) < 0) {
    settings_parser_set_error(ctx, t_strdup_printf(
      "Invalid number %s: %s", value,
      str_num_error(value)));
    return -1;
  }
  return 0;
}

static int
get_uint(struct setting_parser_context *ctx, const char *value,
   unsigned int *result_r)
{
  if (settings_value_is_unlimited(value)) {
    *result_r = SET_UINT_UNLIMITED;
    return 0;
  }
  if (str_to_uint(value, result_r) < 0) {
    settings_parser_set_error(ctx, t_strdup_printf(
      "Invalid number %s: %s", value,
      str_num_error(value)));
    return -1;
  }
  return 0;
}

static int
get_octal(struct setting_parser_context *ctx, const char *value,
    unsigned int *result_r)
{
  unsigned long long octal;

  if (*value != '0')
    return get_uint(ctx, value, result_r);

  if (str_to_ullong_oct(value, &octal) < 0) {
    settings_parser_set_error(ctx,
      t_strconcat("Invalid number: ", value, NULL));
    return -1;
  }
  *result_r = (unsigned int)octal;
  return 0;
}

static int get_enum(struct setting_parser_context *ctx, const char *value,
        char **result_r, const char *allowed_values)
{
  const char *p;

  while (allowed_values != NULL) {
    p = strchr(allowed_values, ':');
    if (p == NULL) {
      if (strcmp(allowed_values, value) == 0)
        break;

      settings_parser_set_error(ctx,
        t_strconcat("Invalid value: ", value, NULL));
      return -1;
    }

    if (strncmp(allowed_values, value, p - allowed_values) == 0 &&
        value[p - allowed_values] == '\0')
      break;

    allowed_values = p + 1;
  }

  *result_r = p_strdup(ctx->set_pool, value);
  return 0;
}

static int
get_file(struct setting_parser_context *ctx, bool dup_value, const char **value)
{
  if (**value == '\0')
    return 0;
  const char *content = strchr(*value, '\n');
  if (content != NULL) {
    if (dup_value)
      *value = p_strdup(ctx->set_pool, *value);
    return 0;
  }

  const char *error;
  if (settings_parse_read_file(*value, *value, ctx->set_pool, NULL,
             "", value, &error) < 0) {
    settings_parser_set_error(ctx, error);
    return -1;
  }
  return 0;
}

static int
get_in_port_zero(struct setting_parser_context *ctx, const char *value,
   in_port_t *result_r)
{
  if (net_str2port_zero(value, result_r) < 0) {
    settings_parser_set_error(ctx, t_strdup_printf(
      "Invalid port number %s", value));
    return -1;
  }
  return 0;
}

int settings_parse_read_file(const char *path, const char *value_path,
           pool_t pool, struct stat *st_r,
           const char *prefix, const char **output_r,
           const char **error_r)
{
  struct stat st;
  int fd;

  if ((fd = open(path, O_RDONLY)) == -1) {
    *error_r = t_strdup_printf("open(%s) failed: %m", path);
    return -1;
  }
  if (fstat(fd, &st) < 0) {
    *error_r = t_strdup_printf("fstat(%s) failed: %m", path);
    i_close_fd(&fd);
    return -1;
  }
  size_t prefix_len = strlen(prefix);
  size_t value_path_len = strlen(value_path);
  size_t buf_size = MALLOC_ADD3(prefix_len, value_path_len, 1);
  buf_size = MALLOC_ADD3(buf_size, (size_t)st.st_size, 1);
  char *buf = p_malloc(pool, buf_size);
  memcpy(buf, prefix, prefix_len);
  memcpy(buf + prefix_len, value_path, value_path_len);
  buf[prefix_len + value_path_len] = '\n';

  int ret = read_full(fd, buf + prefix_len + value_path_len + 1,
          st.st_size);
  i_close_fd(&fd);
  if (ret < 0) {
    *error_r = t_strdup_printf("read(%s) failed: %m", path);
    return -1;
  }
  if (ret == 0) {
    *error_r = t_strdup_printf(
      "read(%s) failed: Unexpected EOF", path);
    return -1;
  }
  if (memchr(buf + prefix_len + value_path_len + 1, '\0', st.st_size) != NULL) {
    *error_r = t_strdup_printf(
      "%s contains NUL characters - This is not supported",
      path);
    return -1;
  }

  if (st_r != NULL)
    *st_r = st;
  *output_r = buf;
  return 0;
}

static int
settings_parse_strlist(struct setting_parser_context *ctx,
           ARRAY_TYPE(const_string) *array,
           const char *key, const char *value, const char **error_r)
{
  const char *const *items;
  const char *vkey, *vvalue;
  unsigned int i, count;

  /* If the next element after the visible array is set_array_stop, then
     the strlist should not be modified any further. */
  if (array_is_created(array)) {
    items = array_get(array, &count);
    if (items[count] == set_array_stop)
      return 0;
  }

  const char *suffix = strchr(key, SETTINGS_SEPARATOR);
  if (suffix == NULL) {
    if (value[0] == '\0') {
      /* clear out the whole strlist */
      if (array_is_created(array))
        array_clear(array);
      return 0;
    }

    *error_r = t_strdup_printf(
      "Setting is a string list, use %s/key=value'", key);
    return -1;
  }
  key = settings_section_unescape(suffix + 1);
  vvalue = p_strdup(ctx->set_pool, value);

  if (!array_is_created(array))
    p_array_init(array, ctx->set_pool, 4);

  /* replace if it already exists */
  items = array_get(array, &count);
  for (i = 0; i < count; i += 2) {
    if (strcmp(items[i], key) == 0) {
      array_idx_set(array, i + 1, &vvalue);
      return 0;
    }
  }

  vkey = p_strdup(ctx->set_pool, key);
  array_push_back(array, &vkey);
  array_push_back(array, &vvalue);
  return 0;
}

int settings_parse_boollist_string(const char *value, pool_t pool,
           ARRAY_TYPE(const_string) *dest,
           const char **error_r)
{
  string_t *elem = t_str_new(32);
  const char *elem_dup;
  bool quoted = FALSE, end_of_quote = FALSE;
  for (unsigned int i = 0; value[i] != '\0'; i++) {
    switch (value[i]) {
    case '"':
      if (!quoted) {
        /* beginning of a string */
        if (str_len(elem) != 0) {
          *error_r = "'\"' in the middle of a string";
          return -1;
        }
        quoted = TRUE;
      } else if (end_of_quote) {
        *error_r = "Expected ',' or ' ' after '\"'";
        return -1;
      } else {
        /* end of a string */
        end_of_quote = TRUE;
      }
      break;
    case ' ':
    case ',':
      if (quoted && !end_of_quote) {
        /* inside a "quoted string" */
        str_append_c(elem, value[i]);
        break;
      }

      if (quoted || str_len(elem) > 0) {
        elem_dup = p_strdup(pool,
          settings_section_unescape(str_c(elem)));
        array_push_back(dest, &elem_dup);
        str_truncate(elem, 0);
      }
      quoted = FALSE;
      end_of_quote = FALSE;
      break;
    case '\\':
      if (quoted) {
        i++;
        if (value[i] == '\0') {
          *error_r = "Value ends with '\\'";
          return -1;
        }
      }
      /* fall through */
    default:
      if (end_of_quote) {
        *error_r = "Expected ',' or ' ' after '\"'";
        return -1;
      }
      str_append_c(elem, value[i]);
      break;
    }
  }
  if (quoted && !end_of_quote) {
    *error_r = "Missing ending '\"'";
    return -1;
  }
  if (quoted || str_len(elem) > 0) {
    elem_dup = p_strdup(pool, settings_section_unescape(str_c(elem)));
    array_push_back(dest, &elem_dup);
  }
  return 0;
}

const char *const *settings_boollist_get(const ARRAY_TYPE(const_string) *array)
{
  const char *const *strings = empty_str_array;
  unsigned int count;

  if (array_not_empty(array)) {
    strings = array_get(array, &count);
    i_assert(strings[count] == NULL);
#ifdef DEBUG_FAST
  i_assert(strings[count+1] == boollist_eol_sentry ||
     (strings[count+1] == set_array_stop &&
      strings[count+2] == boollist_eol_sentry));
#endif
  }
  return strings;

}

void settings_file_get(const char *value, pool_t path_pool,
           struct settings_file *file_r)
{
  const char *p;

  if (*value == '\0') {
    file_r->path = "";
    file_r->content = "";
    return;
  }

  p = strchr(value, '\n');
  if (p == NULL)
    i_panic("Settings file value is missing LF");
  file_r->path = p_strdup_until(path_pool, value, p);
  file_r->content = p + 1;
}

bool settings_file_has_path(const char *value)
{
  /* value must be in <path><LF><content> format */
  const char *p = strchr(value, '\n');
  if (p == NULL)
    i_panic("Settings file value is missing LF");
  return p != value;
}

const char *settings_file_get_value(pool_t pool,
            const struct settings_file *file)
{
  const char *path = file->path != NULL ? file->path : "";
  size_t path_len = strlen(path);
  size_t content_len = strlen(file->content);
  size_t value_size = MALLOC_ADD3(path_len, 1, content_len);
  value_size = MALLOC_ADD(value_size, 1);

  char *value = p_malloc(pool, value_size);
  memcpy(value, path, path_len);
  value[path_len] = '\n';
  memcpy(value + path_len + 1, file->content, content_len);
  return value;
}

void settings_boollist_finish(ARRAY_TYPE(const_string) *array, bool stop)
{
  array_append_zero(array);
  if (stop)
    array_push_back(array, &set_array_stop);
#ifdef DEBUG_FAST
  array_push_back(array, &boollist_eol_sentry);
  array_pop_back(array);
#endif
  if (stop)
    array_pop_back(array);
  array_pop_back(array);
}

bool settings_boollist_is_stopped(const ARRAY_TYPE(const_string) *array)
{
  /* The first element after the visible array is NULL. If the next element
     after the NULL is set_array_stop, then the boollist is stopped. */
  unsigned int count;
  const char *const *values = array_get(array, &count);
  i_assert(values[count] == NULL);
  return values[count + 1] == set_array_stop;
}

static int
settings_parse_boollist(struct setting_parser_context *ctx,
      ARRAY_TYPE(const_string) *array,
      const char *key, const char *value)
{
  const char *const *elem, *error;

  if (!array_is_created(array))
    p_array_init(array, ctx->set_pool, 5);
  else {
    /* If the array is stopped, then the boollist should not
       be modified any further. */
    if (settings_boollist_is_stopped(array))
      return 0;
  }

  key = strrchr(key, SETTINGS_SEPARATOR);
  if (key == NULL) {
    /* replace the whole boollist */
    array_clear(array);
    if (settings_parse_boollist_string(value, ctx->set_pool,
               array, &error) < 0) {
      settings_parser_set_error(ctx, error);
      return -1;
    }
    /* keep it NULL-terminated for each access */
    settings_boollist_finish(array, FALSE);
    return 0;
  }
  key = settings_section_unescape(key + 1);

  bool value_bool;
  if (get_bool(ctx, value, &value_bool) < 0)
    return -1;

  elem = array_lsearch(array, &key, i_strcmp_p);
  if (elem == NULL && value_bool) {
    /* add missing element */
    key = p_strdup(ctx->set_pool, key);
    array_push_back(array, &key);
  } else if (!value_bool) {
    /* remove unwanted element */
    if (elem != NULL) {
      key = *elem;
      array_delete(array, array_ptr_to_idx(array, elem), 1);
    } else {
      key = p_strdup(ctx->parser_pool, key);
    }
    /* remember the removal for settings_parse_list_has_key() */
    if (!array_is_created(&ctx->boollist_removals))
      p_array_init(&ctx->boollist_removals, ctx->parser_pool, 2);
    struct boollist_removal *removal =
      array_append_space(&ctx->boollist_removals);
    removal->array = array;
    removal->key_suffix = key;
  }
  /* keep it NULL-terminated for each access */
  settings_boollist_finish(array, FALSE);
  return 0;
}

static int
settings_parse(struct setting_parser_context *ctx,
         const struct setting_define *def,
         const char *key, const char *value, bool dup_value)
{
  void *ptr;
  const void *ptr2;
  const char *error;
  int ret;

  if (value == set_value_unknown) {
    /* setting value is unknown - preserve the exact pointer */
    dup_value = FALSE;
  }

  i_free(ctx->error);

  while (def->type == SET_ALIAS) {
    i_assert(def != ctx->info->defines);
    def--;
  }

  ptr = PTR_OFFSET(ctx->set_struct, def->offset);
  switch (def->type) {
  case SET_BOOL:
    if (get_bool(ctx, value, (bool *)ptr) < 0)
      return -1;
    break;
  case SET_UINTMAX:
    if (get_uintmax(ctx, value, (uintmax_t *)ptr) < 0)
      return -1;
    break;
  case SET_UINT:
    if (get_uint(ctx, value, (unsigned int *)ptr) < 0)
      return -1;
    break;
  case SET_UINT_OCT:
    if (get_octal(ctx, value, (unsigned int *)ptr) < 0)
      return -1;
    break;
  case SET_TIME:
    if (settings_value_is_unlimited(value)) {
      *(unsigned int *)ptr = SET_TIME_INFINITE;
      return 0;
    }
    if (str_parse_get_interval(value, (unsigned int *)ptr, &error) < 0) {
      settings_parser_set_error(ctx, error);
      return -1;
    }
    break;
  case SET_TIME_MSECS:
    if (settings_value_is_unlimited(value)) {
      *(unsigned int *)ptr = SET_TIME_MSECS_INFINITE;
      return 0;
    }
    if (str_parse_get_interval_msecs(value, (unsigned int *)ptr, &error) < 0) {
      settings_parser_set_error(ctx, error);
      return -1;
    }
    break;
  case SET_SIZE:
    if (settings_value_is_unlimited(value)) {
      *(uoff_t *)ptr = SET_SIZE_UNLIMITED;
      return 0;
    }
    if (str_parse_get_size(value, (uoff_t *)ptr, &error) < 0) {
      settings_parser_set_error(ctx, error);
      return -1;
    }
    break;
  case SET_IN_PORT:
    if (get_in_port_zero(ctx, value, (in_port_t *)ptr) < 0)
      return -1;
    break;
  case SET_STR:
  case SET_STR_NOVARS:
    if (HAS_ANY_BITS(def->flags, SET_FLAG_UNICODE_NFC) &&
        value != set_value_unknown) {
      if (uni_utf8_to_nfc(value, strlen(value), &value) < 0) {
        settings_parser_set_error(ctx,
          "Value contains invalid Unicode code point");
        return -1;
      }
      dup_value = TRUE;
    }
    if (dup_value)
      value = p_strdup(ctx->set_pool, value);
    *((const char **)ptr) = value;
    break;
  case SET_FILE: {
    /* only expand first line, if there */
    const char *path = t_strcut(value, '\n');
    if (strstr(path, "%{") != NULL) {
      if (t_var_expand(value, NULL, &value, &error) < 0) {
        settings_parser_set_error(ctx, error);
        return -1;
      }
    }
    /* Read the file directly to get the content */
    if (get_file(ctx, dup_value, &value) < 0) {
      /* We may be running settings_check()s in doveconf at a
         time when the file couldn't yet be opened. To avoid
         unnecessary errors, set the value unknown. */
      *((const char **)ptr) = set_value_unknown;
      return -1;
    }
    *((const char **)ptr) = value;
    break;
  }
  case SET_ENUM:
    /* get the available values from default string */
    i_assert(ctx->info->defaults != NULL);
    ptr2 = CONST_PTR_OFFSET(ctx->info->defaults, def->offset);
    if (get_enum(ctx, value, (char **)ptr,
           *(const char *const *)ptr2) < 0)
      return -1;
    break;
  case SET_STRLIST:
    T_BEGIN {
      ret = settings_parse_strlist(ctx, ptr, key, value,
                 &error);
      if (ret < 0)
        settings_parser_set_error(ctx, error);
    } T_END;
    if (ret < 0)
      return -1;
    break;
  case SET_BOOLLIST:
    T_BEGIN {
      ret = settings_parse_boollist(ctx, ptr, key, value);
    } T_END;
    if (ret < 0)
      return -1;
    break;
  case SET_FILTER_ARRAY: {
    /* Add filter names to the array. Userdb can add more simply
       by giving e.g. "namespace+=newname" without it removing the
       existing ones. */
    ARRAY_TYPE(const_string) *arr = ptr;
    const char *const *list =
      t_strsplit(value, SETTINGS_FILTER_ARRAY_SEPARATORS);
    unsigned int i, count = str_array_length(list);
    if (!array_is_created(arr))
      p_array_init(arr, ctx->set_pool, count);
    else {
      /* If the next element after the visible array is
         set_array_stop, then the named list filter
         should not be modified any further. */
      unsigned int old_count;
      const char *const *old_values =
        array_get(arr, &old_count);
      if (old_values[old_count] == set_array_stop)
        break;
    }
    unsigned int insert_pos = 0;
    for (i = 0; i < count; i++) {
      const char *value = p_strdup(ctx->set_pool,
        settings_section_unescape(list[i]));
      if (array_lsearch(arr, &value, i_strcmp_p) != NULL)
        continue; /* ignore duplicates */
      if ((ctx->flags & SETTINGS_PARSER_FLAG_INSERT_FILTERS) != 0)
        array_insert(arr, insert_pos++, &value, 1);
      else
        array_push_back(arr, &value);
    }
    /* Make sure the next element after the array is accessible for
       the set_array_stop check. */
    array_append_zero(arr);
    array_pop_back(arr);
    break;
  }
  case SET_FILTER_NAME:
    settings_parser_set_error(ctx, t_strdup_printf(
      "Setting is a named filter, use '%s {'", key));
    return -1;
  case SET_ALIAS:
    i_unreached();
  }
  return 0;
}

static bool
settings_find_key(struct setting_parser_context *ctx, const char *key,
      bool allow_filter_name, const struct setting_define **def_r)
{
  const struct setting_define *def;
  const char *end, *parent_key;

  /* try to find the exact key */
  def = setting_define_find(ctx->info, key);
  if (def != NULL && (def->type != SET_FILTER_NAME ||
          allow_filter_name)) {
    *def_r = def;
    return TRUE;
  }

  /* try to find list/key prefix */
  end = strrchr(key, SETTINGS_SEPARATOR);
  if (end == NULL)
    return FALSE;

  parent_key = t_strdup_until(key, end);
  def = setting_define_find(ctx->info, parent_key);
  if (def != NULL && (def->type == SET_STRLIST ||
          def->type == SET_BOOLLIST)) {
    *def_r = def;
    return TRUE;
  }
  return FALSE;
}

static int
settings_parse_keyvalue_real(struct setting_parser_context *ctx,
           const char *key, const char *value, bool dup_value)
{
  const struct setting_define *def;

  if (!settings_find_key(ctx, key, FALSE, &def)) {
    settings_parser_set_error(ctx,
      t_strconcat("Unknown setting: ", key, NULL));
    return 0;
  }

  if (settings_parse(ctx, def, key, value, dup_value) < 0)
    return -1;
  return 1;
}

int settings_parse_keyvalue(struct setting_parser_context *ctx,
          const char *key, const char *value)
{
  return settings_parse_keyvalue_real(ctx, key, value, TRUE);
}

int settings_parse_keyidx_value(struct setting_parser_context *ctx,
        unsigned int key_idx, const char *key,
        const char *value)
{
  return settings_parse(ctx, &ctx->info->defines[key_idx],
            key, value, TRUE);
}

int settings_parse_keyvalue_nodup(struct setting_parser_context *ctx,
          const char *key, const char *value)
{
  return settings_parse_keyvalue_real(ctx, key, value, FALSE);
}

int settings_parse_keyidx_value_nodup(struct setting_parser_context *ctx,
              unsigned int key_idx, const char *key,
              const char *value)
{
  return settings_parse(ctx, &ctx->info->defines[key_idx],
            key, value, FALSE);
}

void settings_parse_array_stop(struct setting_parser_context *ctx,
             unsigned int key_idx)
{
  i_assert(ctx->info->defines[key_idx].type == SET_FILTER_ARRAY ||
     ctx->info->defines[key_idx].type == SET_BOOLLIST ||
     ctx->info->defines[key_idx].type == SET_STRLIST);

  ARRAY_TYPE(const_string) *arr =
    PTR_OFFSET(ctx->set_struct, ctx->info->defines[key_idx].offset);
  if (!array_is_created(arr))
    p_array_init(arr, ctx->set_pool, 1);

  if (ctx->info->defines[key_idx].type == SET_BOOLLIST)
    settings_boollist_finish(arr, TRUE);
  else {
    /* Use the next element hidden after the array to keep
       the stop-state */
    array_push_back(arr, &set_array_stop);
    array_pop_back(arr);
  }
}

static int boollist_removal_cmp(const struct boollist_removal *r1,
        const struct boollist_removal *r2)
{
  if (r1->array != r2->array)
    return 1;
  return strcmp(r1->key_suffix, r2->key_suffix);
}

bool settings_parse_list_has_key(struct setting_parser_context *ctx,
         unsigned int key_idx,
         const char *key_suffix)
{
  const struct setting_define *def = &ctx->info->defines[key_idx];
  unsigned int skip = UINT_MAX;

  switch (def->type) {
  case SET_STRLIST:
    skip = 2;
    break;
  case SET_BOOLLIST:
    skip = 1;
    if (!array_is_created(&ctx->boollist_removals))
      break;

    struct boollist_removal lookup = {
      .array = PTR_OFFSET(ctx->set_struct, def->offset),
      .key_suffix = key_suffix,
    };
    if (array_lsearch(&ctx->boollist_removals, &lookup,
          boollist_removal_cmp) != NULL)
      return TRUE;
    break;
  default:
    i_unreached();
  }

  ARRAY_TYPE(const_string) *array =
    PTR_OFFSET(ctx->set_struct, def->offset);
  if (!array_is_created(array))
    return FALSE;

  unsigned int i, count;
  const char *const *items = array_get(array, &count);
  for (i = 0; i < count; i += skip) {
    if (strcmp(items[i], key_suffix) == 0)
      return TRUE;
  }
  return FALSE;
}

const void *
settings_parse_get_value(struct setting_parser_context *ctx,
       const char **key, enum setting_type *type_r)
{
  const struct setting_define *def;

  if (!settings_find_key(ctx, *key, TRUE, &def))
    return NULL;

  while (def->type == SET_ALIAS) {
    i_assert(def != ctx->info->defines);
    def--;
    /* Replace the key with the unaliased key. We assume here that
       lists don't have aliases, because the key replacement
       would only need to replace the key prefix then. */
    i_assert(def->type != SET_STRLIST && def->type != SET_BOOLLIST);
    *key = def->key;
  }
  *type_r = def->type;
  return PTR_OFFSET(ctx->set_struct, def->offset);
}

bool settings_check(struct event *event, const struct setting_parser_info *info,
        pool_t pool, void *set, const char **error_r)
{
  bool valid;

  if (info->check_func != NULL) {
    T_BEGIN {
      valid = info->check_func(set, pool, error_r);
    } T_END_PASS_STR_IF(!valid, error_r);
    if (!valid)
      return FALSE;
  }
  if (info->ext_check_func != NULL) {
    T_BEGIN {
      valid = info->ext_check_func(event, set, pool, error_r);
    } T_END_PASS_STR_IF(!valid, error_r);
    if (!valid)
      return FALSE;
  }
  return TRUE;
}

bool settings_parser_check(struct setting_parser_context *ctx, pool_t pool,
         struct event *event, const char **error_r)
{
  return settings_check(event, ctx->info, pool,
            ctx->set_struct, error_r);
}

unsigned int settings_hash(const struct setting_parser_info *info,
         const void *set, const char *const *except_fields)
{
  unsigned int crc = 0;

  for (unsigned int i = 0; info->defines[i].key != NULL; i++) {
    if (except_fields != NULL &&
        str_array_find(except_fields, info->defines[i].key))
      continue;

    const void *p = CONST_PTR_OFFSET(set, info->defines[i].offset);
    switch (info->defines[i].type) {
    case SET_BOOL: {
      const bool *b = p;
      crc = crc32_data_more(crc, b, sizeof(*b));
      break;
    }
    case SET_UINTMAX: {
      const uintmax_t *i = p;
      crc = crc32_data_more(crc, i, sizeof(*i));
      break;
    }
    case SET_UINT:
    case SET_UINT_OCT:
    case SET_TIME:
    case SET_TIME_MSECS: {
      const unsigned int *i = p;
      crc = crc32_data_more(crc, i, sizeof(*i));
      break;
    }
    case SET_SIZE: {
      const uoff_t *s = p;
      crc = crc32_data_more(crc, s, sizeof(*s));
      break;
    }
    case SET_IN_PORT: {
      const in_port_t *port = p;
      crc = crc32_data_more(crc, port, sizeof(*port));
      break;
    }
    case SET_STR:
    case SET_STR_NOVARS:
    case SET_ENUM: {
      const char *const *str = p;
      crc = crc32_str_more(crc, *str);
      break;
    }
    case SET_FILE: {
      const char *const *str = p;
      const char *lf = strchr(*str, '\n');
      if (lf == NULL)
        i_panic("Settings file value is missing LF");
      if (lf == *str) {
        /* no filename - need to hash the content */
        crc = crc32_str_more(crc, *str + 1);
      } else {
        /* hashing the filename is enough */
        crc = crc32_data_more(crc, *str, lf - *str);
      }
      break;
    }
    case SET_STRLIST:
    case SET_BOOLLIST:
    case SET_FILTER_ARRAY: {
      const ARRAY_TYPE(const_string) *list = p;
      if (array_is_created(list)) {
        const char *str;
        array_foreach_elem(list, str)
          crc = crc32_str_more(crc, str);
      }
      break;
    }
    case SET_ALIAS:
    case SET_FILTER_NAME:
      break;
    }
  }
  return crc;
}

bool settings_equal(const struct setting_parser_info *info,
        const void *set1, const void *set2,
        const char *const *except_fields)
{
  for (unsigned int i = 0; info->defines[i].key != NULL; i++) {
    if (except_fields != NULL &&
        str_array_find(except_fields, info->defines[i].key))
      continue;

    const void *p1 = CONST_PTR_OFFSET(set1, info->defines[i].offset);
    const void *p2 = CONST_PTR_OFFSET(set2, info->defines[i].offset);
    switch (info->defines[i].type) {
    case SET_BOOL: {
      const bool *b1 = p1, *b2 = p2;
      if (*b1 != *b2)
        return FALSE;
      break;
    }
    case SET_UINTMAX: {
      const uintmax_t *i1 = p1, *i2 = p2;
      if (*i1 != *i2)
        return FALSE;
      break;
    }
    case SET_UINT:
    case SET_UINT_OCT:
    case SET_TIME:
    case SET_TIME_MSECS: {
      const unsigned int *i1 = p1, *i2 = p2;
      if (*i1 != *i2)
        return FALSE;
      break;
    }
    case SET_SIZE: {
      const uoff_t *s1 = p1, *s2 = p2;
      if (*s1 != *s2)
        return FALSE;
      break;
    }
    case SET_IN_PORT: {
      const in_port_t *port1 = p1, *port2 = p2;
      if (*port1 != *port2)
        return FALSE;
      break;
    }
    case SET_STR:
    case SET_STR_NOVARS:
    case SET_ENUM:
    case SET_FILE: {
      const char *const *str1 = p1, *const *str2 = p2;
      if (strcmp(*str1, *str2) != 0)
        return FALSE;
      break;
    }
    case SET_STRLIST:
    case SET_BOOLLIST:
    case SET_FILTER_ARRAY: {
      const ARRAY_TYPE(const_string) *list1 = p1, *list2 = p2;
      if (array_is_empty(list1)) {
        if (!array_is_empty(list2))
          return FALSE;
        break;
      }
      if (array_is_empty(list2))
        return FALSE;

      unsigned int i, count1, count2;
      const char *const *str1 = array_get(list1, &count1);
      const char *const *str2 = array_get(list2, &count2);
      if (count1 != count2)
        return FALSE;
      for (i = 0; i < count1; i++) {
        if (strcmp(str1[i], str2[i]) != 0)
          return FALSE;
      }
      break;
    }
    case SET_ALIAS:
    case SET_FILTER_NAME:
      break;
    }
  }
  return TRUE;
}

void *settings_defaults_dup(pool_t pool, const struct setting_parser_info *info)
{
  void *dup = p_malloc(pool, info->struct_size);
  memcpy(dup, info->defaults, info->struct_size);
  memcpy(PTR_OFFSET(dup, info->pool_offset1 - 1), &pool, sizeof(pool));
  return dup;
}

const char *settings_section_escape(const char *name)
{
#define CHAR_NEED_ESCAPE(c) \
  ((c) == '=' || (c) == SETTINGS_SEPARATOR || (c) == '\\' || (c) == ' ' || (c) == ',')
  string_t *str;
  unsigned int i;

  for (i = 0; name[i] != '\0'; i++) {
    if (CHAR_NEED_ESCAPE(name[i]))
      break;
  }
  if (name[i] == '\0') {
    if (i == 0)
      return "\\.";
    return name;
  }

  str = t_str_new(i + strlen(name+i) + 8);
  str_append_data(str, name, i);
  for (; name[i] != '\0'; i++) {
    switch (name[i]) {
    case '=':
      str_append(str, "\\e");
      break;
    case SETTINGS_SEPARATOR:
      str_append(str, "\\s");
      break;
    case '\\':
      str_append(str, "\\\\");
      break;
    case ' ':
      str_append(str, "\\_");
      break;
    case ',':
      str_append(str, "\\+");
      break;
    default:
      str_append_c(str, name[i]);
      break;
    }
  }
  return str_c(str);
}

const char *settings_section_unescape(const char *name)
{
  const char *p = strchr(name, '\\');
  if (p == NULL)
    return name;

  string_t *str = t_str_new(strlen(name));
  str_append_data(str, name, p - name);
  while (p[1] != '\0') {
    switch (p[1]) {
    case 'e':
      str_append_c(str, '=');
      break;
    case 's':
      str_append_c(str, SETTINGS_SEPARATOR);
      break;
    case '\\':
      str_append_c(str, '\\');
      break;
    case '_':
      str_append_c(str, ' ');
      break;
    case '+':
      str_append_c(str, ',');
      break;
    case '.':
      /* empty string */
      break;
    default:
      /* not supposed to happen */
      str_append_c(str, '\\');
      str_append_c(str, p[1]);
      break;
    }
    name = p+2;
    p = strchr(name, '\\');
    if (p == NULL) {
      str_append(str, name);
      return str_c(str);
    }
    str_append_data(str, name, p - name);
  }
  /* ends with '\\' - not supposed to happen */
  str_append_c(str, '\\');
  return str_c(str);
}

static enum settings_binary config_binary = SETTINGS_BINARY_OTHER;

void settings_set_config_binary(enum settings_binary binary)
{
  config_binary = binary;
}

enum settings_binary settings_get_config_binary(void)
{
  return config_binary;
}


Coverage Report

Created: 2026-03-15 06:40