address.h File Reference

Representation of an email address. More...

#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"

Include dependency graph for address.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Address
	An email address. More...

Typedefs
typedef bool(*	addr_predicate_t) (const struct Address *a)

Functions
	TAILQ_HEAD (AddressList, Address)
void	mutt_addr_cat (char *buf, size_t buflen, const char *value, const char *specials)
	Copy a string and wrap it in quotes if it contains special characters.
bool	mutt_addr_valid_msgid (const char *msgid)
	Is this a valid Message ID?
bool	mutt_addr_cmp (const struct Address *a, const struct Address *b)
	Compare two e-mail addresses.
struct Address *	mutt_addr_copy (const struct Address *addr)
	Copy the real address.
struct Address *	mutt_addr_create (const char *personal, const char *mailbox)
	Create and populate a new Address.
const char *	mutt_addr_for_display (const struct Address *a)
	Convert an Address for display purposes.
void	mutt_addr_free (struct Address **ptr)
	Free a single Address.
struct Address *	mutt_addr_new (void)
	Create a new Address.
bool	mutt_addr_to_intl (struct Address *a)
	Convert an Address to Punycode.
bool	mutt_addr_to_local (struct Address *a)
	Convert an Address from Punycode.
bool	mutt_addr_uses_unicode (const char *str)
	Does this address use Unicode character.
size_t	mutt_addr_write (struct Buffer *buf, struct Address *addr, bool display)
	Write a single Address to a buffer.
void	mutt_addrlist_append (struct AddressList *al, struct Address *a)
	Append an Address to an AddressList.
void	mutt_addrlist_clear (struct AddressList *al)
	Unlink and free all Address in an AddressList.
void	mutt_addrlist_copy (struct AddressList *dst, const struct AddressList *src, bool prune)
	Copy a list of addresses into another list.
int	mutt_addrlist_count_recips (const struct AddressList *al)
	Count the number of Addresses with valid recipients.
void	mutt_addrlist_dedupe (struct AddressList *al)
	Remove duplicate addresses.
bool	mutt_addrlist_equal (const struct AddressList *ala, const struct AddressList *alb)
	Compare two Address lists for equality.
int	mutt_addrlist_parse (struct AddressList *al, const char *s)
	Parse a list of email addresses.
int	mutt_addrlist_parse2 (struct AddressList *al, const char *s)
	Parse a list of email addresses.
void	mutt_addrlist_prepend (struct AddressList *al, struct Address *a)
	Prepend an Address to an AddressList.
void	mutt_addrlist_qualify (struct AddressList *al, const char *host)
	Expand local names in an Address list using a hostname.
int	mutt_addrlist_remove (struct AddressList *al, const char *mailbox)
	Remove an Address from a list.
void	mutt_addrlist_remove_xrefs (const struct AddressList *a, struct AddressList *b)
	Remove cross-references.
bool	mutt_addrlist_search (const struct AddressList *haystack, const struct Address *needle)
	Search for an e-mail address in a list.
int	mutt_addrlist_to_intl (struct AddressList *al, char **err)
	Convert an Address list to Punycode.
int	mutt_addrlist_to_local (struct AddressList *al)
	Convert an Address list from Punycode.
bool	mutt_addrlist_uses_unicode (const struct AddressList *al)
	Do any of a list of addresses use Unicode characters.
size_t	mutt_addrlist_write (const struct AddressList *al, struct Buffer *buf, bool display)
	Write an Address to a buffer.
size_t	mutt_addrlist_write_wrap (const struct AddressList *al, struct Buffer *buf, const char *header)
	Write an AddressList to a buffer, perform line wrapping.
void	mutt_addrlist_write_file (const struct AddressList *al, FILE *fp, const char *header)
	Wrapper for mutt_write_address().
size_t	mutt_addrlist_write_list (const struct AddressList *al, struct ListHead *list)
	Write Addresses to a List.

Variables
const char	AddressSpecials []
	Characters with special meaning for email addresses.

Detailed Description

Representation of an email address.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file address.h.

Typedef Documentation

addr_predicate_t

typedef bool(* addr_predicate_t) (const struct Address *a)

Definition at line 55 of file address.h.

Function Documentation

TAILQ_HEAD()

TAILQ_HEAD	(	AddressList	,
		Address	)

mutt_addr_cat()

void mutt_addr_cat	(	char *	buf,
		size_t	buflen,
		const char *	value,
		const char *	specials )

Copy a string and wrap it in quotes if it contains special characters.

Parameters

buf	Buffer for the result
buflen	Length of the result buffer
value	String to copy
specials	Characters to lookup

This function copies the string in the "value" parameter in the buffer pointed to by "buf" parameter. If the input string contains any of the characters specified in the "specials" parameters, the output string is wrapped in double quoted. Additionally, any backslashes or quotes inside the input string are backslash-escaped.

Definition at line 715 of file address.c.

{
  if (!buf || !value || !specials)
    return;
 
  if (strpbrk(value, specials))
  {
    if (buflen < 4)
    {
      mutt_str_copy(buf, value, buflen);
      return;
    }
 
    char *pc = buf;
    size_t remaining = buflen - 3; // Reserve for opening quote, closing quote, NUL
 
    *pc++ = '"';
    for (; *value && (remaining > 1); value++)
    {
      if ((*value == '\\') || (*value == '"'))
      {
        *pc++ = '\\';
        remaining--;
      }
      *pc++ = *value;
      remaining--;
    }
    *pc++ = '"';
    *pc = '\0';
  }
  else
  {
    mutt_str_copy(buf, value, buflen);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_valid_msgid()

bool mutt_addr_valid_msgid

(

const char *

msgid

)

Is this a valid Message ID?

Parameters

msgid

Message ID

Return values

true	It is a valid message ID

Incomplete. Only used to thwart the APOP MD5 attack

Definition at line 803 of file address.c.

{
  /* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_cmp()

bool mutt_addr_cmp	(	const struct Address *	a,
		const struct Address *	b )

Compare two e-mail addresses.

Parameters

a	Address 1
b	Address 2

Return values

true	They are equivalent

Definition at line 903 of file address.c.

{
  if (!a || !b)
    return false;
  if (!a->mailbox || !b->mailbox)
    return false;
  if (!buf_istr_equal(a->mailbox, b->mailbox))
    return false;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_copy()

struct Address * mutt_addr_copy

(

const struct Address *

addr

)

Copy the real address.

Parameters

addr	Address to copy

Return values

ptr	New Address

Definition at line 756 of file address.c.

{
  if (!addr)
    return NULL;
 
  struct Address *p = mutt_addr_new();
  p->personal = buf_dup(addr->personal);
  p->mailbox = buf_dup(addr->mailbox);
  p->group = addr->group;
  p->is_intl = addr->is_intl;
  p->intl_checked = addr->intl_checked;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_create()

struct Address * mutt_addr_create	(	const char *	personal,
		const char *	mailbox )

Create and populate a new Address.

Parameters

[in]	personal	The personal name for the Address (can be NULL)
[in]	mailbox	The mailbox for the Address (can be NULL)

Return values

ptr	Newly allocated Address

Note

The personal and mailbox values, if not NULL, are going to be copied into the newly allocated Address.

Definition at line 414 of file address.c.

{
  struct Address *a = mutt_addr_new();
  if (personal)
  {
    a->personal = buf_new(personal);
  }
  if (mailbox)
  {
    a->mailbox = buf_new(mailbox);
  }
  return a;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_for_display()

const char * mutt_addr_for_display

(

const struct Address *

a

)

Convert an Address for display purposes.

Parameters

a	Address to convert

Return values

ptr	Address to display

Warning

This function may return a static pointer. It must not be freed by the caller. Later calls may overwrite the returned pointer.

Definition at line 1023 of file address.c.

{
  if (!a)
    return NULL;
 
  char *user = NULL;
  char *domain = NULL;
  static char *buf = NULL;
 
  if (!a->mailbox || addr_is_local(a))
    return buf_string(a->mailbox);
 
  if (addr_mbox_to_udomain(buf_string(a->mailbox), &user, &domain) == -1)
    return buf_string(a->mailbox);
 
  char *local_mailbox = mutt_idna_intl_to_local(user, domain, MI_MAY_BE_IRREVERSIBLE);
 
  FREE(&user);
  FREE(&domain);
 
  if (!local_mailbox)
    return buf_string(a->mailbox);
 
  mutt_str_replace(&buf, local_mailbox);
  FREE(&local_mailbox);
 
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_free()

void mutt_addr_free

(

struct Address **

ptr

)

Free a single Address.

Parameters

[out]

ptr

Address to free

Definition at line 463 of file address.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct Address *a = *ptr;
 
  buf_free(&a->personal);
  buf_free(&a->mailbox);
  FREE(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_new()

struct Address * mutt_addr_new

(

void

)

Create a new Address.

Return values

ptr	Newly allocated Address

Free the result with mutt_addr_free()

Definition at line 401 of file address.c.

{
  return MUTT_MEM_CALLOC(1, struct Address);
}

Here is the caller graph for this function:

mutt_addr_to_intl()

bool mutt_addr_to_intl

(

struct Address *

a

)

Convert an Address to Punycode.

Parameters

a	Address to convert

Return values

true	Success
false	Otherwise

Definition at line 1274 of file address.c.

{
  if (!a || !a->mailbox || addr_is_intl(a))
    return true;
 
  char *user = NULL;
  char *domain = NULL;
  if (addr_mbox_to_udomain(buf_string(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);
  FREE(&intl_mailbox);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_to_local()

bool mutt_addr_to_local

(

struct Address *

a

)

Convert an Address from Punycode.

Parameters

a	Address to convert

Return values

true	Success
false	Otherwise

Definition at line 1351 of file address.c.

{
  if (!a || !a->mailbox)
  {
    return false;
  }
 
  if (addr_is_local(a))
  {
    return true;
  }
 
  char *user = NULL;
  char *domain = NULL;
  if (addr_mbox_to_udomain(buf_string(a->mailbox), &user, &domain) == -1)
  {
    return false;
  }
 
  char *local_mailbox = mutt_idna_intl_to_local(user, domain, MI_NONE);
  FREE(&user);
  FREE(&domain);
 
  if (!local_mailbox)
  {
    return false;
  }
 
  addr_set_local(a, local_mailbox);
  FREE(&local_mailbox);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_uses_unicode()

bool mutt_addr_uses_unicode

(

const char *

str

)

Does this address use Unicode character.

Parameters

str	Address string to check

Return values

true	The string uses 8-bit characters

Definition at line 1516 of file address.c.

{
  if (!str)
    return false;
 
  while (*str)
  {
    if ((unsigned char) *str & (1 << 7))
      return true;
    str++;
  }
 
  return false;
}

Here is the caller graph for this function:

mutt_addr_write()

size_t mutt_addr_write	(	struct Buffer *	buf,
		struct Address *	addr,
		bool	display )

Write a single Address to a buffer.

Parameters

buf	Buffer for the Address
addr	Address to display
display	This address will be displayed to the user

Return values

num	Length of the string written to buf

If 'display' is set, then it doesn't matter if the transformation isn't reversible.

Definition at line 1062 of file address.c.

{
  if (!buf || !addr || (!addr->personal && !addr->mailbox))
  {
    return 0;
  }
 
  const size_t initial_len = buf_len(buf);
 
  if (addr->personal)
  {
    if (strpbrk(buf_string(addr->personal), AddressSpecials) ||
        mutt_addr_uses_unicode(buf_string(addr->personal)))
    {
      buf_addch(buf, '"');
      for (const char *pc = buf_string(addr->personal); *pc; pc++)
      {
        if ((*pc == '"') || (*pc == '\\'))
        {
          buf_addch(buf, '\\');
        }
        buf_addch(buf, *pc);
      }
      buf_addch(buf, '"');
    }
    else
    {
      buf_addstr(buf, buf_string(addr->personal));
    }
 
    buf_addch(buf, ' ');
  }
 
  if (addr->personal || (addr->mailbox && (buf_at(addr->mailbox, 0) == '@')))
  {
    buf_addch(buf, '<');
  }
 
  if (addr->mailbox)
  {
    if (!mutt_str_equal(buf_string(addr->mailbox), "@"))
    {
      const char *a = display ? mutt_addr_for_display(addr) : buf_string(addr->mailbox);
      buf_addstr(buf, a);
    }
 
    if (addr->personal || (addr->mailbox && (buf_at(addr->mailbox, 0) == '@')))
    {
      buf_addch(buf, '>');
    }
 
    if (addr->group)
    {
      buf_addstr(buf, ": ");
    }
  }
  else
  {
    buf_addch(buf, ';');
  }
 
  return buf_len(buf) - initial_len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_append()

void mutt_addrlist_append	(	struct AddressList *	al,
		struct Address *	a )

Append an Address to an AddressList.

Parameters

al	AddressList
a	Address

Definition at line 1494 of file address.c.

{
  if (al && a)
    TAILQ_INSERT_TAIL(al, a, entries);
}

Here is the caller graph for this function:

mutt_addrlist_clear()

void mutt_addrlist_clear

(

struct AddressList *

al

)

Unlink and free all Address in an AddressList.

Parameters

al	AddressList

Note

After this call, the AddressList is reinitialized and ready for reuse.

Definition at line 1473 of file address.c.

{
  if (!al)
    return;
 
  struct Address *a = TAILQ_FIRST(al);
  struct Address *next = NULL;
  while (a)
  {
    next = TAILQ_NEXT(a, entries);
    mutt_addr_free(&a);
    a = next;
  }
  TAILQ_INIT(al);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_copy()

void mutt_addrlist_copy	(	struct AddressList *	dst,
		const struct AddressList *	src,
		bool	prune )

Copy a list of addresses into another list.

Parameters

dst	Destination Address list
src	Source Address list
prune	Skip groups if there are more addresses

Definition at line 776 of file address.c.

{
  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));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_count_recips()

int mutt_addrlist_count_recips

(

const struct AddressList *

al

)

Count the number of Addresses with valid recipients.

Parameters

al	Address list

Return values

num	Number of valid Addresses

An Address has a recipient if the mailbox is set and is not a group

Definition at line 883 of file address.c.

{
  if (!al)
    return 0;
 
  int c = 0;
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    c += (a->mailbox && !a->group);
  }
  return c;
}

Here is the caller graph for this function:

mutt_addrlist_dedupe()

void mutt_addrlist_dedupe

(

struct AddressList *

al

)

Remove duplicate addresses.

Parameters

al	Address list to de-dupe

Given a list of addresses, return a list of unique addresses

Definition at line 1408 of file address.c.

{
  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 && buf_istr_equal(a->mailbox, a2->mailbox))
          {
            mutt_debug(LL_DEBUG2, "Removing %s\n", buf_string(a2->mailbox));
            TAILQ_REMOVE(al, a2, entries);
            mutt_addr_free(&a2);
          }
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_equal()

bool mutt_addrlist_equal	(	const struct AddressList *	ala,
		const struct AddressList *	alb )

Compare two Address lists for equality.

Parameters

ala	First Address
alb	Second Address

Return values

true	Address lists are strictly identical

Definition at line 851 of file address.c.

{
  if (!ala || !alb)
  {
    return !(ala || alb);
  }
 
  struct Address *ana = TAILQ_FIRST(ala);
  struct Address *anb = TAILQ_FIRST(alb);
 
  while (ana && anb)
  {
    if (!buf_str_equal(ana->mailbox, anb->mailbox) ||
        !buf_str_equal(ana->personal, anb->personal))
    {
      break;
    }
 
    ana = TAILQ_NEXT(ana, entries);
    anb = TAILQ_NEXT(anb, entries);
  }
 
  return !(ana || anb);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_parse()

int mutt_addrlist_parse	(	struct AddressList *	al,
		const char *	s )

Parse a list of email addresses.

Parameters

al	AddressList to append addresses
s	String to parse

Return values

num	Number of parsed addresses

Definition at line 481 of file address.c.

{
  if (!s)
    return 0;
 
  int parsed = 0;
  char comment[1024] = { 0 };
  char phrase[1024] = { 0 };
  size_t phraselen = 0;
  size_t commentlen = 0;
 
  bool ws_pending = mutt_str_is_email_wsp(*s);
 
  /* Parse the address string character by character, handling RFC 2822
   * constructs: quoted strings, comments, route-addr, group syntax */
  s = mutt_str_skip_email_wsp(s);
  while (*s)
  {
    switch (*s)
    {
      case ';':
      case ',':
        /* Address separator: convert accumulated phrase into an address */
        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 && !buf_is_empty(last->mailbox))
          {
            terminate_buffer(comment, commentlen);
            last->personal = buf_new(comment);
          }
        }
 
        if (*s == ';')
        {
          /* add group terminator */
          mutt_addrlist_append(al, mutt_addr_new());
        }
 
        phraselen = 0;
        commentlen = 0;
        s++;
        break;
 
      case '(':
        /* RFC 822 comment in parentheses */
        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);
        if (phraselen != 0)
        {
          a->mailbox = buf_new(phrase);
        }
        a->group = true;
        mutt_addrlist_append(al, a);
        phraselen = 0;
        commentlen = 0;
        s++;
        break;
      }
 
      case '<':
      {
        /* Route-addr: phrase before '<' becomes personal name */
        struct Address *a = mutt_addr_new();
        terminate_buffer(phrase, phraselen);
        if (phraselen != 0)
        {
          a->personal = buf_new(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 && !buf_is_empty(last->mailbox))
    {
      terminate_buffer(comment, commentlen);
      last->personal = buf_new(comment);
    }
  }
 
  return parsed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_parse2()

int mutt_addrlist_parse2	(	struct AddressList *	al,
		const char *	s )

Parse a list of email addresses.

Parameters

al	Add to this List of Addresses
s	String to parse

Return values

num	Number of parsed addresses

Simple email addresses (without any personal name or grouping) can be separated by whitespace or commas.

Definition at line 651 of file address.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_prepend()

void mutt_addrlist_prepend	(	struct AddressList *	al,
		struct Address *	a )

Prepend an Address to an AddressList.

Parameters

al	AddressList
a	Address

Definition at line 1505 of file address.c.

{
  if (al && a)
    TAILQ_INSERT_HEAD(al, a, entries);
}

Here is the caller graph for this function:

mutt_addrlist_qualify()

void mutt_addrlist_qualify	(	struct AddressList *	al,
		const char *	host )

Expand local names in an Address list using a hostname.

Parameters

al	Address list
host	Hostname

Any addresses containing a bare name will be expanded using the hostname. e.g. "john", "example.com" -> 'john@.nosp@m.exam.nosp@m.ple.c.nosp@m.om'. This function has no effect if host is NULL or the empty string.

Definition at line 687 of file address.c.

{
  if (!al || !host || (*host == '\0'))
    return;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    if (!a->group && a->mailbox && !buf_find_char(a->mailbox, '@'))
    {
      buf_add_printf(a->mailbox, "@%s", host);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_remove()

int mutt_addrlist_remove	(	struct AddressList *	al,
		const char *	mailbox )

Remove an Address from a list.

Parameters

[in,out]	al	AddressList
[in]	mailbox	Email address to match

Return values

0	Success
-1	Error, or email not found

Definition at line 435 of file address.c.

{
  if (!al)
    return -1;
 
  if (!mailbox)
    return 0;
 
  int rc = -1;
  struct Address *a = NULL;
  struct Address *tmp = NULL;
  TAILQ_FOREACH_SAFE(a, al, entries, tmp)
  {
    if (mutt_istr_equal(mailbox, buf_string(a->mailbox)))
    {
      TAILQ_REMOVE(al, a, entries);
      mutt_addr_free(&a);
      rc = 0;
    }
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_remove_xrefs()

void mutt_addrlist_remove_xrefs	(	const struct AddressList *	a,
		struct AddressList *	b )

Remove cross-references.

Parameters

a	Reference AddressList
b	AddressLis to trim

Remove addresses from "b" which are contained in "a"

Definition at line 1444 of file address.c.

{
  if (!a || !b)
    return;
 
  struct Address *aa = NULL;
  struct Address *ab = NULL;
  struct Address *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;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_search()

bool mutt_addrlist_search	(	const struct AddressList *	haystack,
		const struct Address *	needle )

Search for an e-mail address in a list.

Parameters

haystack	Address List
needle	Address containing the search email

Return values

true	The Address is in the list

Definition at line 920 of file address.c.

{
  if (!needle || !haystack)
    return false;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, haystack, entries)
  {
    if (mutt_addr_cmp(needle, a))
      return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_to_intl()

int mutt_addrlist_to_intl	(	struct AddressList *	al,
		char **	err )

Convert an Address list to Punycode.

Parameters

[in]	al	Address list to modify
[out]	err	Pointer for failed addresses

Return values

0	Success, all addresses converted
-1	Error, err will be set to the failed address

Definition at line 1304 of file address.c.

{
  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(buf_string(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 = buf_strdup(a->mailbox);
      continue;
    }
 
    addr_set_intl(a, intl_mailbox);
    FREE(&intl_mailbox);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_to_local()

int mutt_addrlist_to_local

(

struct AddressList *

al

)

Convert an Address list from Punycode.

Parameters

al	Address list to modify

Return values

0

Always

Definition at line 1389 of file address.c.

{
  if (!al)
    return 0;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    mutt_addr_to_local(a);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_uses_unicode()

bool mutt_addrlist_uses_unicode

(

const struct AddressList *

al

)

Do any of a list of addresses use Unicode characters.

Parameters

al	Address list to check

Return values

true	Any use 8-bit characters

Definition at line 1536 of file address.c.

{
  if (!al)
  {
    return false;
  }
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    if (a->mailbox && !a->group && mutt_addr_uses_unicode(buf_string(a->mailbox)))
      return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_write()

size_t mutt_addrlist_write	(	const struct AddressList *	al,
		struct Buffer *	buf,
		bool	display )

Write an Address to a buffer.

Parameters

al	AddressList to display
buf	Buffer for the Address
display	This address will be displayed to the user

Return values

num	Length of the string written to buf

If 'display' is set, then it doesn't matter if the transformation isn't reversible.

Definition at line 1217 of file address.c.

{
  return addrlist_write(al, buf, display, NULL, -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_write_wrap()

size_t mutt_addrlist_write_wrap	(	const struct AddressList *	al,
		struct Buffer *	buf,
		const char *	header )

Write an AddressList to a buffer, perform line wrapping.

Parameters

al	AddressList to display
buf	Buffer for the Address
header	Header name; if present, addresses we be written after ": "

Return values

num	Length of the string written to buf

Definition at line 1201 of file address.c.

{
  return addrlist_write(al, buf, false, header, 74);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_write_file()

void mutt_addrlist_write_file	(	const struct AddressList *	al,
		FILE *	fp,
		const char *	header )

Wrapper for mutt_write_address().

Parameters

al	Address list
fp	File to write to
header	Header name; if present, addresses we be written after ": "

So we can handle very large recipient lists without needing a huge temporary buffer in memory

Definition at line 1259 of file address.c.

{
  struct Buffer *buf = buf_pool_get();
  mutt_addrlist_write_wrap(al, buf, header);
  fputs(buf_string(buf), fp);
  buf_pool_release(&buf);
  fputc('\n', fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addrlist_write_list()

size_t mutt_addrlist_write_list	(	const struct AddressList *	al,
		struct ListHead *	list )

Write Addresses to a List.

Parameters

al	AddressList to write
list	List for the Addresses

Return values

num	Number of addresses written

Definition at line 1228 of file address.c.

{
  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 (!buf_is_empty(&buf))
    {
      /* We're taking the ownership of the buffer string here */
      mutt_list_insert_tail(list, (char *) buf_string(&buf));
      count++;
    }
  }
 
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

AddressSpecials

const char AddressSpecials[]

extern

Characters with special meaning for email addresses.

Definition at line 45 of file address.c.