lib.h File Reference

#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include "mutt_commands.h"
#include "sort.h"
#include "gui.h"

Include dependency graph for lib.h:

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

Go to the source code of this file.

Functions
void	alias_init (void)
	Set up the Alias globals. More...
void	alias_shutdown (void)
	Clean up the Alias globals. More...
void	alias_create (struct AddressList *al, const struct ConfigSubset *sub)
	Create a new Alias from an Address. More...
struct AddressList *	alias_lookup (const char *name)
	Find an Alias. More...
bool	mutt_addr_is_user (const struct Address *addr)
	Does the address belong to the user. More...
void	mutt_expand_aliases_env (struct Envelope *env)
	Expand aliases in all the fields of an Envelope. More...
void	mutt_expand_aliases (struct AddressList *al)
	Expand aliases in a List of Addresses. More...
struct AddressList *	mutt_get_address (struct Envelope *env, const char **prefix)
	Get an Address from an Envelope. More...
enum CommandResult	parse_alias (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'alias' command - Implements Command::parse() More...
enum CommandResult	parse_unalias (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unalias' command - Implements Command::parse() More...
int	alias_complete (char *buf, size_t buflen, struct ConfigSubset *sub)
	alias completion routine More...
int	query_complete (char *buf, size_t buflen, struct ConfigSubset *sub)
	Perform auto-complete using an Address Query. More...
void	query_index (struct ConfigSubset *sub)
	Perform an Alias Query and display the results. More...
struct Address *	alias_reverse_lookup (const struct Address *addr)
	Does the user have an alias for the given address. More...
void	alias_array_sort (struct AliasViewArray *ava, const struct ConfigSubset *sub)
	Sort and reindex an AliasViewArray. More...

Detailed Description

Email Aliases

Authors

• Richard Russon

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 lib.h.

Function Documentation

alias_init()

void alias_init

(

void

)

Set up the Alias globals.

Definition at line 662 of file alias.c.

{
  alias_reverse_init();
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_shutdown()

void alias_shutdown

(

void

)

Clean up the Alias globals.

Definition at line 670 of file alias.c.

{
  struct Alias *np = NULL;
  TAILQ_FOREACH(np, &Aliases, entries)
  {
    alias_reverse_delete(np);
  }
  aliaslist_free(&Aliases);
  alias_reverse_shutdown();
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_create()

void alias_create	(	struct AddressList *	al,
		const struct ConfigSubset *	sub
	)

Create a new Alias from an Address.

Parameters

al	Address to use
sub	Config items

Definition at line 366 of file alias.c.

{
  struct Address *addr = NULL;
  char buf[1024], tmp[1024] = { 0 }, prompt[2048];
  char *pc = NULL;
  char *err = NULL;
  char fixed[1024];
 
  if (al)
  {
    addr = TAILQ_FIRST(al);
    if (addr && addr->mailbox)
    {
      mutt_str_copy(tmp, addr->mailbox, sizeof(tmp));
      pc = strchr(tmp, '@');
      if (pc)
        *pc = '\0';
    }
  }
 
  /* Don't suggest a bad alias name in the event of a strange local part. */
  check_alias_name(tmp, buf, sizeof(buf));
 
retry_name:
  /* L10N: prompt to add a new alias */
  if ((mutt_get_field(_("Alias as: "), buf, sizeof(buf), MUTT_COMP_NO_FLAGS,
                      false, NULL, NULL) != 0) ||
      (buf[0] == '\0'))
  {
    return;
  }
 
  /* check to see if the user already has an alias defined */
  if (alias_lookup(buf))
  {
    mutt_error(_("You already have an alias defined with that name"));
    return;
  }
 
  if (check_alias_name(buf, fixed, sizeof(fixed)))
  {
    switch (mutt_yesorno(_("Warning: This alias name may not work.  Fix it?"), MUTT_YES))
    {
      case MUTT_YES:
        mutt_str_copy(buf, fixed, sizeof(buf));
        goto retry_name;
      case MUTT_ABORT:
        return;
      default:; // do nothing
    }
  }
 
  struct Alias *alias = alias_new();
  alias->name = mutt_str_dup(buf);
 
  mutt_addrlist_to_local(al);
 
  if (addr && addr->mailbox)
    mutt_str_copy(buf, addr->mailbox, sizeof(buf));
  else
    buf[0] = '\0';
 
  mutt_addrlist_to_intl(al, NULL);
 
  do
  {
    if ((mutt_get_field(_("Address: "), buf, sizeof(buf), MUTT_COMP_NO_FLAGS,
                        false, NULL, NULL) != 0) ||
        (buf[0] == '\0'))
    {
      alias_free(&alias);
      return;
    }
 
    mutt_addrlist_parse(&alias->addr, 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_str_copy(buf, addr->personal, sizeof(buf));
  else
    buf[0] = '\0';
 
  if (mutt_get_field(_("Personal name: "), buf, sizeof(buf), MUTT_COMP_NO_FLAGS,
                     false, NULL, NULL) != 0)
  {
    alias_free(&alias);
    return;
  }
  mutt_str_replace(&TAILQ_FIRST(&alias->addr)->personal, buf);
 
  buf[0] = '\0';
  if (mutt_get_field(_("Comment: "), buf, sizeof(buf), MUTT_COMP_NO_FLAGS,
                     false, NULL, NULL) == 0)
  {
    mutt_str_replace(&alias->comment, buf);
  }
 
  buf[0] = '\0';
  mutt_addrlist_write(&alias->addr, buf, sizeof(buf), true);
  if (alias->comment)
  {
    snprintf(prompt, sizeof(prompt), "[%s = %s # %s] %s", alias->name, buf,
             alias->comment, _("Accept?"));
  }
  else
  {
    snprintf(prompt, sizeof(prompt), "[%s = %s] %s", alias->name, buf, _("Accept?"));
  }
  if (mutt_yesorno(prompt, MUTT_YES) != MUTT_YES)
  {
    alias_free(&alias);
    return;
  }
 
  alias_reverse_add(alias);
  TAILQ_INSERT_TAIL(&Aliases, alias, entries);
 
  const char *alias_file = cs_subset_path(sub, "alias_file");
  mutt_str_copy(buf, NONULL(alias_file), sizeof(buf));
 
  if (mutt_get_field(_("Save to file: "), buf, sizeof(buf),
                     MUTT_FILE | MUTT_CLEAR, false, NULL, NULL) != 0)
  {
    return;
  }
  mutt_expand_path(buf, sizeof(buf));
  FILE *fp_alias = fopen(buf, "a+");
  if (!fp_alias)
  {
    mutt_perror(buf);
    return;
  }
 
  /* terminate existing file with \n if necessary */
  if (fseek(fp_alias, 0, SEEK_END))
    goto fseek_err;
  if (ftell(fp_alias) > 0)
  {
    if (fseek(fp_alias, -1, SEEK_CUR) < 0)
      goto fseek_err;
    if (fread(buf, 1, 1, fp_alias) != 1)
    {
      mutt_perror(_("Error reading alias file"));
      mutt_file_fclose(&fp_alias);
      return;
    }
    if (fseek(fp_alias, 0, SEEK_END) < 0)
      goto fseek_err;
    if (buf[0] != '\n')
      fputc('\n', fp_alias);
  }
 
  if (check_alias_name(alias->name, NULL, 0))
    mutt_file_quote_filename(alias->name, buf, sizeof(buf));
  else
    mutt_str_copy(buf, alias->name, sizeof(buf));
  recode_buf(buf, sizeof(buf));
  fprintf(fp_alias, "alias %s ", buf);
  buf[0] = '\0';
  mutt_addrlist_write(&alias->addr, buf, sizeof(buf), false);
  recode_buf(buf, sizeof(buf));
  write_safe_address(fp_alias, 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"));
 
  return;
 
fseek_err:
  mutt_perror(_("Error seeking in alias file"));
  mutt_file_fclose(&fp_alias);
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_lookup()

struct AddressList* alias_lookup

(

const char *

name

)

Find an Alias.

Parameters

name	Alias name to find

Return values

ptr	Address for the Alias
NULL	No such Alias

Note

The search is case-insensitive

Definition at line 276 of file alias.c.

{
  struct Alias *a = NULL;
 
  TAILQ_FOREACH(a, &Aliases, entries)
  {
    if (mutt_istr_equal(name, a->name))
      return &a->addr;
  }
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addr_is_user()

bool mutt_addr_is_user

(

const struct Address *

addr

)

Does the address belong to the user.

Parameters

addr	Address to check

Return values

true	if the given address belongs to the user

Definition at line 556 of file alias.c.

{
  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;
  }
 
  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_regexlist_match(&Alternates, addr->mailbox))
  {
    mutt_debug(LL_DEBUG5, "yes, %s matched by alternates\n", addr->mailbox);
    if (mutt_regexlist_match(&UnAlternates, addr->mailbox))
      mutt_debug(LL_DEBUG5, "but, %s matched by unalternates\n", addr->mailbox);
    else
      return true;
  }
 
  mutt_debug(LL_DEBUG5, "no, all failed\n");
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_expand_aliases_env()

void mutt_expand_aliases_env

(

struct Envelope *

env

)

Expand aliases in all the fields of an Envelope.

Parameters

env	Envelope to expand

Definition at line 308 of file alias.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_expand_aliases()

void mutt_expand_aliases

(

struct AddressList *

al

)

Expand aliases in a List of Addresses.

Parameters

al	AddressList

Duplicate addresses are dropped

Definition at line 294 of file alias.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_address()

struct AddressList* mutt_get_address	(	struct Envelope *	env,
		const char **	prefix
	)

Get an Address from an Envelope.

Parameters

[in]	env	Envelope to examine
[out]	prefix	Prefix for the Address, e.g. "To:"

Return values

ptr	AddressList in the Envelope

Note

The caller must NOT free the returned AddressList

Definition at line 326 of file alias.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

parse_alias()

enum CommandResult parse_alias	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

Parse the 'alias' command - Implements Command::parse()

e.g. "alias jim James Smith <js@example.com> # Pointy-haired boss"

Definition at line 49 of file commands.c.

{
  struct Alias *tmp = NULL;
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  enum NotifyAlias event;
 
  if (!MoreArgs(s))
  {
    mutt_buffer_strcpy(err, _("alias: no address"));
    return MUTT_CMD_WARNING;
  }
 
  /* name */
  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
  mutt_debug(LL_DEBUG5, "First token is '%s'\n", buf->data);
  if (parse_grouplist(&gl, buf, s, err) == -1)
  {
    return MUTT_CMD_ERROR;
  }
  char *name = mutt_str_dup(buf->data);
 
  /* address list */
  mutt_extract_token(buf, s, MUTT_TOKEN_QUOTE | MUTT_TOKEN_SPACE | MUTT_TOKEN_SEMICOLON);
  mutt_debug(LL_DEBUG5, "Second token is '%s'\n", buf->data);
  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
  int parsed = mutt_addrlist_parse2(&al, buf->data);
  if (parsed == 0)
  {
    mutt_buffer_printf(err, _("Warning: Bad address '%s' in alias '%s'"), buf->data, name);
    FREE(&name);
    goto bail;
  }
 
  /* IDN */
  char *estr = NULL;
  if (mutt_addrlist_to_intl(&al, &estr))
  {
    mutt_buffer_printf(err, _("Warning: Bad IDN '%s' in alias '%s'"), estr, name);
    FREE(&name);
    FREE(&estr);
    goto bail;
  }
 
  /* check to see if an alias with this name already exists */
  TAILQ_FOREACH(tmp, &Aliases, entries)
  {
    if (mutt_istr_equal(tmp->name, name))
      break;
  }
 
  if (tmp)
  {
    FREE(&name);
    alias_reverse_delete(tmp);
    /* override the previous value */
    mutt_addrlist_clear(&tmp->addr);
    FREE(&tmp->comment);
    event = NT_ALIAS_CHANGED;
  }
  else
  {
    /* create a new alias */
    tmp = alias_new();
    tmp->name = name;
    TAILQ_INSERT_TAIL(&Aliases, tmp, entries);
    event = NT_ALIAS_NEW;
  }
  tmp->addr = al;
 
  mutt_grouplist_add_addrlist(&gl, &tmp->addr);
 
  if (C_DebugLevel > LL_DEBUG4)
  {
    /* A group is terminated with an empty address, so check a->mailbox */
    struct Address *a = NULL;
    TAILQ_FOREACH(a, &tmp->addr, entries)
    {
      if (!a->mailbox)
        break;
 
      if (a->group)
        mutt_debug(LL_DEBUG5, "  Group %s\n", a->mailbox);
      else
        mutt_debug(LL_DEBUG5, "  %s\n", a->mailbox);
    }
  }
  mutt_grouplist_destroy(&gl);
  if (!MoreArgs(s) && (s->dptr[0] == '#'))
  {
    char *comment = s->dptr + 1;
    SKIPWS(comment);
    tmp->comment = mutt_str_dup(comment);
  }
 
  alias_reverse_add(tmp);
 
  struct EventAlias ea = { tmp };
  notify_send(NeoMutt->notify, NT_ALIAS, event, &ea);
 
  return MUTT_CMD_SUCCESS;
 
bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_unalias()

enum CommandResult parse_unalias	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

Parse the 'unalias' command - Implements Command::parse()

Definition at line 159 of file commands.c.

{
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
 
    struct Alias *np = NULL;
    if (mutt_str_equal("*", buf->data))
    {
      TAILQ_FOREACH(np, &Aliases, entries)
      {
        alias_reverse_delete(np);
      }
 
      aliaslist_free(&Aliases);
      return MUTT_CMD_SUCCESS;
    }
 
    TAILQ_FOREACH(np, &Aliases, entries)
    {
      if (!mutt_istr_equal(buf->data, np->name))
        continue;
 
      TAILQ_REMOVE(&Aliases, np, entries);
      alias_reverse_delete(np);
      alias_free(&np);
      break;
    }
  } while (MoreArgs(s));
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

alias_complete()

int alias_complete	(	char *	buf,
		size_t	buflen,
		struct ConfigSubset *	sub
	)

alias completion routine

Parameters

buf	Partial Alias to complete
buflen	Length of buffer
sub	Config items

Return values

1	Success
0	Error

Given a partial alias, this routine attempts to fill in the alias from the alias list as much as possible. if given empty search string or found nothing, present all aliases

Definition at line 375 of file dlgalias.c.

{
  struct Alias *np = NULL;
  char bestname[8192] = { 0 };
 
  struct AliasMenuData mdata = { NULL, NULL, ARRAY_HEAD_INITIALIZER, sub };
  mdata.str = mutt_str_dup(buf);
 
  if (buf[0] != '\0')
  {
    TAILQ_FOREACH(np, &Aliases, entries)
    {
      if (np->name && mutt_strn_equal(np->name, buf, strlen(buf)))
      {
        if (bestname[0] == '\0') /* init */
        {
          mutt_str_copy(bestname, np->name,
                        MIN(mutt_str_len(np->name) + 1, sizeof(bestname)));
        }
        else
        {
          int i;
          for (i = 0; np->name[i] && (np->name[i] == bestname[i]); i++)
            ; // do nothing
 
          bestname[i] = '\0';
        }
      }
    }
 
    if (bestname[0] != '\0')
    {
      /* fake the pattern for menu title */
      char *mtitle = NULL;
      mutt_str_asprintf(&mtitle, "~f ^%s", buf);
      FREE(&mdata.str);
      mdata.str = mtitle;
 
      if (!mutt_str_equal(bestname, buf))
      {
        /* we are adding something to the completion */
        mutt_str_copy(buf, bestname, mutt_str_len(bestname) + 1);
        FREE(&mdata.str);
        return 1;
      }
 
      /* build alias list and show it */
      TAILQ_FOREACH(np, &Aliases, entries)
      {
        int aasize = alias_array_alias_add(&mdata.ava, np);
 
        struct AliasView *av = ARRAY_GET(&mdata.ava, aasize - 1);
 
        if (np->name && !mutt_strn_equal(np->name, buf, strlen(buf)))
        {
          av->is_visible = false;
        }
      }
    }
  }
 
  if (ARRAY_EMPTY(&mdata.ava))
  {
    TAILQ_FOREACH(np, &Aliases, entries)
    {
      alias_array_alias_add(&mdata.ava, np);
    }
 
    mutt_pattern_alias_func(MUTT_LIMIT, NULL, _("Aliases"), &mdata, Context, NULL);
  }
 
  alias_array_sort(&mdata.ava, mdata.sub);
 
  bestname[0] = '\0';
  dlg_select_alias(bestname, sizeof(bestname), &mdata);
  if (bestname[0] != '\0')
    mutt_str_copy(buf, bestname, buflen);
 
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_deleted)
      continue;
 
    TAILQ_REMOVE(&Aliases, avp->alias, entries);
    alias_free(&avp->alias);
  }
 
  ARRAY_FREE(&mdata.ava);
  FREE(&mdata.str);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_complete()

int query_complete	(	char *	buf,
		size_t	buflen,
		struct ConfigSubset *	sub
	)

Perform auto-complete using an Address Query.

Parameters

buf	Buffer for completion
buflen	Length of buffer
sub	Config item

Return values

0

Always

Definition at line 606 of file dlgquery.c.

{
  const char *query_command = cs_subset_string(sub, "query_command");
  if (!query_command)
  {
    mutt_warning(_("Query command not defined"));
    return 0;
  }
 
  struct AliasList al = TAILQ_HEAD_INITIALIZER(al);
  query_run(buf, true, &al, sub);
  if (TAILQ_EMPTY(&al))
    return 0;
 
  struct Alias *a_first = TAILQ_FIRST(&al);
  if (!TAILQ_NEXT(a_first, entries)) // only one response?
  {
    struct AddressList addr = TAILQ_HEAD_INITIALIZER(addr);
    if (alias_to_addrlist(&addr, a_first))
    {
      mutt_addrlist_to_local(&addr);
      buf[0] = '\0';
      mutt_addrlist_write(&addr, buf, buflen, false);
      mutt_addrlist_clear(&addr);
      aliaslist_free(&al);
      mutt_clear_error();
    }
    return 0;
  }
 
  /* multiple results, choose from query menu */
  dlg_select_query(buf, buflen, &al, true, sub);
  aliaslist_free(&al);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_index()

void query_index

(

struct ConfigSubset *

sub

)

Perform an Alias Query and display the results.

Parameters

sub	Config item

Definition at line 646 of file dlgquery.c.

{
  const char *query_command = cs_subset_string(sub, "query_command");
  if (!query_command)
  {
    mutt_warning(_("Query command not defined"));
    return;
  }
 
  char buf[256] = { 0 };
  if ((mutt_get_field(_("Query: "), buf, sizeof(buf), MUTT_COMP_NO_FLAGS, false,
                      NULL, NULL) != 0) ||
      (buf[0] == '\0'))
  {
    return;
  }
 
  struct AliasList al = TAILQ_HEAD_INITIALIZER(al);
  query_run(buf, false, &al, sub);
  if (TAILQ_EMPTY(&al))
    return;
 
  dlg_select_query(buf, sizeof(buf), &al, false, sub);
  aliaslist_free(&al);
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_reverse_lookup()

struct Address* alias_reverse_lookup

(

const struct Address *

addr

)

Does the user have an alias for the given address.

Parameters

addr	Address to lookup

Return values

ptr	Matching Address

Definition at line 105 of file reverse.c.

{
  if (!addr || !addr->mailbox)
    return NULL;
 
  return mutt_hash_find(ReverseAliases, addr->mailbox);
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_array_sort()

void alias_array_sort	(	struct AliasViewArray *	ava,
		const struct ConfigSubset *	sub
	)

Sort and reindex an AliasViewArray.

Parameters

ava	Array of Aliases
sub	Config items

Definition at line 158 of file sort.c.

{
  if (!ava || ARRAY_EMPTY(ava))
    return;
 
  sort_alias = cs_subset_sort(sub, "sort_alias");
  ARRAY_SORT(ava, alias_get_sort_function(sort_alias));
 
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, ava)
  {
    avp->num = ARRAY_FOREACH_IDX;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: