lib.h File Reference

Email Aliases. More...

#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include "mutt_commands.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() -e.g. 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 664 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 672 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 372 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 *const 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 282 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	The given address belongs to the user

Definition at line 562 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;
  }

  const struct Address *c_from = cs_subset_address(NeoMutt->sub, "from");
  if (c_from && mutt_istr_equal(c_from->mailbox, addr->mailbox))
  {
    mutt_debug(LL_DEBUG5, "#5 yes, %s = %s\n", addr->mailbox, c_from->mailbox);
    return true;
  }

  if (mutt_alternates_match(addr->mailbox))
    return true;

  mutt_debug(LL_DEBUG5, "no, all failed\n");
  return false;
}

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 314 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 300 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 332 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_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 465 of file dlgalias.c.

{
  struct Alias *np = NULL;
  char bestname[8192] = { 0 };

  struct AliasMenuData mdata = { 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, &mdata, 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 697 of file dlgquery.c.

{
  const char *const 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 737 of file dlgquery.c.

{
  const char *const 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 157 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: