alias.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include <pwd.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <wctype.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "alias.h"
#include "lib.h"
#include "enter/lib.h"
#include "question/lib.h"
#include "send/lib.h"
#include "alternates.h"
#include "globals.h" // IWYU pragma: keep
#include "maillist.h"
#include "muttlib.h"
#include "reverse.h"
 
struct AliasList Aliases = TAILQ_HEAD_INITIALIZER(Aliases); 
 
static void write_safe_address(FILE *fp, const char *s)
{
  while (*s)
  {
    if ((*s == '\\') || (*s == '`') || (*s == '\'') || (*s == '"') || (*s == '$'))
      fputc('\\', fp);
    fputc(*s, fp);
    s++;
  }
}
 
static void expand_aliases_r(struct AddressList *al, struct ListHead *expn)
{
  struct Address *a = TAILQ_FIRST(al);
  while (a)
  {
    if (!a->group && !a->personal && a->mailbox && !strchr(a->mailbox, '@'))
    {
      struct AddressList *alias = alias_lookup(a->mailbox);
      if (alias)
      {
        bool duplicate = false;
        struct ListNode *np = NULL;
        STAILQ_FOREACH(np, expn, entries)
        {
          if (mutt_str_equal(a->mailbox, np->data)) /* alias already found */
          {
            mutt_debug(LL_DEBUG1, "loop in alias found for '%s'\n", a->mailbox);
            duplicate = true;
            break;
          }
        }
 
        if (duplicate)
        {
          // We've already seen this alias, so drop it
          struct Address *next = TAILQ_NEXT(a, entries);
          TAILQ_REMOVE(al, a, entries);
          mutt_addr_free(&a);
          a = next;
          continue;
        }
 
        // Keep a list of aliases that we've already seen
        mutt_list_insert_head(expn, mutt_str_dup(a->mailbox));
 
        /* The alias may expand to several addresses,
         * some of which may themselves be aliases.
         * Create a copy and recursively expand any aliases within. */
        struct AddressList copy = TAILQ_HEAD_INITIALIZER(copy);
        mutt_addrlist_copy(&copy, alias, false);
        expand_aliases_r(&copy, expn);
 
        /* Next, move the expanded addresses
         * from the copy into the original list (before the alias) */
        struct Address *a2 = NULL, *tmp = NULL;
        TAILQ_FOREACH_SAFE(a2, &copy, entries, tmp)
        {
          TAILQ_INSERT_BEFORE(a, a2, entries);
        }
        a = TAILQ_PREV(a, AddressList, entries);
        // Finally, remove the alias itself
        struct Address *next = TAILQ_NEXT(a, entries);
        TAILQ_REMOVE(al, next, entries);
        mutt_addr_free(&next);
      }
      else
      {
        struct passwd *pw = getpwnam(a->mailbox);
        if (pw)
        {
          char namebuf[256] = { 0 };
 
          mutt_gecos_name(namebuf, sizeof(namebuf), pw);
          mutt_str_replace(&a->personal, namebuf);
        }
      }
    }
    a = TAILQ_NEXT(a, entries);
  }
 
  const char *fqdn = NULL;
  const bool c_use_domain = cs_subset_bool(NeoMutt->sub, "use_domain");
  if (c_use_domain && (fqdn = mutt_fqdn(true, NeoMutt->sub)))
  {
    /* now qualify all local addresses */
    mutt_addrlist_qualify(al, fqdn);
  }
}
 
static void recode_buf(char *buf, size_t buflen)
{
  const char *const c_config_charset = cs_subset_string(NeoMutt->sub, "config_charset");
  const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
  if (!c_config_charset || !c_charset)
    return;
 
  char *s = mutt_str_dup(buf);
  if (!s)
    return;
  if (mutt_ch_convert_string(&s, c_charset, c_config_charset, MUTT_ICONV_NO_FLAGS) == 0)
    mutt_str_copy(buf, s, buflen);
  FREE(&s);
}
 
static int check_alias_name(const char *s, char *dest, size_t destlen)
{
  wchar_t wc = 0;
  mbstate_t mbstate = { 0 };
  size_t l;
  int rc = 0;
  bool dry = !dest || !destlen;
 
  if (!dry)
    destlen--;
  for (; s && *s && (dry || destlen) && (l = mbrtowc(&wc, s, MB_CUR_MAX, &mbstate)) != 0;
       s += l, destlen -= l)
  {
    bool bad = (l == (size_t) (-1)) || (l == (size_t) (-2)); /* conversion error */
    bad = bad || (!dry && l > destlen); /* too few room for mb char */
    if (l == 1)
      bad = bad || (!strchr("-_+=.", *s) && !iswalnum(wc));
    else
      bad = bad || !iswalnum(wc);
    if (bad)
    {
      if (dry)
        return -1;
      if (l == (size_t) (-1))
        memset(&mbstate, 0, sizeof(mbstate_t));
      *dest++ = '_';
      rc = -1;
    }
    else if (!dry)
    {
      memcpy(dest, s, l);
      dest += l;
    }
  }
  if (!dry)
    *dest = '\0';
  return rc;
}
 
static bool string_is_address(const char *str, const char *user, const char *domain)
{
  char buf[1024] = { 0 };
 
  snprintf(buf, sizeof(buf), "%s@%s", NONULL(user), NONULL(domain));
  if (mutt_istr_equal(str, buf))
    return true;
 
  return false;
}
 
struct AddressList *alias_lookup(const char *name)
{
  struct Alias *a = NULL;
 
  TAILQ_FOREACH(a, &Aliases, entries)
  {
    if (mutt_istr_equal(name, a->name))
      return &a->addr;
  }
  return NULL;
}
 
void mutt_expand_aliases(struct AddressList *al)
{
  struct ListHead expn; /* previously expanded aliases to avoid loops */
 
  STAILQ_INIT(&expn);
  expand_aliases_r(al, &expn);
  mutt_list_free(&expn);
  mutt_addrlist_dedupe(al);
}
 
void mutt_expand_aliases_env(struct Envelope *env)
{
  mutt_expand_aliases(&env->from);
  mutt_expand_aliases(&env->to);
  mutt_expand_aliases(&env->cc);
  mutt_expand_aliases(&env->bcc);
  mutt_expand_aliases(&env->reply_to);
  mutt_expand_aliases(&env->mail_followup_to);
}
 
struct AddressList *mutt_get_address(struct Envelope *env, const char **prefix)
{
  struct AddressList *al = NULL;
  const char *pfx = NULL;
 
  if (mutt_addr_is_user(TAILQ_FIRST(&env->from)))
  {
    if (!TAILQ_EMPTY(&env->to) && !mutt_is_mail_list(TAILQ_FIRST(&env->to)))
    {
      pfx = "To";
      al = &env->to;
    }
    else
    {
      pfx = "Cc";
      al = &env->cc;
    }
  }
  else if (!TAILQ_EMPTY(&env->reply_to) && !mutt_is_mail_list(TAILQ_FIRST(&env->reply_to)))
  {
    pfx = "Reply-To";
    al = &env->reply_to;
  }
  else
  {
    al = &env->from;
    pfx = "From";
  }
 
  if (prefix)
    *prefix = pfx;
 
  return al;
}
 
void alias_create(struct AddressList *al, const struct ConfigSubset *sub)
{
  struct Buffer *buf = mutt_buffer_pool_get();
  struct Buffer *fixed = mutt_buffer_pool_get();
  struct Buffer *prompt = NULL;
  struct Buffer *tmp = mutt_buffer_pool_get();
 
  struct Address *addr = NULL;
  char *pc = NULL;
  char *err = NULL;
  FILE *fp_alias = NULL;
 
  if (al)
  {
    addr = TAILQ_FIRST(al);
    if (addr && addr->mailbox)
    {
      mutt_buffer_strcpy(tmp, addr->mailbox);
      pc = strchr(mutt_buffer_string(tmp), '@');
      if (pc)
        *pc = '\0';
    }
  }
 
  /* Don't suggest a bad alias name in the event of a strange local part. */
  check_alias_name(mutt_buffer_string(tmp), buf->data, buf->dsize);
 
retry_name:
  /* L10N: prompt to add a new alias */
  if ((mutt_buffer_get_field(_("Alias as: "), buf, MUTT_COMP_NO_FLAGS, false,
                             NULL, NULL, NULL) != 0) ||
      mutt_buffer_is_empty(buf))
  {
    goto done;
  }
 
  /* check to see if the user already has an alias defined */
  if (alias_lookup(mutt_buffer_string(buf)))
  {
    mutt_error(_("You already have an alias defined with that name"));
    goto done;
  }
 
  if (check_alias_name(mutt_buffer_string(buf), fixed->data, fixed->dsize))
  {
    switch (mutt_yesorno(_("Warning: This alias name may not work.  Fix it?"), MUTT_YES))
    {
      case MUTT_YES:
        mutt_buffer_copy(buf, fixed);
        goto retry_name;
      case MUTT_ABORT:
        goto done;
      default:; // do nothing
    }
  }
 
  struct Alias *alias = alias_new();
  alias->name = mutt_buffer_strdup(buf);
 
  mutt_addrlist_to_local(al);
 
  if (addr && addr->mailbox)
    mutt_buffer_strcpy(buf, addr->mailbox);
  else
    mutt_buffer_reset(buf);
 
  mutt_addrlist_to_intl(al, NULL);
 
  do
  {
    if ((mutt_buffer_get_field(_("Address: "), buf, MUTT_COMP_NO_FLAGS, false,
                               NULL, NULL, NULL) != 0) ||
        mutt_buffer_is_empty(buf))
    {
      alias_free(&alias);
      goto done;
    }
 
    mutt_addrlist_parse(&alias->addr, mutt_buffer_string(buf));
    if (TAILQ_EMPTY(&alias->addr))
      mutt_beep(false);
    if (mutt_addrlist_to_intl(&alias->addr, &err))
    {
      mutt_error(_("Bad IDN: '%s'"), err);
      FREE(&err);
      continue;
    }
  } while (TAILQ_EMPTY(&alias->addr));
 
  if (addr && addr->personal && !mutt_is_mail_list(addr))
    mutt_buffer_strcpy(buf, addr->personal);
  else
    mutt_buffer_reset(buf);
 
  if (mutt_buffer_get_field(_("Personal name: "), buf, MUTT_COMP_NO_FLAGS,
                            false, NULL, NULL, NULL) != 0)
  {
    alias_free(&alias);
    goto done;
  }
  mutt_str_replace(&TAILQ_FIRST(&alias->addr)->personal, mutt_buffer_string(buf));
 
  mutt_buffer_reset(buf);
  if (mutt_buffer_get_field(_("Comment: "), buf, MUTT_COMP_NO_FLAGS, false,
                            NULL, NULL, NULL) == 0)
  {
    mutt_str_replace(&alias->comment, mutt_buffer_string(buf));
  }
 
  mutt_buffer_reset(buf);
  mutt_addrlist_write(&alias->addr, buf, true);
  prompt = mutt_buffer_pool_get();
  if (alias->comment)
  {
    mutt_buffer_printf(prompt, "[%s = %s # %s] %s", alias->name,
                       mutt_buffer_string(buf), alias->comment, _("Accept?"));
  }
  else
  {
    mutt_buffer_printf(prompt, "[%s = %s] %s", alias->name,
                       mutt_buffer_string(buf), _("Accept?"));
  }
  if (mutt_yesorno(mutt_buffer_string(prompt), MUTT_YES) != MUTT_YES)
  {
    alias_free(&alias);
    goto done;
  }
 
  alias_reverse_add(alias);
  TAILQ_INSERT_TAIL(&Aliases, alias, entries);
 
  const char *const c_alias_file = cs_subset_path(sub, "alias_file");
  mutt_buffer_strcpy(buf, c_alias_file);
 
  if (mutt_buffer_get_field(_("Save to file: "), buf, MUTT_COMP_FILE | MUTT_COMP_CLEAR,
                            false, NULL, NULL, NULL) != 0)
  {
    goto done;
  }
  mutt_expand_path(buf->data, buf->dsize);
  fp_alias = fopen(mutt_buffer_string(buf), "a+");
  if (!fp_alias)
  {
    mutt_perror(mutt_buffer_string(buf));
    goto done;
  }
 
  /* terminate existing file with \n if necessary */
  if (!mutt_file_seek(fp_alias, 0, SEEK_END))
  {
    goto done;
  }
  if (ftell(fp_alias) > 0)
  {
    if (!mutt_file_seek(fp_alias, -1, SEEK_CUR))
    {
      goto done;
    }
    if (fread(buf->data, 1, 1, fp_alias) != 1)
    {
      mutt_perror(_("Error reading alias file"));
      goto done;
    }
    if (!mutt_file_seek(fp_alias, 0, SEEK_END))
    {
      goto done;
    }
    if (buf->data[0] != '\n')
      fputc('\n', fp_alias);
  }
 
  if (check_alias_name(alias->name, NULL, 0))
    mutt_file_quote_filename(alias->name, buf->data, buf->dsize);
  else
    mutt_buffer_strcpy(buf, alias->name);
 
  recode_buf(buf->data, buf->dsize);
  fprintf(fp_alias, "alias %s ", mutt_buffer_string(buf));
  mutt_buffer_reset(buf);
 
  mutt_addrlist_write(&alias->addr, buf, false);
  recode_buf(buf->data, buf->dsize);
  write_safe_address(fp_alias, mutt_buffer_string(buf));
  if (alias->comment)
    fprintf(fp_alias, " # %s", alias->comment);
  fputc('\n', fp_alias);
  if (mutt_file_fsync_close(&fp_alias) != 0)
    mutt_perror(_("Trouble adding alias"));
  else
    mutt_message(_("Alias added"));
 
done:
  mutt_file_fclose(&fp_alias);
  mutt_buffer_pool_release(&buf);
  mutt_buffer_pool_release(&fixed);
  mutt_buffer_pool_release(&prompt);
  mutt_buffer_pool_release(&tmp);
}
 
bool mutt_addr_is_user(const struct Address *addr)
{
  if (!addr)
  {
    mutt_debug(LL_DEBUG5, "no, NULL address\n");
    return false;
  }
  if (!addr->mailbox)
  {
    mutt_debug(LL_DEBUG5, "no, no mailbox\n");
    return false;
  }
 
  if (mutt_istr_equal(addr->mailbox, Username))
  {
    mutt_debug(LL_DEBUG5, "#1 yes, %s = %s\n", addr->mailbox, Username);
    return true;
  }
  if (string_is_address(addr->mailbox, Username, ShortHostname))
  {
    mutt_debug(LL_DEBUG5, "#2 yes, %s = %s @ %s\n", addr->mailbox, Username, ShortHostname);
    return true;
  }
  const char *fqdn = mutt_fqdn(false, NeoMutt->sub);
  if (string_is_address(addr->mailbox, Username, fqdn))
  {
    mutt_debug(LL_DEBUG5, "#3 yes, %s = %s @ %s\n", addr->mailbox, Username, NONULL(fqdn));
    return true;
  }
  fqdn = mutt_fqdn(true, NeoMutt->sub);
  if (string_is_address(addr->mailbox, Username, fqdn))
  {
    mutt_debug(LL_DEBUG5, "#4 yes, %s = %s @ %s\n", addr->mailbox, Username, NONULL(fqdn));
    return true;
  }
 
  const struct Address *c_from = cs_subset_address(NeoMutt->sub, "from");
  if (c_from && mutt_istr_equal(c_from->mailbox, addr->mailbox))
  {
    mutt_debug(LL_DEBUG5, "#5 yes, %s = %s\n", addr->mailbox, c_from->mailbox);
    return true;
  }
 
  if (mutt_alternates_match(addr->mailbox))
    return true;
 
  mutt_debug(LL_DEBUG5, "no, all failed\n");
  return false;
}
 
struct Alias *alias_new(void)
{
  struct Alias *a = mutt_mem_calloc(1, sizeof(struct Alias));
  TAILQ_INIT(&a->addr);
  return a;
}
 
void alias_free(struct Alias **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Alias *alias = *ptr;
 
  mutt_debug(LL_NOTIFY, "NT_ALIAS_DELETE: %s\n", alias->name);
  struct EventAlias ev_a = { alias };
  notify_send(NeoMutt->notify, NT_ALIAS, NT_ALIAS_DELETE, &ev_a);
 
  FREE(&alias->name);
  FREE(&alias->comment);
  mutt_addrlist_clear(&(alias->addr));
  FREE(ptr);
}
 
void aliaslist_free(struct AliasList *al)
{
  if (!al)
    return;
 
  struct Alias *np = NULL, *tmp = NULL;
  TAILQ_FOREACH_SAFE(np, al, entries, tmp)
  {
    TAILQ_REMOVE(al, np, entries);
    alias_free(&np);
  }
  TAILQ_INIT(al);
}
 
void alias_init(void)
{
  alias_reverse_init();
}
 
void alias_shutdown(void)
{
  struct Alias *np = NULL;
  TAILQ_FOREACH(np, &Aliases, entries)
  {
    alias_reverse_delete(np);
  }
  aliaslist_free(&Aliases);
  alias_reverse_shutdown();
}