config_type.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "config_type.h"
#include "address.h"
 
struct Address *address_new(const char *addr)
{
  struct Address *a = mutt_mem_calloc(1, sizeof(*a));
  a->mailbox = buf_new(addr);
  return a;
}
 
static void address_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
{
  struct Address **a = var;
  if (!*a)
    return;
 
  mutt_addr_free(a);
}
 
static int address_string_set(const struct ConfigSet *cs, void *var, struct ConfigDef *cdef,
                              const char *value, struct Buffer *err)
{
  /* Store empty address as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  struct Address *addr = NULL;
 
  int rc = CSR_SUCCESS;
 
  if (!value && (cdef->type & D_NOT_EMPTY))
  {
    buf_printf(err, _("Option %s may not be empty"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  if (var && value)
  {
    // TODO - config can only store one
    struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
    mutt_addrlist_parse(&al, value);
    addr = mutt_addr_copy(TAILQ_FIRST(&al));
    mutt_addrlist_clear(&al);
  }
 
  if (var)
  {
    if (cdef->validator)
    {
      rc = cdef->validator(cs, cdef, (intptr_t) addr, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        address_destroy(cs, &addr, cdef);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    /* ordinary variable setting */
    address_destroy(cs, var, cdef);
 
    *(struct Address **) var = addr;
 
    if (!addr)
      rc |= CSR_SUC_EMPTY;
  }
  else
  {
    /* set the default/initial value */
    if (cdef->type & D_INTERNAL_INITIAL_SET)
      FREE(&cdef->initial);
 
    cdef->type |= D_INTERNAL_INITIAL_SET;
    cdef->initial = (intptr_t) mutt_str_dup(value);
  }
 
  return rc;
}
 
static int address_string_get(const struct ConfigSet *cs, void *var,
                              const struct ConfigDef *cdef, struct Buffer *result)
{
  if (var)
  {
    struct Address *a = *(struct Address **) var;
    if (a)
    {
      mutt_addr_write(result, a, false);
    }
  }
  else
  {
    buf_addstr(result, (char *) cdef->initial);
  }
 
  if (buf_is_empty(result))
    return CSR_SUCCESS | CSR_SUC_EMPTY; /* empty string */
 
  return CSR_SUCCESS;
}
 
static struct Address *address_dup(struct Address *addr)
{
  if (!addr)
    return NULL; /* LCOV_EXCL_LINE */
 
  struct Address *a = mutt_mem_calloc(1, sizeof(*a));
  a->personal = buf_dup(addr->personal);
  a->mailbox = buf_dup(addr->mailbox);
  return a;
}
 
static int address_native_set(const struct ConfigSet *cs, void *var,
                              const struct ConfigDef *cdef, intptr_t value,
                              struct Buffer *err)
{
  int rc;
 
  if (cdef->validator)
  {
    rc = cdef->validator(cs, cdef, value, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  mutt_addr_free(var);
 
  struct Address *addr = address_dup((struct Address *) value);
 
  rc = CSR_SUCCESS;
  if (!addr)
    rc |= CSR_SUC_EMPTY;
 
  *(struct Address **) var = addr;
  return rc;
}
 
static intptr_t address_native_get(const struct ConfigSet *cs, void *var,
                                   const struct ConfigDef *cdef, struct Buffer *err)
{
  struct Address *addr = *(struct Address **) var;
 
  return (intptr_t) addr;
}
 
static int address_reset(const struct ConfigSet *cs, void *var,
                         const struct ConfigDef *cdef, struct Buffer *err)
{
  struct Address *a = NULL;
  const char *initial = (const char *) cdef->initial;
 
  if (initial)
    a = address_new(initial);
 
  int rc = CSR_SUCCESS;
 
  if (cdef->validator)
  {
    rc = cdef->validator(cs, cdef, (intptr_t) a, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
    {
      address_destroy(cs, &a, cdef);
      return rc | CSR_INV_VALIDATOR;
    }
  }
 
  if (!a)
    rc |= CSR_SUC_EMPTY;
 
  address_destroy(cs, var, cdef);
 
  *(struct Address **) var = a;
  return rc;
}
 
const struct ConfigSetType CstAddress = {
  DT_ADDRESS,
  "address",
  address_string_set,
  address_string_get,
  address_native_set,
  address_native_get,
  NULL, // string_plus_equals
  NULL, // string_minus_equals
  address_reset,
  address_destroy,
};
 
const struct Address *cs_subset_address(const struct ConfigSubset *sub, const char *name)
{
  assert(sub && name);
 
  struct HashElem *he = cs_subset_create_inheritance(sub, name);
  assert(he);
 
#ifndef NDEBUG
  struct HashElem *he_base = cs_get_base(he);
  assert(DTYPE(he_base->type) == DT_ADDRESS);
#endif
 
  intptr_t value = cs_subset_he_native_get(sub, he, NULL);
  assert(value != INT_MIN);
 
  return (const struct Address *) value;
}