hook.h File Reference

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "mutt_commands.h"

Include dependency graph for hook.h:

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

Go to the source code of this file.

Macros
#define	MUTT_HOOK_NO_FLAGS   0
	No flags are set. More...
#define	MUTT_FOLDER_HOOK   (1 << 0)
	folder-hook: when entering a mailbox More...
#define	MUTT_MBOX_HOOK   (1 << 1)
	mbox-hook: move messages after reading them More...
#define	MUTT_SEND_HOOK   (1 << 2)
	send-hook: when composing a new email More...
#define	MUTT_FCC_HOOK   (1 << 3)
	fcc-hook: to save outgoing email More...
#define	MUTT_SAVE_HOOK   (1 << 4)
	save-hook: set a default folder when saving an email More...
#define	MUTT_CHARSET_HOOK   (1 << 5)
	charset-hook: create a charset alias for malformed emails More...
#define	MUTT_ICONV_HOOK   (1 << 6)
	iconv-hook: create a system charset alias More...
#define	MUTT_MESSAGE_HOOK   (1 << 7)
	message-hook: run before displaying a message More...
#define	MUTT_CRYPT_HOOK   (1 << 8)
	crypt-hook: automatically select a PGP/SMIME key More...
#define	MUTT_ACCOUNT_HOOK   (1 << 9)
	account-hook: when changing between accounts More...
#define	MUTT_REPLY_HOOK   (1 << 10)
	reply-hook: when replying to an email More...
#define	MUTT_SEND2_HOOK   (1 << 11)
	send2-hook: when changing fields in the compose menu More...
#define	MUTT_OPEN_HOOK   (1 << 12)
	open-hook: to read a compressed mailbox More...
#define	MUTT_APPEND_HOOK   (1 << 13)
	append-hook: append to a compressed mailbox More...
#define	MUTT_CLOSE_HOOK   (1 << 14)
	close-hook: write to a compressed mailbox More...
#define	MUTT_IDXFMTHOOK   (1 << 15)
	index-format-hook: customise the format of the index More...
#define	MUTT_TIMEOUT_HOOK   (1 << 16)
	timeout-hook: run a command periodically More...
#define	MUTT_STARTUP_HOOK   (1 << 17)
	startup-hook: run when starting NeoMutt More...
#define	MUTT_SHUTDOWN_HOOK   (1 << 18)
	shutdown-hook: run when leaving NeoMutt More...
#define	MUTT_GLOBAL_HOOK   (1 << 19)
	Hooks which don't take a regex. More...

Typedefs
typedef uint32_t	HookFlags
	Flags for mutt_parse_hook(), e.g. MUTT_FOLDER_HOOK. More...

Functions
void	mutt_account_hook (const char *url)
	Perform an account hook. More...
void	mutt_crypt_hook (struct ListHead *list, struct Address *addr)
	Find crypto hooks for an Address. More...
void	mutt_default_save (char *path, size_t pathlen, struct Email *e)
	Find the default save path for an email. More...
void	mutt_delete_hooks (HookFlags type)
	Delete matching hooks. More...
char *	mutt_find_hook (HookFlags type, const char *pat)
	Find a matching hook. More...
void	mutt_folder_hook (const char *path, const char *desc)
	Perform a folder hook. More...
const char *	mutt_idxfmt_hook (const char *name, struct Mailbox *m, struct Email *e)
	Get index-format-hook format string. More...
void	mutt_message_hook (struct Mailbox *m, struct Email *e, HookFlags type)
	Perform a message hook. More...
enum CommandResult	mutt_parse_idxfmt_hook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'index-format-hook' command - Implements Command::parse() More...
enum CommandResult	mutt_parse_hook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'hook' family of commands - Implements Command::parse() More...
enum CommandResult	mutt_parse_unhook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unhook' command - Implements Command::parse() More...
void	mutt_select_fcc (struct Buffer *path, struct Email *e)
	Select the FCC path for an email. More...
void	mutt_startup_shutdown_hook (HookFlags type)
	Execute any startup/shutdown hooks. More...
void	mutt_timeout_hook (void)
	Execute any timeout hooks. More...

Variables
char *	C_DefaultHook
	Config: Pattern to use for hooks that only have a simple regex. More...
bool	C_ForceName
	Config: Save outgoing mail in a folder of their name. More...
bool	C_SaveName
	Config: Save outgoing message to mailbox of recipient's name if it exists. More...

Detailed Description

Parse and execute user-defined hooks

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

Macro Definition Documentation

MUTT_HOOK_NO_FLAGS

#define MUTT_HOOK_NO_FLAGS   0

No flags are set.

Definition at line 44 of file hook.h.

MUTT_FOLDER_HOOK

#define MUTT_FOLDER_HOOK   (1 << 0)

folder-hook: when entering a mailbox

Definition at line 45 of file hook.h.

MUTT_MBOX_HOOK

#define MUTT_MBOX_HOOK   (1 << 1)

mbox-hook: move messages after reading them

Definition at line 46 of file hook.h.

MUTT_SEND_HOOK

#define MUTT_SEND_HOOK   (1 << 2)

send-hook: when composing a new email

Definition at line 47 of file hook.h.

MUTT_FCC_HOOK

#define MUTT_FCC_HOOK   (1 << 3)

fcc-hook: to save outgoing email

Definition at line 48 of file hook.h.

MUTT_SAVE_HOOK

#define MUTT_SAVE_HOOK   (1 << 4)

save-hook: set a default folder when saving an email

Definition at line 49 of file hook.h.

MUTT_CHARSET_HOOK

#define MUTT_CHARSET_HOOK   (1 << 5)

charset-hook: create a charset alias for malformed emails

Definition at line 50 of file hook.h.

MUTT_ICONV_HOOK

#define MUTT_ICONV_HOOK   (1 << 6)

iconv-hook: create a system charset alias

Definition at line 51 of file hook.h.

MUTT_MESSAGE_HOOK

#define MUTT_MESSAGE_HOOK   (1 << 7)

message-hook: run before displaying a message

Definition at line 52 of file hook.h.

MUTT_CRYPT_HOOK

#define MUTT_CRYPT_HOOK   (1 << 8)

crypt-hook: automatically select a PGP/SMIME key

Definition at line 53 of file hook.h.

MUTT_ACCOUNT_HOOK

#define MUTT_ACCOUNT_HOOK   (1 << 9)

account-hook: when changing between accounts

Definition at line 54 of file hook.h.

MUTT_REPLY_HOOK

#define MUTT_REPLY_HOOK   (1 << 10)

reply-hook: when replying to an email

Definition at line 55 of file hook.h.

MUTT_SEND2_HOOK

#define MUTT_SEND2_HOOK   (1 << 11)

send2-hook: when changing fields in the compose menu

Definition at line 56 of file hook.h.

MUTT_OPEN_HOOK

#define MUTT_OPEN_HOOK   (1 << 12)

open-hook: to read a compressed mailbox

Definition at line 58 of file hook.h.

MUTT_APPEND_HOOK

#define MUTT_APPEND_HOOK   (1 << 13)

append-hook: append to a compressed mailbox

Definition at line 59 of file hook.h.

MUTT_CLOSE_HOOK

#define MUTT_CLOSE_HOOK   (1 << 14)

close-hook: write to a compressed mailbox

Definition at line 60 of file hook.h.

MUTT_IDXFMTHOOK

#define MUTT_IDXFMTHOOK   (1 << 15)

index-format-hook: customise the format of the index

Definition at line 62 of file hook.h.

MUTT_TIMEOUT_HOOK

#define MUTT_TIMEOUT_HOOK   (1 << 16)

timeout-hook: run a command periodically

Definition at line 63 of file hook.h.

MUTT_STARTUP_HOOK

#define MUTT_STARTUP_HOOK   (1 << 17)

startup-hook: run when starting NeoMutt

Definition at line 64 of file hook.h.

MUTT_SHUTDOWN_HOOK

#define MUTT_SHUTDOWN_HOOK   (1 << 18)

shutdown-hook: run when leaving NeoMutt

Definition at line 65 of file hook.h.

MUTT_GLOBAL_HOOK

#define MUTT_GLOBAL_HOOK   (1 << 19)

Hooks which don't take a regex.

Definition at line 66 of file hook.h.

Typedef Documentation

HookFlags

typedef uint32_t HookFlags

Flags for mutt_parse_hook(), e.g. MUTT_FOLDER_HOOK.

Definition at line 43 of file hook.h.

Function Documentation

mutt_account_hook()

void mutt_account_hook

(

const char *

url

)

Perform an account hook.

Parameters

url	Account URL to match

Definition at line 756 of file hook.c.

{
  /* parsing commands with URLs in an account hook can cause a recursive
   * call. We just skip processing if this occurs. Typically such commands
   * belong in a folder-hook -- perhaps we should warn the user. */
  static bool inhook = false;
  if (inhook)
    return;
 
  struct Hook *hook = NULL;
  struct Buffer *err = mutt_buffer_pool_get();
 
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (!(hook->command && (hook->type & MUTT_ACCOUNT_HOOK)))
      continue;
 
    if (mutt_regex_match(&hook->regex, url))
    {
      inhook = true;
      mutt_debug(LL_DEBUG1, "account-hook '%s' matches '%s'\n", hook->regex.pattern, url);
      mutt_debug(LL_DEBUG5, "    %s\n", hook->command);
 
      if (mutt_parse_rc_line(hook->command, err) == MUTT_CMD_ERROR)
      {
        mutt_error("%s", mutt_buffer_string(err));
        mutt_buffer_pool_release(&err);
 
        inhook = false;
        goto done;
      }
 
      inhook = false;
    }
  }
done:
  mutt_buffer_pool_release(&err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_crypt_hook()

void mutt_crypt_hook	(	struct ListHead *	list,
		struct Address *	addr
	)

Find crypto hooks for an Address.

Parameters

[out]	list	List of keys
[in]	addr	Address to match

The crypt-hook associates keys with addresses.

Definition at line 747 of file hook.c.

{
  list_hook(list, addr->mailbox, MUTT_CRYPT_HOOK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_default_save()

void mutt_default_save	(	char *	path,
		size_t	pathlen,
		struct Email *	e
	)

Find the default save path for an email.

Parameters

path	Buffer for the path
pathlen	Length of buffer
e	Email

Definition at line 655 of file hook.c.

{
  *path = '\0';
  if (addr_hook(path, pathlen, MUTT_SAVE_HOOK, Context, e) == 0)
    return;
 
  struct Envelope *env = e->env;
  const struct Address *from = TAILQ_FIRST(&env->from);
  const struct Address *reply_to = TAILQ_FIRST(&env->reply_to);
  const struct Address *to = TAILQ_FIRST(&env->to);
  const struct Address *cc = TAILQ_FIRST(&env->cc);
  const struct Address *addr = NULL;
  bool from_me = mutt_addr_is_user(from);
 
  if (!from_me && reply_to && reply_to->mailbox)
    addr = reply_to;
  else if (!from_me && from && from->mailbox)
    addr = from;
  else if (to && to->mailbox)
    addr = to;
  else if (cc && cc->mailbox)
    addr = cc;
  else
    addr = NULL;
  if (addr)
  {
    struct Buffer *tmp = mutt_buffer_pool_get();
    mutt_safe_path(tmp, addr);
    snprintf(path, pathlen, "=%s", mutt_buffer_string(tmp));
    mutt_buffer_pool_release(&tmp);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_delete_hooks()

void mutt_delete_hooks

(

HookFlags

type

)

Delete matching hooks.

Parameters

type	Hook type to delete, see HookFlags

If 0 is passed, all the hooks will be deleted.

Definition at line 307 of file hook.c.

{
  struct Hook *h = NULL;
  struct Hook *tmp = NULL;
 
  TAILQ_FOREACH_SAFE(h, &Hooks, entries, tmp)
  {
    if ((type == MUTT_HOOK_NO_FLAGS) || (type == h->type))
    {
      TAILQ_REMOVE(&Hooks, h, entries);
      delete_hook(h);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_find_hook()

char* mutt_find_hook	(	HookFlags	type,
		const char *	pat
	)

Find a matching hook.

Parameters

type	Hook type, see HookFlags
pat	Pattern to match

Return values

ptr	Command string

Note

The returned string must not be freed.

Definition at line 553 of file hook.c.

{
  struct Hook *tmp = NULL;
 
  TAILQ_FOREACH(tmp, &Hooks, entries)
  {
    if (tmp->type & type)
    {
      if (mutt_regex_match(&tmp->regex, pat))
        return tmp->command;
    }
  }
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_folder_hook()

void mutt_folder_hook	(	const char *	path,
		const char *	desc
	)

Perform a folder hook.

Parameters

path	Path to potentially match
desc	Description to potentially match

Definition at line 505 of file hook.c.

{
  if (!path && !desc)
    return;
 
  struct Hook *hook = NULL;
  struct Buffer *err = mutt_buffer_pool_get();
 
  current_hook_type = MUTT_FOLDER_HOOK;
 
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (!hook->command)
      continue;
 
    if (!(hook->type & MUTT_FOLDER_HOOK))
      continue;
 
    const char *match = NULL;
    if (mutt_regex_match(&hook->regex, path))
      match = path;
    else if (mutt_regex_match(&hook->regex, desc))
      match = desc;
 
    if (match)
    {
      mutt_debug(LL_DEBUG1, "folder-hook '%s' matches '%s'\n", hook->regex.pattern, match);
      mutt_debug(LL_DEBUG5, "    %s\n", hook->command);
      if (mutt_parse_rc_line(hook->command, err) == MUTT_CMD_ERROR)
      {
        mutt_error("%s", mutt_buffer_string(err));
        break;
      }
    }
  }
  mutt_buffer_pool_release(&err);
 
  current_hook_type = MUTT_HOOK_NO_FLAGS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_idxfmt_hook()

const char* mutt_idxfmt_hook	(	const char *	name,
		struct Mailbox *	m,
		struct Email *	e
	)

Get index-format-hook format string.

Parameters

name	Hook name
m	Mailbox
e	Email

Return values

ptr	printf(3)-like format string
NULL	No matching hook

Definition at line 867 of file hook.c.

{
  if (!IdxFmtHooks)
    return NULL;
 
  struct HookList *hl = mutt_hash_find(IdxFmtHooks, name);
  if (!hl)
    return NULL;
 
  current_hook_type = MUTT_IDXFMTHOOK;
 
  struct PatternCache cache = { 0 };
  const char *fmtstring = NULL;
  struct Hook *hook = NULL;
 
  TAILQ_FOREACH(hook, hl, entries)
  {
    struct Pattern *pat = SLIST_FIRST(hook->pattern);
    if ((mutt_pattern_exec(pat, 0, m, e, &cache) > 0) ^ hook->regex.pat_not)
    {
      fmtstring = hook->command;
      break;
    }
  }
 
  current_hook_type = MUTT_HOOK_NO_FLAGS;
 
  return fmtstring;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_message_hook()

void mutt_message_hook	(	struct Mailbox *	m,
		struct Email *	e,
		HookFlags	type
	)

Perform a message hook.

Parameters

m	Mailbox Context
e	Email
type	Hook type, see HookFlags

Definition at line 574 of file hook.c.

{
  struct Hook *hook = NULL;
  struct PatternCache cache = { 0 };
  struct Buffer *err = mutt_buffer_pool_get();
 
  current_hook_type = type;
 
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (!hook->command)
      continue;
 
    if (hook->type & type)
    {
      if ((mutt_pattern_exec(SLIST_FIRST(hook->pattern), 0, m, e, &cache) > 0) ^
          hook->regex.pat_not)
      {
        if (mutt_parse_rc_line(hook->command, err) == MUTT_CMD_ERROR)
        {
          mutt_error("%s", mutt_buffer_string(err));
          current_hook_type = MUTT_HOOK_NO_FLAGS;
          mutt_buffer_pool_release(&err);
 
          return;
        }
        /* Executing arbitrary commands could affect the pattern results,
         * so the cache has to be wiped */
        memset(&cache, 0, sizeof(cache));
      }
    }
  }
  mutt_buffer_pool_release(&err);
 
  current_hook_type = MUTT_HOOK_NO_FLAGS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_idxfmt_hook()

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

Parse the 'index-format-hook' command - Implements Command::parse()

Definition at line 351 of file hook.c.

{
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
 
  struct Buffer *name = mutt_buffer_pool_get();
  struct Buffer *pattern = mutt_buffer_pool_get();
  struct Buffer *fmtstring = mutt_buffer_pool_get();
 
  if (!IdxFmtHooks)
  {
    IdxFmtHooks = mutt_hash_new(30, MUTT_HASH_STRDUP_KEYS);
    mutt_hash_set_destructor(IdxFmtHooks, delete_idxfmt_hooklist, 0);
  }
 
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
    goto out;
  }
  mutt_extract_token(name, s, MUTT_TOKEN_NO_FLAGS);
  struct HookList *hl = mutt_hash_find(IdxFmtHooks, mutt_buffer_string(name));
 
  if (*s->dptr == '!')
  {
    s->dptr++;
    SKIPWS(s->dptr);
    pat_not = true;
  }
  mutt_extract_token(pattern, s, MUTT_TOKEN_NO_FLAGS);
 
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
    goto out;
  }
  mutt_extract_token(fmtstring, s, MUTT_TOKEN_NO_FLAGS);
 
  if (MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too many arguments"), buf->data);
    goto out;
  }
 
  if (C_DefaultHook)
    mutt_check_simple(pattern, C_DefaultHook);
 
  /* check to make sure that a matching hook doesn't already exist */
  struct Hook *hook = NULL;
  if (hl)
  {
    TAILQ_FOREACH(hook, hl, entries)
    {
      if ((hook->regex.pat_not == pat_not) &&
          mutt_str_equal(mutt_buffer_string(pattern), hook->regex.pattern))
      {
        mutt_str_replace(&hook->command, mutt_buffer_string(fmtstring));
        rc = MUTT_CMD_SUCCESS;
        goto out;
      }
    }
  }
 
  /* MUTT_PC_PATTERN_DYNAMIC sets so that date ranges are regenerated during
   * matching.  This of course is slower, but index-format-hook is commonly
   * used for date ranges, and they need to be evaluated relative to "now", not
   * the hook compilation time.  */
  struct PatternList *pat =
      mutt_pattern_comp(Context, mutt_buffer_string(pattern),
                        MUTT_PC_FULL_MSG | MUTT_PC_PATTERN_DYNAMIC, err);
  if (!pat)
    goto out;
 
  hook = mutt_mem_calloc(1, sizeof(struct Hook));
  hook->type = MUTT_IDXFMTHOOK;
  hook->command = mutt_buffer_strdup(fmtstring);
  hook->pattern = pat;
  hook->regex.pattern = mutt_buffer_strdup(pattern);
  hook->regex.regex = NULL;
  hook->regex.pat_not = pat_not;
 
  if (!hl)
  {
    hl = mutt_mem_calloc(1, sizeof(*hl));
    TAILQ_INIT(hl);
    mutt_hash_insert(IdxFmtHooks, mutt_buffer_string(name), hl);
  }
 
  TAILQ_INSERT_TAIL(hl, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
out:
  mutt_buffer_pool_release(&name);
  mutt_buffer_pool_release(&pattern);
  mutt_buffer_pool_release(&fmtstring);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_hook()

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

Parse the 'hook' family of commands - Implements Command::parse()

This is used by 'account-hook', 'append-hook' and many more.

Definition at line 85 of file hook.c.

{
  struct Hook *hook = NULL;
  int rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  regex_t *rx = NULL;
  struct PatternList *pat = NULL;
 
  struct Buffer *cmd = mutt_buffer_pool_get();
  struct Buffer *pattern = mutt_buffer_pool_get();
 
  if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
  {
    if (*s->dptr == '!')
    {
      s->dptr++;
      SKIPWS(s->dptr);
      pat_not = true;
    }
 
    mutt_extract_token(pattern, s, MUTT_TOKEN_NO_FLAGS);
 
    if (!MoreArgs(s))
    {
      mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
      rc = MUTT_CMD_WARNING;
      goto cleanup;
    }
  }
 
  mutt_extract_token(cmd, s,
                     (data & (MUTT_FOLDER_HOOK | MUTT_SEND_HOOK | MUTT_SEND2_HOOK |
                              MUTT_ACCOUNT_HOOK | MUTT_REPLY_HOOK)) ?
                         MUTT_TOKEN_SPACE :
                         MUTT_TOKEN_NO_FLAGS);
 
  if (mutt_buffer_is_empty(cmd))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too many arguments"), buf->data);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (data & (MUTT_FOLDER_HOOK | MUTT_MBOX_HOOK))
  {
    /* Accidentally using the ^ mailbox shortcut in the .neomuttrc is a
     * common mistake */
    if ((pattern->data[0] == '^') && !CurrentFolder)
    {
      mutt_buffer_strcpy(err, _("current mailbox shortcut '^' is unset"));
      goto cleanup;
    }
 
    struct Buffer *tmp = mutt_buffer_pool_get();
    mutt_buffer_copy(tmp, pattern);
    mutt_buffer_expand_path_regex(tmp, true);
 
    /* Check for other mailbox shortcuts that expand to the empty string.
     * This is likely a mistake too */
    if (mutt_buffer_is_empty(tmp) && !mutt_buffer_is_empty(pattern))
    {
      mutt_buffer_strcpy(err, _("mailbox shortcut expanded to empty regex"));
      mutt_buffer_pool_release(&tmp);
      goto cleanup;
    }
 
    mutt_buffer_copy(pattern, tmp);
    mutt_buffer_pool_release(&tmp);
  }
#ifdef USE_COMP_MBOX
  else if (data & (MUTT_APPEND_HOOK | MUTT_OPEN_HOOK | MUTT_CLOSE_HOOK))
  {
    if (mutt_comp_valid_command(mutt_buffer_string(cmd)) == 0)
    {
      mutt_buffer_strcpy(err, _("badly formatted command string"));
      goto cleanup;
    }
  }
#endif
  else if (C_DefaultHook && (~data & MUTT_GLOBAL_HOOK) &&
           !(data & (MUTT_CHARSET_HOOK | MUTT_ICONV_HOOK | MUTT_ACCOUNT_HOOK)) &&
           (!WithCrypto || !(data & MUTT_CRYPT_HOOK)))
  {
    /* At this stage remain only message-hooks, reply-hooks, send-hooks,
     * send2-hooks, save-hooks, and fcc-hooks: All those allowing full
     * patterns. If given a simple regex, we expand $default_hook.  */
    mutt_check_simple(pattern, C_DefaultHook);
  }
 
  if (data & (MUTT_MBOX_HOOK | MUTT_SAVE_HOOK | MUTT_FCC_HOOK))
  {
    mutt_buffer_expand_path(cmd);
  }
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (data & MUTT_GLOBAL_HOOK)
    {
      /* Ignore duplicate global hooks */
      if (mutt_str_equal(hook->command, mutt_buffer_string(cmd)))
      {
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
    else if ((hook->type == data) && (hook->regex.pat_not == pat_not) &&
             mutt_str_equal(mutt_buffer_string(pattern), hook->regex.pattern))
    {
      if (data & (MUTT_FOLDER_HOOK | MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_MESSAGE_HOOK |
                  MUTT_ACCOUNT_HOOK | MUTT_REPLY_HOOK | MUTT_CRYPT_HOOK |
                  MUTT_TIMEOUT_HOOK | MUTT_STARTUP_HOOK | MUTT_SHUTDOWN_HOOK))
      {
        /* these hooks allow multiple commands with the same
         * pattern, so if we've already seen this pattern/command pair, just
         * ignore it instead of creating a duplicate */
        if (mutt_str_equal(hook->command, mutt_buffer_string(cmd)))
        {
          rc = MUTT_CMD_SUCCESS;
          goto cleanup;
        }
      }
      else
      {
        /* other hooks only allow one command per pattern, so update the
         * entry with the new command.  this currently does not change the
         * order of execution of the hooks, which i think is desirable since
         * a common action to perform is to change the default (.) entry
         * based upon some other information. */
        FREE(&hook->command);
        hook->command = mutt_buffer_strdup(cmd);
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
  }
 
  if (data & (MUTT_CHARSET_HOOK | MUTT_ICONV_HOOK))
  {
    /* These are managed separately by the charset code */
    enum LookupType type = (data & MUTT_CHARSET_HOOK) ? MUTT_LOOKUP_CHARSET : MUTT_LOOKUP_ICONV;
    if (mutt_ch_lookup_add(type, mutt_buffer_string(pattern), mutt_buffer_string(cmd), err))
      rc = MUTT_CMD_SUCCESS;
    goto cleanup;
  }
  else if (data & (MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_SAVE_HOOK |
                   MUTT_FCC_HOOK | MUTT_MESSAGE_HOOK | MUTT_REPLY_HOOK))
  {
    PatternCompFlags comp_flags;
 
    if (data & (MUTT_SEND2_HOOK))
      comp_flags = MUTT_PC_SEND_MODE_SEARCH;
    else if (data & (MUTT_SEND_HOOK | MUTT_FCC_HOOK))
      comp_flags = MUTT_PC_NO_FLAGS;
    else
      comp_flags = MUTT_PC_FULL_MSG;
 
    pat = mutt_pattern_comp(Context, mutt_buffer_string(pattern), comp_flags, err);
    if (!pat)
      goto cleanup;
  }
  else if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
  {
    /* Hooks not allowing full patterns: Check syntax of regex */
    rx = mutt_mem_malloc(sizeof(regex_t));
    int rc2 = REG_COMP(rx, NONULL(mutt_buffer_string(pattern)),
                       ((data & MUTT_CRYPT_HOOK) ? REG_ICASE : 0));
    if (rc2 != 0)
    {
      regerror(rc2, rx, err->data, err->dsize);
      FREE(&rx);
      goto cleanup;
    }
  }
 
  hook = mutt_mem_calloc(1, sizeof(struct Hook));
  hook->type = data;
  hook->command = mutt_buffer_strdup(cmd);
  hook->pattern = pat;
  hook->regex.pattern = mutt_buffer_strdup(pattern);
  hook->regex.regex = rx;
  hook->regex.pat_not = pat_not;
  TAILQ_INSERT_TAIL(&Hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  mutt_buffer_pool_release(&cmd);
  mutt_buffer_pool_release(&pattern);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_unhook()

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

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

Definition at line 454 of file hook.c.

{
  while (MoreArgs(s))
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf->data))
    {
      if (current_hook_type != MUTT_TOKEN_NO_FLAGS)
      {
        mutt_buffer_printf(err, "%s", _("unhook: Can't do unhook * from within a hook"));
        return MUTT_CMD_WARNING;
      }
      mutt_delete_hooks(MUTT_HOOK_NO_FLAGS);
      delete_idxfmt_hooks();
      mutt_ch_lookup_remove();
    }
    else
    {
      HookFlags type = mutt_get_hook_type(buf->data);
 
      if (type == MUTT_HOOK_NO_FLAGS)
      {
        mutt_buffer_printf(err, _("unhook: unknown hook type: %s"), buf->data);
        return MUTT_CMD_ERROR;
      }
      if (type & (MUTT_CHARSET_HOOK | MUTT_ICONV_HOOK))
      {
        mutt_ch_lookup_remove();
        return MUTT_CMD_SUCCESS;
      }
      if (current_hook_type == type)
      {
        mutt_buffer_printf(err, _("unhook: Can't delete a %s from within a %s"),
                           buf->data, buf->data);
        return MUTT_CMD_WARNING;
      }
      if (type == MUTT_IDXFMTHOOK)
        delete_idxfmt_hooks();
      else
        mutt_delete_hooks(type);
    }
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_select_fcc()

void mutt_select_fcc	(	struct Buffer *	path,
		struct Email *	e
	)

Select the FCC path for an email.

Parameters

path	Buffer for the path
e	Email

Definition at line 693 of file hook.c.

{
  mutt_buffer_alloc(path, PATH_MAX);
 
  if (addr_hook(path->data, path->dsize, MUTT_FCC_HOOK, NULL, e) != 0)
  {
    const struct Address *to = TAILQ_FIRST(&e->env->to);
    const struct Address *cc = TAILQ_FIRST(&e->env->cc);
    const struct Address *bcc = TAILQ_FIRST(&e->env->bcc);
    if ((C_SaveName || C_ForceName) && (to || cc || bcc))
    {
      const struct Address *addr = to ? to : (cc ? cc : bcc);
      struct Buffer *buf = mutt_buffer_pool_get();
      mutt_safe_path(buf, addr);
      mutt_buffer_concat_path(path, NONULL(C_Folder), mutt_buffer_string(buf));
      mutt_buffer_pool_release(&buf);
      if (!C_ForceName && (mx_access(mutt_buffer_string(path), W_OK) != 0))
        mutt_buffer_strcpy(path, C_Record);
    }
    else
      mutt_buffer_strcpy(path, C_Record);
  }
  else
    mutt_buffer_fix_dptr(path);
 
  mutt_buffer_pretty_mailbox(path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_startup_shutdown_hook()

void mutt_startup_shutdown_hook

(

HookFlags

type

)

Execute any startup/shutdown hooks.

Parameters

type	Hook type: MUTT_STARTUP_HOOK or MUTT_SHUTDOWN_HOOK

The user can configure hooks to be run on startup/shutdown. This function finds all the matching hooks and executes them.

Definition at line 837 of file hook.c.

{
  struct Hook *hook = NULL;
  struct Buffer err = mutt_buffer_make(0);
  char buf[256];
 
  err.data = buf;
  err.dsize = sizeof(buf);
 
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (!(hook->command && (hook->type & type)))
      continue;
 
    if (mutt_parse_rc_line(hook->command, &err) == MUTT_CMD_ERROR)
    {
      mutt_error("%s", err.data);
      mutt_buffer_reset(&err);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_timeout_hook()

void mutt_timeout_hook

(

void

)

Execute any timeout hooks.

The user can configure hooks to be run on timeout. This function finds all the matching hooks and executes them.

Definition at line 801 of file hook.c.

{
  struct Hook *hook = NULL;
  struct Buffer err;
  char buf[256];
 
  mutt_buffer_init(&err);
  err.data = buf;
  err.dsize = sizeof(buf);
 
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (!(hook->command && (hook->type & MUTT_TIMEOUT_HOOK)))
      continue;
 
    if (mutt_parse_rc_line(hook->command, &err) == MUTT_CMD_ERROR)
    {
      mutt_error("%s", err.data);
      mutt_buffer_reset(&err);
 
      /* The hooks should be independent of each other, so even though this on
       * failed, we'll carry on with the others. */
    }
  }
 
  /* Delete temporary attachment files */
  mutt_unlink_temp_attachments();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

C_DefaultHook

char* C_DefaultHook

Config: Pattern to use for hooks that only have a simple regex.

Definition at line 58 of file hook.c.

C_ForceName

bool C_ForceName

Config: Save outgoing mail in a folder of their name.

Definition at line 59 of file hook.c.

C_SaveName

bool C_SaveName

Config: Save outgoing message to mailbox of recipient's name if it exists.

Definition at line 60 of file hook.c.