commands.c File Reference

Alias commands. More...

#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"

Include dependency graph for commands.c:

Go to the source code of this file.

Functions
void	mutt_auto_subscribe (const char *mailto)
	Check if user is subscribed to mailing list.
void	alias_tags_to_buffer (struct TagList *tl, struct Buffer *buf)
	Write a comma-separated list of tags to a Buffer.
void	parse_alias_tags (const char *tags, struct TagList *tl)
	Parse a comma-separated list of tags.
void	parse_alias_comments (struct Alias *alias, const char *com)
	Parse the alias/query comment field.
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() -.

Variables
const struct Command	AliasCommands []
	Alias Commands.

Detailed Description

Alias commands.

Authors

• Pietro Cerutti
• 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 commands.c.

Function Documentation

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:

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_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:

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:

Variable Documentation

AliasCommands

const struct Command AliasCommands[]

Alias Commands.

Definition at line 361 of file commands.c.

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