lib.h File Reference

Email Aliases. More...

#include <stdbool.h>
#include "core/lib.h"
#include "alternates.h"
#include "expando.h"
#include "group.h"
#include "module_data.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)
void	alias_init_keys (struct NeoMutt *n, struct SubMenu *sm_generic)
	Initialise the Alias Keybindings - Implements ::init_keys_api.
void	alias_cleanup (void)
void	alias_create (struct AddressList *al, const struct ConfigSubset *sub)
	Create a new Alias from an Address.
struct AddressList *	alias_lookup (const char *name)
	Find an Alias.
bool	mutt_addr_is_user (const struct Address *addr)
	Does the address belong to the user.
void	mutt_expand_aliases_env (struct Envelope *env)
	Expand aliases in all the fields of an Envelope.
void	mutt_expand_aliases (struct AddressList *al)
	Expand aliases in a List of Addresses.
struct AddressList *	mutt_get_address (struct Envelope *env, const char **prefix)
	Get an Address from an Envelope.
enum CommandResult	parse_alias (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'alias' command - Implements Command::parse() -.
enum CommandResult	parse_unalias (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unalias' command - Implements Command::parse() -.
void	alias_tags_to_buffer (struct TagList *tl, struct Buffer *buf)
	Write a comma-separated list of tags to a Buffer.
void	parse_alias_comments (struct Alias *alias, const char *com)
	Parse the alias/query comment field.
void	parse_alias_tags (const char *tags, struct TagList *tl)
	Parse a comma-separated list of tags.
int	alias_complete (struct Buffer *buf, struct ConfigSubset *sub)
	Alias completion routine.
void	alias_dialog (struct Mailbox *m, struct ConfigSubset *sub)
	Open the aliases dialog.
int	query_complete (struct Buffer *buf, struct ConfigSubset *sub)
	Perform auto-complete using an Address Query.
void	query_index (struct Mailbox *m, struct ConfigSubset *sub)
	Perform an Alias Query and display the results.
struct Address *	alias_reverse_lookup (const struct Address *addr)
	Does the user have an alias for the given address.
void	mutt_auto_subscribe (const char *mailto)
	Check if user is subscribed to mailing list.

Variables
const struct CompleteOps	CompleteAliasOps
	Auto-Completion of Aliases.

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

)

alias_init_keys()

void alias_init_keys	(	struct NeoMutt *	n,
		struct SubMenu *	sm_generic )

Initialise the Alias Keybindings - Implements ::init_keys_api.

Definition at line 120 of file functions.c.

{
  struct AliasModuleData *mod_data = neomutt_get_module_data(n, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm = NULL;
 
  sm = km_register_submenu(OpAlias);
  md = km_register_menu(MENU_ALIAS, "alias");
  km_menu_add_submenu(md, sm);
  km_menu_add_submenu(md, sm_generic);
  km_menu_add_bindings(md, AliasDefaultBindings);
 
  mod_data->menu_alias = md;
 
  sm = km_register_submenu(OpQuery);
  md = km_register_menu(MENU_QUERY, "query");
  km_menu_add_submenu(md, sm);
  km_menu_add_submenu(md, sm_generic);
  km_menu_add_bindings(md, QueryDefaultBindings);
 
  mod_data->menu_query = md;
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_cleanup()

void alias_cleanup

(

void

)

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 369 of file alias.c.

{
  struct Buffer *buf = buf_pool_get();
  struct Buffer *fixed = buf_pool_get();
  struct Buffer *prompt = NULL;
  struct Buffer *tmp = buf_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)
    {
      buf_copy(tmp, addr->mailbox);
      pc = strchr(buf_string(tmp), '@');
      if (pc)
        *pc = '\0';
    }
  }
 
  /* Don't suggest a bad alias name in the event of a strange local part. */
  check_alias_name(buf_string(tmp), buf);
 
retry_name:
  /* L10N: prompt to add a new alias */
  if ((mw_get_field(_("Alias as: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0) ||
      buf_is_empty(buf))
  {
    goto done;
  }
 
  /* check to see if the user already has an alias defined */
  if (alias_lookup(buf_string(buf)))
  {
    mutt_error(_("You already have an alias defined with that name"));
    goto done;
  }
 
  if (check_alias_name(buf_string(buf), fixed))
  {
    switch (query_yesorno(_("Warning: This alias name may not work.  Fix it?"), MUTT_YES))
    {
      case MUTT_YES:
        buf_copy(buf, fixed);
        goto retry_name;
      case MUTT_ABORT:
        goto done;
      default:; // do nothing
    }
  }
 
  struct Alias *alias = alias_new();
  alias->name = buf_strdup(buf);
 
  mutt_addrlist_to_local(al);
 
  if (addr && addr->mailbox)
    buf_copy(buf, addr->mailbox);
  else
    buf_reset(buf);
 
  mutt_addrlist_to_intl(al, NULL);
 
  do
  {
    if ((mw_get_field(_("Address: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0) ||
        buf_is_empty(buf))
    {
      alias_free(&alias);
      goto done;
    }
 
    mutt_addrlist_parse(&alias->addr, buf_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))
    buf_copy(buf, addr->personal);
  else
    buf_reset(buf);
 
  if (mw_get_field(_("Personal name: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0)
  {
    alias_free(&alias);
    goto done;
  }
 
  TAILQ_FIRST(&alias->addr)->personal = buf_new(buf_string(buf));
 
  buf_reset(buf);
  if (mw_get_field(_("Comment: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) == 0)
  {
    mutt_str_replace(&alias->comment, buf_string(buf));
  }
 
  buf_reset(buf);
  if (mw_get_field(_("Tags (comma-separated): "), buf, MUTT_COMP_NONE, HC_OTHER,
                   NULL, NULL) == 0)
  {
    parse_alias_tags(buf_string(buf), &alias->tags);
  }
 
  buf_reset(buf);
  mutt_addrlist_write(&alias->addr, buf, true);
  prompt = buf_pool_get();
 
  buf_printf(prompt, "alias %s %s", alias->name, buf_string(buf));
 
  bool has_tags = STAILQ_FIRST(&alias->tags);
 
  if (alias->comment || has_tags)
    buf_addstr(prompt, " #");
 
  if (alias->comment)
    buf_add_printf(prompt, " %s", alias->comment);
 
  if (has_tags)
  {
    if (STAILQ_FIRST(&alias->tags))
    {
      buf_addstr(prompt, " tags:");
      alias_tags_to_buffer(&alias->tags, prompt);
    }
  }
 
  buf_add_printf(prompt, "\n%s", _("Accept?"));
 
  if (query_yesorno(buf_string(prompt), MUTT_YES) != MUTT_YES)
  {
    alias_free(&alias);
    goto done;
  }
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  alias_reverse_add(alias);
  ARRAY_ADD(&mod_data->aliases, alias);
 
  const char *const c_alias_file = cs_subset_path(sub, "alias_file");
  buf_strcpy(buf, c_alias_file);
 
  struct FileCompletionData cdata = { false, NULL, NULL, NULL, NULL };
  if (mw_get_field(_("Save to file: "), buf, MUTT_COMP_CLEAR, HC_FILE,
                   &CompleteFileOps, &cdata) != 0)
  {
    goto done;
  }
  expand_path(buf, false);
  fp_alias = mutt_file_fopen(buf_string(buf), "a+");
  if (!fp_alias)
  {
    mutt_perror("%s", buf_string(buf));
    goto done;
  }
 
  /* terminate existing file with \n if necessary */
  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_at(buf, 0) != '\n')
      fputc('\n', fp_alias);
  }
 
  if (check_alias_name(alias->name, NULL))
    buf_quote_filename(buf, alias->name, true);
  else
    buf_strcpy(buf, alias->name);
 
  recode_buf(buf);
  fprintf(fp_alias, "alias %s ", buf_string(buf));
  buf_reset(buf);
 
  mutt_addrlist_write(&alias->addr, buf, false);
  recode_buf(buf);
  write_safe_address(fp_alias, buf_string(buf));
  if (alias->comment)
    fprintf(fp_alias, " # %s", alias->comment);
  if (STAILQ_FIRST(&alias->tags))
  {
    fprintf(fp_alias, " tags:");
 
    struct Tag *tag = NULL;
    STAILQ_FOREACH(tag, &alias->tags, entries)
    {
      fprintf(fp_alias, "%s", tag->name);
      if (STAILQ_NEXT(tag, entries))
        fprintf(fp_alias, ",");
    }
  }
  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);
  buf_pool_release(&buf);
  buf_pool_release(&fixed);
  buf_pool_release(&prompt);
  buf_pool_release(&tmp);
}

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 274 of file alias.c.

{
  struct Alias **ap = NULL;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  ARRAY_FOREACH(ap, &mod_data->aliases)
  {
    struct Alias *a = *ap;
 
    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	The given address belongs to the user

Definition at line 601 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(buf_string(addr->mailbox), NeoMutt->username))
  {
    mutt_debug(LL_DEBUG5, "#1 yes, %s = %s\n", buf_string(addr->mailbox),
               NeoMutt->username);
    return true;
  }
  if (string_is_address(buf_string(addr->mailbox), NeoMutt->username, ShortHostname))
  {
    mutt_debug(LL_DEBUG5, "#2 yes, %s = %s @ %s\n", buf_string(addr->mailbox),
               NeoMutt->username, ShortHostname);
    return true;
  }
  const char *fqdn = mutt_fqdn(false, NeoMutt->sub);
  if (string_is_address(buf_string(addr->mailbox), NeoMutt->username, fqdn))
  {
    mutt_debug(LL_DEBUG5, "#3 yes, %s = %s @ %s\n", buf_string(addr->mailbox),
               NeoMutt->username, NONULL(fqdn));
    return true;
  }
  fqdn = mutt_fqdn(true, NeoMutt->sub);
  if (string_is_address(buf_string(addr->mailbox), NeoMutt->username, fqdn))
  {
    mutt_debug(LL_DEBUG5, "#4 yes, %s = %s @ %s\n", buf_string(addr->mailbox),
               NeoMutt->username, NONULL(fqdn));
    return true;
  }
 
  const struct Address *c_from = cs_subset_address(NeoMutt->sub, "from");
  if (c_from && mutt_istr_equal(buf_string(c_from->mailbox), buf_string(addr->mailbox)))
  {
    mutt_debug(LL_DEBUG5, "#5 yes, %s = %s\n", buf_string(addr->mailbox),
               buf_string(c_from->mailbox));
    return true;
  }
 
  if (mutt_alternates_match(buf_string(addr->mailbox)))
    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 311 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 297 of file alias.c.

{
  // previously expanded aliases to avoid loops
  struct ListHead expn = STAILQ_HEAD_INITIALIZER(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 329 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:

alias_tags_to_buffer()

void alias_tags_to_buffer	(	struct TagList *	tl,
		struct Buffer *	buf )

Write a comma-separated list of tags to a Buffer.

Parameters

tl	Tags
buf	Buffer for the result

Definition at line 89 of file commands.c.

{
  struct Tag *tag = NULL;
  STAILQ_FOREACH(tag, tl, entries)
  {
    buf_addstr(buf, tag->name);
    if (STAILQ_NEXT(tag, entries))
      buf_addch(buf, ',');
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_alias_comments()

void parse_alias_comments	(	struct Alias *	alias,
		const char *	com )

Parse the alias/query comment field.

Parameters

alias	Alias for the result
com	Comment string

If the comment contains a 'tags:' field, the result will be put in alias.tags

Definition at line 135 of file commands.c.

{
  if (!com || (com[0] == '\0'))
    return;
 
  const regmatch_t *match = mutt_prex_capture(PREX_ALIAS_TAGS, com);
  if (match)
  {
    const regmatch_t *pre = &match[PREX_ALIAS_TAGS_MATCH_PRE];
    const regmatch_t *tags = &match[PREX_ALIAS_TAGS_MATCH_TAGS];
    const regmatch_t *post = &match[PREX_ALIAS_TAGS_MATCH_POST];
 
    struct Buffer *tmp = buf_pool_get();
 
    // Extract the tags
    buf_addstr_n(tmp, com + mutt_regmatch_start(tags),
                 mutt_regmatch_end(tags) - mutt_regmatch_start(tags));
    parse_alias_tags(buf_string(tmp), &alias->tags);
    buf_reset(tmp);
 
    // Collect all the other text as "comments"
    buf_addstr_n(tmp, com + mutt_regmatch_start(pre),
                 mutt_regmatch_end(pre) - mutt_regmatch_start(pre));
    buf_addstr_n(tmp, com + mutt_regmatch_start(post),
                 mutt_regmatch_end(post) - mutt_regmatch_start(post));
    alias->comment = buf_strdup(tmp);
 
    buf_pool_release(&tmp);
  }
  else
  {
    alias->comment = mutt_str_dup(com);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_alias_tags()

void parse_alias_tags	(	const char *	tags,
		struct TagList *	tl )

Parse a comma-separated list of tags.

Parameters

tags	Comma-separated string
tl	TagList for the results

Definition at line 105 of file commands.c.

{
  if (!tags || !tl)
    return;
 
  struct Slist *sl = slist_parse(tags, D_SLIST_SEP_COMMA);
  if (slist_is_empty(sl))
  {
    slist_free(&sl);
    return;
  }
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &sl->head, entries)
  {
    struct Tag *tag = tag_new();
    tag->name = np->data; // Transfer string
    np->data = NULL;
    STAILQ_INSERT_TAIL(tl, tag, entries);
  }
  slist_free(&sl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_complete()

int alias_complete	(	struct Buffer *	buf,
		struct ConfigSubset *	sub )

Alias completion routine.

Parameters

buf	Partial Alias to complete
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 353 of file dlg_alias.c.

{
  char bestname[8192] = { 0 };
  struct Alias *a_best = NULL;
  int count = 0;
 
  struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
  mdata.limit = buf_strdup(buf);
  mdata.search_state = search_state_new();
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  if (buf_at(buf, 0) != '\0')
  {
    struct Alias **ap = NULL;
    ARRAY_FOREACH(ap, &mod_data->aliases)
    {
      struct Alias *a = *ap;
      if (a->name && mutt_strn_equal(a->name, buf_string(buf), buf_len(buf)))
      {
        a_best = a;
        count++;
 
        if (bestname[0] == '\0') /* init */
        {
          mutt_str_copy(bestname, a->name, MIN(mutt_str_len(a->name) + 1, sizeof(bestname)));
        }
        else
        {
          int i;
          for (i = 0; a->name[i] && (a->name[i] == bestname[i]); i++)
            ; // do nothing
 
          bestname[i] = '\0';
        }
      }
    }
 
    // Exactly one match, so expand the Alias and return
    if (count == 1)
    {
      buf_reset(buf);
      mutt_addrlist_write(&a_best->addr, buf, true);
      buf_addstr(buf, ", ");
      FREE(&mdata.limit);
      search_state_free(&mdata.search_state);
      return 1;
    }
 
    if (bestname[0] == '\0')
    {
      // Create a View Array of all the Aliases
      FREE(&mdata.limit);
      ARRAY_FOREACH(ap, &mod_data->aliases)
      {
        alias_array_alias_add(&mdata.ava, *ap);
      }
    }
    else
    {
      /* fake the pattern for menu title */
      char *mtitle = NULL;
      mutt_str_asprintf(&mtitle, "~f ^%s", buf_string(buf));
      FREE(&mdata.limit);
      mdata.limit = mtitle;
 
      if (!mutt_str_equal(bestname, buf_string(buf)))
      {
        /* we are adding something to the completion */
        buf_strcpy_n(buf, bestname, mutt_str_len(bestname) + 1);
        FREE(&mdata.limit);
        search_state_free(&mdata.search_state);
        return 1;
      }
 
      /* build alias list and show it */
      ARRAY_FOREACH(ap, &mod_data->aliases)
      {
        struct Alias *a = *ap;
        int aasize = alias_array_alias_add(&mdata.ava, a);
 
        struct AliasView *av = ARRAY_GET(&mdata.ava, aasize - 1);
 
        if (a->name && !mutt_strn_equal(a->name, buf_string(buf), buf_len(buf)))
        {
          av->is_visible = false;
        }
      }
    }
  }
 
  if (ARRAY_EMPTY(&mdata.ava))
  {
    struct Alias **ap = NULL;
    ARRAY_FOREACH(ap, &mod_data->aliases)
    {
      alias_array_alias_add(&mdata.ava, *ap);
    }
 
    mutt_pattern_alias_func(NULL, &mdata, PAA_VISIBLE, NULL);
  }
 
  if (!dlg_alias(&mdata))
    goto done;
 
  buf_reset(buf);
 
  // Extract the selected aliases
  struct Buffer *tmpbuf = buf_pool_get();
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_tagged)
      continue;
 
    mutt_addrlist_write(&avp->alias->addr, tmpbuf, true);
    buf_addstr(tmpbuf, ", ");
  }
  buf_copy(buf, tmpbuf);
  buf_pool_release(&tmpbuf);
 
done:
  // Process any deleted aliases
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_deleted)
      continue;
 
    // Find and remove the alias from the Aliases array
    struct Alias **ap = NULL;
    ARRAY_FOREACH(ap, &mod_data->aliases)
    {
      if (*ap == avp->alias)
      {
        ARRAY_REMOVE(&mod_data->aliases, ap);
        break;
      }
    }
    alias_free(&avp->alias);
  }
 
  ARRAY_FREE(&mdata.ava);
  FREE(&mdata.limit);
  FREE(&mdata.title);
  search_state_free(&mdata.search_state);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_dialog()

void alias_dialog	(	struct Mailbox *	m,
		struct ConfigSubset *	sub )

Open the aliases dialog.

Parameters

m	Mailbox
sub	Config item

Definition at line 508 of file dlg_alias.c.

{
  struct Alias **ap = NULL;
 
  struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
  mdata.search_state = search_state_new();
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  // Create a View Array of all the Aliases
  ARRAY_FOREACH(ap, &mod_data->aliases)
  {
    alias_array_alias_add(&mdata.ava, *ap);
  }
 
  if (!dlg_alias(&mdata))
    goto done;
 
  // Prepare the "To:" field of a new email
  struct Email *e = email_new();
  e->env = mutt_env_new();
 
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_tagged)
      continue;
 
    struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
    if (alias_to_addrlist(&al_copy, avp->alias))
    {
      mutt_addrlist_copy(&e->env->to, &al_copy, false);
      mutt_addrlist_clear(&al_copy);
    }
  }
 
  mutt_send_message(SEND_REVIEW_TO, e, NULL, m, NULL, sub);
 
done:
  // Process any deleted aliases
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (avp->is_deleted)
    {
      // Find and remove the alias from the Aliases array
      ARRAY_FOREACH(ap, &mod_data->aliases)
      {
        if (*ap == avp->alias)
        {
          ARRAY_REMOVE(&mod_data->aliases, ap);
          break;
        }
      }
      alias_free(&avp->alias);
    }
  }
 
  ARRAY_FREE(&mdata.ava);
  FREE(&mdata.limit);
  FREE(&mdata.title);
  search_state_free(&mdata.search_state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_complete()

int query_complete	(	struct Buffer *	buf,
		struct ConfigSubset *	sub )

Perform auto-complete using an Address Query.

Parameters

buf	Buffer for completion
sub	Config item

Return values

0

Always

Definition at line 414 of file dlg_query.c.

{
  struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
  mdata.search_state = search_state_new();
 
  struct AliasArray aa = ARRAY_HEAD_INITIALIZER;
  const char *const c_query_command = cs_subset_string(sub, "query_command");
  if (!c_query_command)
  {
    mutt_warning(_("Query command not defined"));
    goto done;
  }
 
  query_run(buf_string(buf), true, &aa, sub);
  if (ARRAY_EMPTY(&aa))
    goto done;
 
  mdata.aa = &aa;
 
  struct Alias **a_first = ARRAY_FIRST(&aa);
  if (ARRAY_SIZE(&aa) == 1) // only one response?
  {
    struct AddressList addr = TAILQ_HEAD_INITIALIZER(addr);
    if (alias_to_addrlist(&addr, *a_first))
    {
      mutt_addrlist_to_local(&addr);
      buf_reset(buf);
      mutt_addrlist_write(&addr, buf, false);
      mutt_addrlist_clear(&addr);
      mutt_clear_error();
      buf_addstr(buf, ", ");
    }
    goto done;
  }
 
  struct Alias **ap = NULL;
  ARRAY_FOREACH(ap, mdata.aa)
  {
    alias_array_alias_add(&mdata.ava, *ap);
  }
 
  /* multiple results, choose from query menu */
  if (!dlg_query(buf, &mdata))
    goto done;
 
  buf_reset(buf);
  buf_alloc(buf, 8192);
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_tagged)
      continue;
 
    struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
    if (alias_to_addrlist(&al_copy, avp->alias))
    {
      mutt_addrlist_to_local(&al_copy);
      mutt_addrlist_write(&al_copy, buf, false);
      mutt_addrlist_clear(&al_copy);
    }
    buf_addstr(buf, ", ");
  }
 
done:
  ARRAY_FREE(&mdata.ava);
  FREE(&mdata.title);
  FREE(&mdata.limit);
  search_state_free(&mdata.search_state);
  aliaslist_clear(&aa);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_index()

void query_index	(	struct Mailbox *	m,
		struct ConfigSubset *	sub )

Perform an Alias Query and display the results.

Parameters

m	Mailbox
sub	Config item

Definition at line 491 of file dlg_query.c.

{
  const char *const c_query_command = cs_subset_string(sub, "query_command");
  if (!c_query_command)
  {
    mutt_warning(_("Query command not defined"));
    return;
  }
 
  struct AliasArray aa = ARRAY_HEAD_INITIALIZER;
  struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
  mdata.aa = &aa;
  mdata.search_state = search_state_new();
 
  struct Buffer *buf = buf_pool_get();
  if ((mw_get_field(_("Query: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0) ||
      buf_is_empty(buf))
  {
    goto done;
  }
 
  query_run(buf_string(buf), false, &aa, sub);
  if (ARRAY_EMPTY(&aa))
    goto done;
 
  struct Alias **ap = NULL;
  ARRAY_FOREACH(ap, mdata.aa)
  {
    alias_array_alias_add(&mdata.ava, *ap);
  }
 
  if (!dlg_query(buf, &mdata))
    goto done;
 
  // Prepare the "To:" field of a new email
  struct Email *e = email_new();
  e->env = mutt_env_new();
 
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_tagged)
      continue;
 
    struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
    if (alias_to_addrlist(&al_copy, avp->alias))
    {
      mutt_addrlist_copy(&e->env->to, &al_copy, false);
      mutt_addrlist_clear(&al_copy);
    }
  }
 
  mutt_send_message(SEND_REVIEW_TO, e, NULL, m, NULL, sub);
 
done:
  ARRAY_FREE(&mdata.ava);
  FREE(&mdata.title);
  FREE(&mdata.limit);
  search_state_free(&mdata.search_state);
  aliaslist_clear(&aa);
  buf_pool_release(&buf);
}

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 110 of file reverse.c.

{
  if (!addr || !addr->mailbox)
    return NULL;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  return mutt_hash_find(mod_data->reverse_aliases, buf_string(addr->mailbox));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_auto_subscribe()

void mutt_auto_subscribe

(

const char *

mailto

)

Check if user is subscribed to mailing list.

Parameters

mailto

URL of mailing list subscribe

Definition at line 49 of file commands.c.

{
  if (!mailto)
    return;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  if (!mod_data->auto_subscribe_cache)
    mod_data->auto_subscribe_cache = mutt_hash_new(200, MUTT_HASH_STRCASECMP | MUTT_HASH_STRDUP_KEYS);
 
  if (mutt_hash_find(mod_data->auto_subscribe_cache, mailto))
    return;
 
  mutt_hash_insert(mod_data->auto_subscribe_cache, mailto, mod_data->auto_subscribe_cache);
 
  struct Envelope *lpenv = mutt_env_new(); /* parsed envelope from the List-Post mailto: URL */
 
  if (mutt_parse_mailto(lpenv, NULL, mailto) && !TAILQ_EMPTY(&lpenv->to))
  {
    const char *mailbox = buf_string(TAILQ_FIRST(&lpenv->to)->mailbox);
    if (mailbox && !mutt_regexlist_match(&mod_data->subscribed, mailbox) &&
        !mutt_regexlist_match(&mod_data->unmail, mailbox) &&
        !mutt_regexlist_match(&mod_data->unsubscribed, mailbox))
    {
      /* mutt_regexlist_add() detects duplicates, so it is safe to
       * try to add here without any checks. */
      mutt_regexlist_add(&mod_data->mail, mailbox, REG_ICASE, NULL);
      mutt_regexlist_add(&mod_data->subscribed, mailbox, REG_ICASE, NULL);
    }
  }
 
  mutt_env_free(&lpenv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CompleteAliasOps

const struct CompleteOps CompleteAliasOps

extern

Auto-Completion of Aliases.

Definition at line 108 of file complete.c.

                                          {
  .complete = complete_alias,
};