commands.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdio.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "lib.h"
#include "parse/lib.h"
#include "alias.h"
#include "alternates.h"
#include "group.h"
#include "module_data.h"
#include "reverse.h"

void mutt_auto_subscribe(const char *mailto)
{
  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);
}

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

void parse_alias_tags(const char *tags, struct TagList *tl)
{
  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);
}

void parse_alias_comments(struct Alias *alias, const char *com)
{
  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);
  }
}

enum CommandResult parse_alias(const struct Command *cmd, struct Buffer *line,
                               const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  struct Alias *a = NULL;
  enum NotifyAlias event;
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  /* name */
  parse_extract_token(token, line, TOKEN_NONE);
  mutt_debug(LL_DEBUG5, "First token is '%s'\n", buf_string(token));
  if (parse_grouplist(&gl, token, line, err, mod_data->groups) == -1)
    goto done;
 
  char *name = mutt_str_dup(buf_string(token));
 
  /* address list */
  parse_extract_token(token, line, TOKEN_QUOTE | TOKEN_SPACE | TOKEN_SEMICOLON);
  mutt_debug(LL_DEBUG5, "Second token is '%s'\n", buf_string(token));
  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
  int parsed = mutt_addrlist_parse2(&al, buf_string(token));
  if (parsed == 0)
  {
    buf_printf(err, _("Warning: Bad address '%s' in alias '%s'"), buf_string(token), name);
    FREE(&name);
    goto done;
  }
 
  /* IDN */
  char *estr = NULL;
  if (mutt_addrlist_to_intl(&al, &estr))
  {
    buf_printf(err, _("Warning: Bad IDN '%s' in alias '%s'"), estr, name);
    FREE(&name);
    FREE(&estr);
    goto done;
  }
 
  /* check to see if an alias with this name already exists */
  struct Alias **ap = NULL;
  ARRAY_FOREACH(ap, &mod_data->aliases)
  {
    if (mutt_istr_equal((*ap)->name, name))
    {
      a = *ap;
      break;
    }
  }
 
  if (a)
  {
    FREE(&name);
    alias_reverse_delete(mod_data->reverse_aliases, a);
    /* override the previous value */
    mutt_addrlist_clear(&a->addr);
    FREE(&a->comment);
    event = NT_ALIAS_CHANGE;
  }
  else
  {
    /* create a new alias */
    a = alias_new();
    a->name = name;
    ARRAY_ADD(&mod_data->aliases, a);
    event = NT_ALIAS_ADD;
  }
  a->addr = al;
 
  grouplist_add_addrlist(&gl, &a->addr);
 
  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  if (c_debug_level > LL_DEBUG4)
  {
    /* A group is terminated with an empty address, so check addr->mailbox */
    struct Address *addr = NULL;
    TAILQ_FOREACH(addr, &a->addr, entries)
    {
      if (!addr->mailbox)
        break;
 
      if (addr->group)
        mutt_debug(LL_DEBUG5, "  Group %s\n", buf_string(addr->mailbox));
      else
        mutt_debug(LL_DEBUG5, "  %s\n", buf_string(addr->mailbox));
    }
  }
 
  if (!MoreArgs(line) && (line->dptr[0] == '#'))
  {
    line->dptr++; // skip over the "# "
    if (*line->dptr == ' ')
      line->dptr++;
 
    parse_alias_comments(a, line->dptr);
    *line->dptr = '\0'; // We're done parsing
  }
 
  alias_reverse_add(a);
 
  mutt_debug(LL_NOTIFY, "%s: %s\n",
             (event == NT_ALIAS_ADD) ? "NT_ALIAS_ADD" : "NT_ALIAS_CHANGE", a->name);
  struct EventAlias ev_a = { a };
  notify_send(NeoMutt->notify, NT_ALIAS, event, &ev_a);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  grouplist_destroy(&gl);
  return rc;
}

enum CommandResult parse_unalias(const struct Command *cmd, struct Buffer *line,
                                 const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NONE);
 
    struct Alias **ap = NULL;
    if (mutt_str_equal("*", buf_string(token)))
    {
      ARRAY_FOREACH(ap, &mod_data->aliases)
      {
        alias_reverse_delete(mod_data->reverse_aliases, *ap);
      }
 
      aliaslist_clear(&mod_data->aliases);
      goto done;
    }
 
    ARRAY_FOREACH(ap, &mod_data->aliases)
    {
      if (!mutt_istr_equal(buf_string(token), (*ap)->name))
        continue;
 
      struct Alias *a = *ap;
      ARRAY_REMOVE(&mod_data->aliases, ap);
      alias_reverse_delete(mod_data->reverse_aliases, a);
      alias_free(&a);
      break;
    }
  } while (MoreArgs(line));
 
done:
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

const struct Command AliasCommands[] = {
  // clang-format off
  { "alias", CMD_ALIAS, parse_alias,
        N_("Define an alias (name to email address)"),
        N_("alias [ -group <name> ... ] <key> <address> [,...] [ # <comments> ]"),
        "configuration.html#alias" },
  { "alternates", CMD_ALTERNATES, parse_alternates,
        N_("Define a list of alternate email addresses for the user"),
        N_("alternates [ -group <name> ... ] <regex> [ <regex> ... ]"),
        "configuration.html#alternates" },
  { "group", CMD_GROUP, parse_group,
        N_("Add addresses to an address group"),
        N_("group [ -group <name> ... ] { -rx <regex> ... | -addr <address> ... }"),
        "configuration.html#addrgroup" },
  { "lists", CMD_LISTS, parse_lists,
        N_("Add address to the list of mailing lists"),
        N_("lists [ -group <name> ... ] <regex> [ ... ]"),
        "configuration.html#lists" },
  { "subscribe", CMD_SUBSCRIBE, parse_subscribe,
        N_("Add address to the list of subscribed mailing lists"),
        N_("subscribe [ -group <name> ... ] <regex> [ ... ]"),
        "configuration.html#lists" },
  { "unalias", CMD_UNALIAS, parse_unalias,
        N_("Remove an alias definition"),
        N_("unalias { * | <key> ... }"),
        "configuration.html#alias" },
  { "unalternates", CMD_UNALTERNATES, parse_unalternates,
        N_("Remove addresses from `alternates` list"),
        N_("unalternates { * | <regex> ... }"),
        "configuration.html#alternates" },
  { "ungroup", CMD_UNGROUP, parse_group,
        N_("Remove addresses from an address `group`"),
        N_("ungroup [ -group <name> ... ] { * | -rx <regex> ... | -addr <address> ... }"),
        "configuration.html#addrgroup" },
  { "unlists", CMD_UNLISTS, parse_unlists,
        N_("Remove address from the list of mailing lists"),
        N_("unlists { * | <regex> ... }"),
        "configuration.html#lists" },
  { "unsubscribe", CMD_UNSUBSCRIBE, parse_unsubscribe,
        N_("Remove address from the list of subscribed mailing lists"),
        N_("unsubscribe { * | <regex> ... }"),
        "configuration.html#lists" },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NONE },
  // clang-format on
};