address.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "mutt/lib.h"
#include "address.h"
#include "idna2.h"
 
const char AddressSpecials[] = "@.,:;<>[]\\\"()";
 
#define is_special(ch) strchr(AddressSpecials, ch)
 
int AddressError = 0;
 
const char *const AddressErrors[] = {
  "out of memory",   "mismatched parentheses", "mismatched quotes",
  "bad route in <>", "bad address in <>",      "bad address spec",
};
 
static const char *parse_comment(const char *s, char *comment, size_t *commentlen, size_t commentmax)
{
  int level = 1;
 
  while (*s && level)
  {
    if (*s == '(')
      level++;
    else if (*s == ')')
    {
      if (--level == 0)
      {
        s++;
        break;
      }
    }
    else if (*s == '\\')
    {
      if (!*++s)
        break;
    }
    if (*commentlen < commentmax)
      comment[(*commentlen)++] = *s;
    s++;
  }
  if (level != 0)
  {
    AddressError = ADDR_ERR_MISMATCH_PAREN;
    return NULL;
  }
  return s;
}
 
static const char *parse_quote(const char *s, char *token, size_t *tokenlen, size_t tokenmax)
{
  while (*s)
  {
    if (*tokenlen < tokenmax)
      token[*tokenlen] = *s;
    if (*s == '\\')
    {
      if (!*++s)
        break;
 
      if (*tokenlen < tokenmax)
        token[*tokenlen] = *s;
    }
    else if (*s == '"')
      return s + 1;
    (*tokenlen)++;
    s++;
  }
  AddressError = ADDR_ERR_MISMATCH_QUOTE;
  return NULL;
}
 
static const char *next_token(const char *s, char *token, size_t *tokenlen, size_t tokenmax)
{
  if (*s == '(')
    return parse_comment(s + 1, token, tokenlen, tokenmax);
  if (*s == '"')
    return parse_quote(s + 1, token, tokenlen, tokenmax);
  if (*s && is_special(*s))
  {
    if (*tokenlen < tokenmax)
      token[(*tokenlen)++] = *s;
    return s + 1;
  }
  while (*s)
  {
    if (mutt_str_is_email_wsp(*s) || is_special(*s))
      break;
    if (*tokenlen < tokenmax)
      token[(*tokenlen)++] = *s;
    s++;
  }
  return s;
}
 
static const char *parse_mailboxdomain(const char *s, const char *nonspecial,
                                       char *mailbox, size_t *mailboxlen,
                                       size_t mailboxmax, char *comment,
                                       size_t *commentlen, size_t commentmax)
{
  const char *ps = NULL;
 
  while (*s)
  {
    s = mutt_str_skip_email_wsp(s);
    if ((*s == '\0'))
      return s;
 
    if (!strchr(nonspecial, *s) && is_special(*s))
      return s;
 
    if (*s == '(')
    {
      if (*commentlen && (*commentlen < commentmax))
        comment[(*commentlen)++] = ' ';
      ps = next_token(s, comment, commentlen, commentmax);
    }
    else
      ps = next_token(s, mailbox, mailboxlen, mailboxmax);
    if (!ps)
      return NULL;
    s = ps;
  }
 
  return s;
}
 
static const char *parse_address(const char *s, char *token, size_t *tokenlen,
                                 size_t tokenmax, char *comment, size_t *commentlen,
                                 size_t commentmax, struct Address *addr)
{
  s = parse_mailboxdomain(s, ".\"(\\", token, tokenlen, tokenmax, comment,
                          commentlen, commentmax);
  if (!s)
    return NULL;
 
  if (*s == '@')
  {
    if (*tokenlen < tokenmax)
      token[(*tokenlen)++] = '@';
    s = parse_mailboxdomain(s + 1, ".([]\\", token, tokenlen, tokenmax, comment,
                            commentlen, commentmax);
    if (!s)
      return NULL;
  }
 
  terminate_string(token, *tokenlen, tokenmax);
  addr->mailbox = mutt_str_dup(token);
 
  if (*commentlen && !addr->personal)
  {
    terminate_string(comment, *commentlen, commentmax);
    addr->personal = mutt_str_dup(comment);
  }
 
  return s;
}
 
static const char *parse_route_addr(const char *s, char *comment, size_t *commentlen,
                                    size_t commentmax, struct Address *addr)
{
  char token[1024] = { 0 };
  size_t tokenlen = 0;
 
  s = mutt_str_skip_email_wsp(s);
 
  /* find the end of the route */
  if (*s == '@')
  {
    while (s && (*s == '@'))
    {
      if (tokenlen < (sizeof(token) - 1))
        token[tokenlen++] = '@';
      s = parse_mailboxdomain(s + 1, ",.\\[](", token, &tokenlen,
                              sizeof(token) - 1, comment, commentlen, commentmax);
    }
    if (!s || (*s != ':'))
    {
      AddressError = ADDR_ERR_BAD_ROUTE;
      return NULL; /* invalid route */
    }
 
    if (tokenlen < (sizeof(token) - 1))
      token[tokenlen++] = ':';
    s++;
  }
 
  s = parse_address(s, token, &tokenlen, sizeof(token) - 1, comment, commentlen,
                    commentmax, addr);
  if (!s)
    return NULL;
 
  if (*s != '>')
  {
    AddressError = ADDR_ERR_BAD_ROUTE_ADDR;
    return NULL;
  }
 
  if (!addr->mailbox)
    addr->mailbox = mutt_str_dup("@");
 
  s++;
  return s;
}
 
static const char *parse_addr_spec(const char *s, char *comment, size_t *commentlen,
                                   size_t commentmax, struct Address *addr)
{
  char token[1024] = { 0 };
  size_t tokenlen = 0;
 
  s = parse_address(s, token, &tokenlen, sizeof(token) - 1, comment, commentlen,
                    commentmax, addr);
  if (s && *s && (*s != ',') && (*s != ';'))
  {
    AddressError = ADDR_ERR_BAD_ADDR_SPEC;
    return NULL;
  }
  return s;
}
 
static bool add_addrspec(struct AddressList *al, const char *phrase,
                         char *comment, size_t *commentlen, size_t commentmax)
{
  struct Address *cur = mutt_addr_new();
 
  if (!parse_addr_spec(phrase, comment, commentlen, commentmax, cur))
  {
    mutt_addr_free(&cur);
    return false;
  }
 
  mutt_addrlist_append(al, cur);
  return true;
}
 
struct Address *mutt_addr_new(void)
{
  return mutt_mem_calloc(1, sizeof(struct Address));
}
 
struct Address *mutt_addr_create(const char *personal, const char *mailbox)
{
  struct Address *a = mutt_addr_new();
  a->personal = mutt_str_dup(personal);
  a->mailbox = mutt_str_dup(mailbox);
  return a;
}
 
int mutt_addrlist_remove(struct AddressList *al, const char *mailbox)
{
  if (!al)
    return -1;
 
  if (!mailbox)
    return 0;
 
  int rc = -1;
  struct Address *a = NULL, *tmp = NULL;
  TAILQ_FOREACH_SAFE(a, al, entries, tmp)
  {
    if (mutt_istr_equal(mailbox, a->mailbox))
    {
      TAILQ_REMOVE(al, a, entries);
      mutt_addr_free(&a);
      rc = 0;
    }
  }
 
  return rc;
}
 
void mutt_addr_free(struct Address **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Address *a = *ptr;
 
  FREE(&a->personal);
  FREE(&a->mailbox);
  FREE(ptr);
}
 
int mutt_addrlist_parse(struct AddressList *al, const char *s)
{
  if (!s)
    return 0;
 
  int parsed = 0;
  char comment[1024], phrase[1024];
  size_t phraselen = 0, commentlen = 0;
  AddressError = 0;
 
  bool ws_pending = mutt_str_is_email_wsp(*s);
 
  s = mutt_str_skip_email_wsp(s);
  while (*s)
  {
    switch (*s)
    {
      case ';':
      case ',':
        if (phraselen != 0)
        {
          terminate_buffer(phrase, phraselen);
          if (add_addrspec(al, phrase, comment, &commentlen, sizeof(comment) - 1))
          {
            parsed++;
          }
        }
        else if (commentlen != 0)
        {
          struct Address *last = TAILQ_LAST(al, AddressList);
          if (last && !last->personal && last->mailbox)
          {
            terminate_buffer(comment, commentlen);
            last->personal = mutt_str_dup(comment);
          }
        }
 
        if (*s == ';')
        {
          /* add group terminator */
          mutt_addrlist_append(al, mutt_addr_new());
        }
 
        phraselen = 0;
        commentlen = 0;
        s++;
        break;
 
      case '(':
        if ((commentlen != 0) && (commentlen < (sizeof(comment) - 1)))
          comment[commentlen++] = ' ';
        s = next_token(s, comment, &commentlen, sizeof(comment) - 1);
        if (!s)
        {
          mutt_addrlist_clear(al);
          return 0;
        }
        break;
 
      case '"':
        if ((phraselen != 0) && (phraselen < (sizeof(phrase) - 1)))
          phrase[phraselen++] = ' ';
        s = parse_quote(s + 1, phrase, &phraselen, sizeof(phrase) - 1);
        if (!s)
        {
          mutt_addrlist_clear(al);
          return 0;
        }
        break;
 
      case ':':
      {
        struct Address *a = mutt_addr_new();
        terminate_buffer(phrase, phraselen);
        a->mailbox = mutt_str_dup(phrase);
        a->group = true;
        mutt_addrlist_append(al, a);
        phraselen = 0;
        commentlen = 0;
        s++;
        break;
      }
 
      case '<':
      {
        struct Address *a = mutt_addr_new();
        terminate_buffer(phrase, phraselen);
        a->personal = mutt_str_dup(phrase);
        s = parse_route_addr(s + 1, comment, &commentlen, sizeof(comment) - 1, a);
        if (!s)
        {
          mutt_addrlist_clear(al);
          mutt_addr_free(&a);
          return 0;
        }
        mutt_addrlist_append(al, a);
        phraselen = 0;
        commentlen = 0;
        parsed++;
        break;
      }
 
      default:
        if ((phraselen != 0) && (phraselen < (sizeof(phrase) - 1)) && ws_pending)
          phrase[phraselen++] = ' ';
        if (*s == '\\')
        {
          s++;
          if (*s && (phraselen < (sizeof(phrase) - 1)))
          {
            phrase[phraselen++] = *s;
            s++;
          }
        }
        s = next_token(s, phrase, &phraselen, sizeof(phrase) - 1);
        if (!s)
        {
          mutt_addrlist_clear(al);
          return 0;
        }
        break;
    } // switch (*s)
 
    ws_pending = mutt_str_is_email_wsp(*s);
    s = mutt_str_skip_email_wsp(s);
  } // while (*s)
 
  if (phraselen != 0)
  {
    terminate_buffer(phrase, phraselen);
    terminate_buffer(comment, commentlen);
    if (add_addrspec(al, phrase, comment, &commentlen, sizeof(comment) - 1))
    {
      parsed++;
    }
  }
  else if (commentlen != 0)
  {
    struct Address *last = TAILQ_LAST(al, AddressList);
    if (last && !last->personal && last->mailbox)
    {
      terminate_buffer(comment, commentlen);
      last->personal = mutt_str_dup(comment);
    }
  }
 
  return parsed;
}
 
int mutt_addrlist_parse2(struct AddressList *al, const char *s)
{
  if (!s || (*s == '\0'))
    return 0;
 
  int parsed = 0;
 
  /* check for a simple whitespace separated list of addresses */
  if (!strpbrk(s, "\"<>():;,\\"))
  {
    char *copy = mutt_str_dup(s);
    char *r = copy;
    while ((r = strtok(r, " \t")))
    {
      parsed += mutt_addrlist_parse(al, r);
      r = NULL;
    }
    FREE(&copy);
  }
  else
    parsed = mutt_addrlist_parse(al, s);
 
  return parsed;
}
 
void mutt_addrlist_qualify(struct AddressList *al, const char *host)
{
  if (!al || !host || (*host == '\0'))
    return;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    if (!a->group && a->mailbox && !strchr(a->mailbox, '@'))
    {
      char *p = mutt_mem_malloc(mutt_str_len(a->mailbox) + mutt_str_len(host) + 2);
      sprintf(p, "%s@%s", a->mailbox, host);
      FREE(&a->mailbox);
      a->mailbox = p;
    }
  }
}
 
void mutt_addr_cat(char *buf, size_t buflen, const char *value, const char *specials)
{
  if (!buf || !value || !specials)
    return;
 
  if (strpbrk(value, specials))
  {
    char tmp[256] = { 0 };
    char *pc = tmp;
    size_t tmplen = sizeof(tmp) - 3;
 
    *pc++ = '"';
    for (; *value && (tmplen > 1); value++)
    {
      if ((*value == '\\') || (*value == '"'))
      {
        *pc++ = '\\';
        tmplen--;
      }
      *pc++ = *value;
      tmplen--;
    }
    *pc++ = '"';
    *pc = '\0';
    mutt_str_copy(buf, tmp, buflen);
  }
  else
    mutt_str_copy(buf, value, buflen);
}
 
struct Address *mutt_addr_copy(const struct Address *addr)
{
  if (!addr)
    return NULL;
 
  struct Address *p = mutt_addr_new();
 
  p->personal = mutt_str_dup(addr->personal);
  p->mailbox = mutt_str_dup(addr->mailbox);
  p->group = addr->group;
  p->is_intl = addr->is_intl;
  p->intl_checked = addr->intl_checked;
  return p;
}
 
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
{
  if (!dst || !src)
    return;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, src, entries)
  {
    struct Address *next = TAILQ_NEXT(a, entries);
    if (prune && a->group && (!next || !next->mailbox))
    {
      /* ignore this element of the list */
    }
    else
    {
      mutt_addrlist_append(dst, mutt_addr_copy(a));
    }
  }
}
 
bool mutt_addr_valid_msgid(const char *msgid)
{
  /* msg-id         = "<" addr-spec ">"
   * addr-spec      = local-part "@" domain
   * local-part     = word *("." word)
   * word           = atom / quoted-string
   * atom           = 1*<any CHAR except specials, SPACE and CTLs>
   * CHAR           = ( 0.-127. )
   * specials       = "(" / ")" / "<" / ">" / "@"
   *                / "," / ";" / ":" / "\" / <">
   *                / "." / "[" / "]"
   * SPACE          = ( 32. )
   * CTLS           = ( 0.-31., 127.)
   * quoted-string  = <"> *(qtext/quoted-pair) <">
   * qtext          = <any CHAR except <">, "\" and CR>
   * CR             = ( 13. )
   * quoted-pair    = "\" CHAR
   * domain         = sub-domain *("." sub-domain)
   * sub-domain     = domain-ref / domain-literal
   * domain-ref     = atom
   * domain-literal = "[" *(dtext / quoted-pair) "]"
   */
 
  if (!msgid || (*msgid == '\0'))
    return false;
 
  size_t l = mutt_str_len(msgid);
  if (l < 5) /* <atom@atom> */
    return false;
  if ((msgid[0] != '<') || (msgid[l - 1] != '>'))
    return false;
  if (!(strrchr(msgid, '@')))
    return false;
 
  /* TODO: complete parser */
  for (size_t i = 0; i < l; i++)
    if ((unsigned char) msgid[i] > 127)
      return false;
 
  return true;
}
 
bool mutt_addrlist_equal(const struct AddressList *ala, const struct AddressList *alb)
{
  if (!ala || !alb)
  {
    return !(ala || alb);
  }
 
  struct Address *ana = TAILQ_FIRST(ala);
  struct Address *anb = TAILQ_FIRST(alb);
 
  while (ana && anb)
  {
    if (!mutt_str_equal(ana->mailbox, anb->mailbox) ||
        !mutt_str_equal(ana->personal, anb->personal))
    {
      break;
    }
 
    ana = TAILQ_NEXT(ana, entries);
    anb = TAILQ_NEXT(anb, entries);
  }
 
  return !(ana || anb);
}
 
int mutt_addrlist_count_recips(const struct AddressList *al)
{
  if (!al)
    return 0;
 
  int c = 0;
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    c += (a->mailbox && !a->group);
  }
  return c;
}
 
bool mutt_addr_cmp(const struct Address *a, const struct Address *b)
{
  if (!a || !b)
    return false;
  if (!a->mailbox || !b->mailbox)
    return false;
  if (!mutt_istr_equal(a->mailbox, b->mailbox))
    return false;
  return true;
}
 
bool mutt_addrlist_search(const struct AddressList *haystack, const struct Address *needle)
{
  if (!needle || !haystack)
    return false;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, haystack, entries)
  {
    if (mutt_addr_cmp(needle, a))
      return true;
  }
  return false;
}
 
static bool addr_is_intl(const struct Address *a)
{
  if (!a)
    return false;
  return a->intl_checked && a->is_intl;
}
 
static bool addr_is_local(const struct Address *a)
{
  if (!a)
    return false;
  return a->intl_checked && !a->is_intl;
}
 
static int addr_mbox_to_udomain(const char *mbox, char **user, char **domain)
{
  if (!mbox || !user || !domain)
    return -1;
 
  char *ptr = strchr(mbox, '@');
 
  /* Fail if '@' is missing, at the start, or at the end */
  if (!ptr || (ptr == mbox) || (ptr[1] == '\0'))
    return -1;
 
  *user = mutt_strn_dup(mbox, ptr - mbox);
  *domain = mutt_str_dup(ptr + 1);
 
  return 0;
}
 
static void addr_set_intl(struct Address *a, char *intl_mailbox)
{
  if (!a)
    return;
 
  FREE(&a->mailbox);
  a->mailbox = intl_mailbox;
  a->intl_checked = true;
  a->is_intl = true;
}
 
static void addr_set_local(struct Address *a, char *local_mailbox)
{
  if (!a)
    return;
 
  FREE(&a->mailbox);
  a->mailbox = local_mailbox;
  a->intl_checked = true;
  a->is_intl = false;
}
 
const char *mutt_addr_for_display(const struct Address *a)
{
  if (!a)
    return NULL;
 
  char *user = NULL, *domain = NULL;
  static char *buf = NULL;
 
  if (!a->mailbox || addr_is_local(a))
    return a->mailbox;
 
  if (addr_mbox_to_udomain(a->mailbox, &user, &domain) == -1)
    return a->mailbox;
 
  char *local_mailbox = mutt_idna_intl_to_local(user, domain, MI_MAY_BE_IRREVERSIBLE);
 
  FREE(&user);
  FREE(&domain);
 
  if (!local_mailbox)
    return a->mailbox;
 
  mutt_str_replace(&buf, local_mailbox);
  FREE(&local_mailbox);
 
  return buf;
}
 
size_t mutt_addr_write(struct Buffer *buf, struct Address *addr, bool display)
{
  if (!buf || !addr || (!addr->personal && !addr->mailbox))
  {
    return 0;
  }
 
  const size_t initial_len = mutt_buffer_len(buf);
 
  if (addr->personal)
  {
    if (strpbrk(addr->personal, AddressSpecials))
    {
      mutt_buffer_addch(buf, '"');
      for (const char *pc = addr->personal; *pc; pc++)
      {
        if ((*pc == '"') || (*pc == '\\'))
        {
          mutt_buffer_addch(buf, '\\');
        }
        mutt_buffer_addch(buf, *pc);
      }
      mutt_buffer_addch(buf, '"');
    }
    else
    {
      mutt_buffer_addstr(buf, addr->personal);
    }
 
    mutt_buffer_addch(buf, ' ');
  }
 
  if (addr->personal || (addr->mailbox && (*addr->mailbox == '@')))
  {
    mutt_buffer_addch(buf, '<');
  }
 
  if (addr->mailbox)
  {
    if (!mutt_str_equal(addr->mailbox, "@"))
    {
      const char *a = display ? mutt_addr_for_display(addr) : addr->mailbox;
      mutt_buffer_addstr(buf, a);
    }
 
    if (addr->personal || (addr->mailbox && (*addr->mailbox == '@')))
    {
      mutt_buffer_addch(buf, '>');
    }
 
    if (addr->group)
    {
      mutt_buffer_addstr(buf, ": ");
    }
  }
  else
  {
    mutt_buffer_addch(buf, ';');
  }
 
  return mutt_buffer_len(buf) - initial_len;
}
 
size_t addrlist_write(const struct AddressList *al, struct Buffer *buf,
                      bool display, const char *header, int cols)
{
  if (!buf || !al || TAILQ_EMPTY(al))
    return 0;
 
  if (header)
  {
    mutt_buffer_printf(buf, "%s: ", header);
  }
 
  size_t cur_col = mutt_buffer_len(buf);
  bool in_group = false;
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    struct Address *next = TAILQ_NEXT(a, entries);
 
    if (a->group)
    {
      in_group = true;
    }
 
    // wrap if needed
    const size_t cur_len = mutt_buffer_len(buf);
    cur_col += mutt_addr_write(buf, a, display);
    if (cur_col > cols)
    {
      mutt_buffer_insert(buf, cur_len, "\n\t");
      cur_col = 8;
    }
 
    if (!a->group)
    {
      // group terminator
      if (in_group && !a->mailbox && !a->personal)
      {
        mutt_buffer_addch(buf, ';');
        ++cur_col;
        in_group = false;
      }
      if (next && (next->mailbox || next->personal))
      {
        mutt_buffer_addstr(buf, ", ");
        cur_col += 2;
      }
      if (!next)
      {
        break;
      }
    }
  }
 
  return mutt_buffer_len(buf);
}
 
size_t mutt_addrlist_write_wrap(const struct AddressList *al,
                                struct Buffer *buf, const char *header)
{
  return addrlist_write(al, buf, false, header, 74);
}
 
size_t mutt_addrlist_write(const struct AddressList *al, struct Buffer *buf, bool display)
{
  return addrlist_write(al, buf, display, NULL, -1);
}
 
size_t mutt_addrlist_write_list(const struct AddressList *al, struct ListHead *list)
{
  if (!al || !list)
    return 0;
 
  size_t count = 0;
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    struct Buffer buf = { 0 };
    mutt_addr_write(&buf, a, true);
    if (!mutt_buffer_is_empty(&buf))
    {
      /* We're taking the ownership of the buffer string here */
      mutt_list_insert_tail(list, (char *) mutt_buffer_string(&buf));
      count++;
    }
  }
 
  return count;
}
 
void mutt_addrlist_write_file(const struct AddressList *al, FILE *fp, const char *header)
{
  struct Buffer *buf = mutt_buffer_pool_get();
  mutt_addrlist_write_wrap(al, buf, header);
  fputs(mutt_buffer_string(buf), fp);
  mutt_buffer_pool_release(&buf);
  fputc('\n', fp);
}
 
bool mutt_addr_to_intl(struct Address *a)
{
  if (!a || !a->mailbox || addr_is_intl(a))
    return true;
 
  char *user = NULL;
  char *domain = NULL;
  if (addr_mbox_to_udomain(a->mailbox, &user, &domain) == -1)
    return true;
 
  char *intl_mailbox = mutt_idna_local_to_intl(user, domain);
 
  FREE(&user);
  FREE(&domain);
 
  if (!intl_mailbox)
    return false;
 
  addr_set_intl(a, intl_mailbox);
  return true;
}
 
int mutt_addrlist_to_intl(struct AddressList *al, char **err)
{
  if (!al)
    return 0;
 
  int rc = 0;
 
  if (err)
    *err = NULL;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    if (!a->mailbox || addr_is_intl(a))
      continue;
 
    char *user = NULL;
    char *domain = NULL;
    if (addr_mbox_to_udomain(a->mailbox, &user, &domain) == -1)
      continue;
 
    char *intl_mailbox = mutt_idna_local_to_intl(user, domain);
 
    FREE(&user);
    FREE(&domain);
 
    if (!intl_mailbox)
    {
      rc = -1;
      if (err && !*err)
        *err = mutt_str_dup(a->mailbox);
      continue;
    }
 
    addr_set_intl(a, intl_mailbox);
  }
 
  return rc;
}
 
bool mutt_addr_to_local(struct Address *a)
{
  if (!a->mailbox)
  {
    return false;
  }
 
  if (addr_is_local(a))
  {
    return true;
  }
 
  char *user = NULL;
  char *domain = NULL;
  if (addr_mbox_to_udomain(a->mailbox, &user, &domain) == -1)
  {
    return false;
  }
 
  char *local_mailbox = mutt_idna_intl_to_local(user, domain, MI_NO_FLAGS);
  FREE(&user);
  FREE(&domain);
 
  if (!local_mailbox)
  {
    return false;
  }
 
  addr_set_local(a, local_mailbox);
  return true;
}
 
int mutt_addrlist_to_local(struct AddressList *al)
{
  if (!al)
    return 0;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    mutt_addr_to_local(a);
  }
  return 0;
}
 
void mutt_addrlist_dedupe(struct AddressList *al)
{
  if (!al)
    return;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    if (a->mailbox)
    {
      struct Address *a2 = TAILQ_NEXT(a, entries);
      struct Address *tmp = NULL;
 
      if (a2)
      {
        TAILQ_FOREACH_FROM_SAFE(a2, al, entries, tmp)
        {
          if (a2->mailbox && mutt_istr_equal(a->mailbox, a2->mailbox))
          {
            mutt_debug(LL_DEBUG2, "Removing %s\n", a2->mailbox);
            TAILQ_REMOVE(al, a2, entries);
            mutt_addr_free(&a2);
          }
        }
      }
    }
  }
}
 
void mutt_addrlist_remove_xrefs(const struct AddressList *a, struct AddressList *b)
{
  if (!a || !b)
    return;
 
  struct Address *aa = NULL, *ab = NULL, *tmp = NULL;
 
  TAILQ_FOREACH_SAFE(ab, b, entries, tmp)
  {
    TAILQ_FOREACH(aa, a, entries)
    {
      if (mutt_addr_cmp(aa, ab))
      {
        TAILQ_REMOVE(b, ab, entries);
        mutt_addr_free(&ab);
        break;
      }
    }
  }
}
 
void mutt_addrlist_clear(struct AddressList *al)
{
  if (!al)
    return;
 
  struct Address *a = TAILQ_FIRST(al), *next = NULL;
  while (a)
  {
    next = TAILQ_NEXT(a, entries);
    mutt_addr_free(&a);
    a = next;
  }
  TAILQ_INIT(al);
}
 
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
{
  if (al && a)
    TAILQ_INSERT_TAIL(al, a, entries);
}
 
void mutt_addrlist_prepend(struct AddressList *al, struct Address *a)
{
  if (al && a)
    TAILQ_INSERT_HEAD(al, a, entries);
}
 
bool mutt_addr_uses_unicode(const char *str)
{
  if (!str)
    return false;
 
  while (*str)
  {
    if ((unsigned char) *str & (1 << 7))
      return true;
    str++;
  }
 
  return false;
}
 
bool mutt_addrlist_uses_unicode(const struct AddressList *al)
{
  if (!al)
  {
    return false;
  }
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    if (a->mailbox && !a->group && mutt_addr_uses_unicode(a->mailbox))
      return true;
  }
  return false;
}