hook.c File Reference

Parse and execute user-defined hooks. More...

#include "config.h"
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "hook.h"
#include "attach/lib.h"
#include "compmbox/lib.h"
#include "expando/lib.h"
#include "index/lib.h"
#include "ncrypt/lib.h"
#include "parse/lib.h"
#include "pattern/lib.h"
#include "commands.h"
#include "globals.h"
#include "muttlib.h"
#include "mx.h"

Include dependency graph for hook.c:

Go to the source code of this file.

Data Structures
struct	Hook
	A list of user hooks. More...

Functions
	TAILQ_HEAD (HookList, Hook)
static void	hook_free (struct Hook **ptr)
	Free a Hook.
static struct Hook *	hook_new (void)
	Create a Hook.
enum CommandResult	mutt_parse_charset_iconv_hook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse 'charset-hook' and 'iconv-hook' commands - Implements Command::parse() -.
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() -.
void	mutt_delete_hooks (HookFlags type)
	Delete matching hooks.
static void	idxfmt_hashelem_free (int type, void *obj, intptr_t data)
	Free our hash table data - Implements hash_hdata_free_t -.
static void	delete_idxfmt_hooks (void)
	Delete all the index-format-hooks.
static 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() -.
static HookFlags	mutt_get_hook_type (const char *name)
	Find a hook by name.
static enum CommandResult	mutt_parse_unhook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unhook' command - Implements Command::parse() -.
void	mutt_folder_hook (const char *path, const char *desc)
	Perform a folder hook.
char *	mutt_find_hook (HookFlags type, const char *pat)
	Find a matching hook.
void	mutt_message_hook (struct Mailbox *m, struct Email *e, HookFlags type)
	Perform a message hook.
static int	addr_hook (struct Buffer *path, HookFlags type, struct Mailbox *m, struct Email *e)
	Perform an address hook (get a path)
void	mutt_default_save (struct Buffer *path, struct Email *e)
	Find the default save path for an email.
void	mutt_select_fcc (struct Buffer *path, struct Email *e)
	Select the FCC path for an email.
static void	list_hook (struct ListHead *matches, const char *match, HookFlags type)
	Find hook strings matching.
void	mutt_crypt_hook (struct ListHead *list, struct Address *addr)
	Find crypto hooks for an Address.
void	mutt_account_hook (const char *url)
	Perform an account hook.
void	mutt_timeout_hook (void)
	Execute any timeout hooks.
void	mutt_startup_shutdown_hook (HookFlags type)
	Execute any startup/shutdown hooks.
const struct Expando *	mutt_idxfmt_hook (const char *name, struct Mailbox *m, struct Email *e)
	Get index-format-hook format string.
void	hooks_init (void)
	Setup feature commands.

Variables
const struct ExpandoDefinition	IndexFormatDef []
	Expando definitions.
static struct HookList	Hooks = TAILQ_HEAD_INITIALIZER(Hooks)
	All simple hooks, e.g. MUTT_FOLDER_HOOK.
static struct HashTable *	IdxFmtHooks = NULL
	All Index Format hooks.
static HookFlags	CurrentHookType = MUTT_HOOK_NO_FLAGS
	The type of the hook currently being executed, e.g. MUTT_SAVE_HOOK.
static const struct Command	HookCommands []
	Hook Commands.

Detailed Description

Parse and execute user-defined hooks.

Authors

• Michael R. Elkins, and others
• Thomas Adam
• Richard Russon
• Pietro Cerutti
• Federico Kircheis
• Naveen Nathan
• Oliver Bandel
• Dennis Schön
• Tóth János

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.c.

Function Documentation

TAILQ_HEAD()

TAILQ_HEAD	(	HookList	,
		Hook
	)

hook_free()

static void hook_free ( struct Hook **  ptr )

static

Free a Hook.

Parameters

ptr	Hook to free

Definition at line 91 of file hook.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct Hook *h = *ptr;
 
  FREE(&h->command);
  FREE(&h->source_file);
  FREE(&h->regex.pattern);
  if (h->regex.regex)
  {
    regfree(h->regex.regex);
    FREE(&h->regex.regex);
  }
  mutt_pattern_free(&h->pattern);
  expando_free(&h->expando);
  FREE(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

hook_new()

static struct Hook * hook_new ( void  )

static

Create a Hook.

Return values

ptr

New Hook

Definition at line 115 of file hook.c.

{
  return MUTT_MEM_CALLOC(1, struct Hook);
}

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 MUTT_HOOK_NO_FLAGS is passed, all the hooks will be deleted.

Definition at line 398 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);
      hook_free(&h);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

delete_idxfmt_hooks()

static void delete_idxfmt_hooks ( void  )

static

Delete all the index-format-hooks.

Definition at line 434 of file hook.c.

{
  mutt_hash_free(&IdxFmtHooks);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_hook_type()

static HookFlags mutt_get_hook_type ( const char *  name )

static

Find a hook by name.

Parameters

name	Name to find

Return values

num	Hook ID, e.g. MUTT_FOLDER_HOOK
MUTT_HOOK_NO_FLAGS	Error, no matching hook

Definition at line 562 of file hook.c.

{
  const struct Command **cp = NULL;
  ARRAY_FOREACH(cp, &NeoMutt->commands)
  {
    const struct Command *cmd = *cp;
 
    if (((cmd->parse == mutt_parse_hook) || (cmd->parse == mutt_parse_idxfmt_hook)) &&
        mutt_istr_equal(cmd->name, name))
    {
      return cmd->data;
    }
  }
  return MUTT_HOOK_NO_FLAGS;
}

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 632 of file hook.c.

{
  if (!path && !desc)
    return;
 
  struct Hook *hook = NULL;
  struct Buffer *err = buf_pool_get();
 
  CurrentHookType = 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 (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
      {
        mutt_error("%s", buf_string(err));
        break;
      }
    }
  }
  buf_pool_release(&err);
 
  CurrentHookType = MUTT_HOOK_NO_FLAGS;
}

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 680 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_message_hook()

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

Perform a message hook.

Parameters

m	Mailbox
e	Email
type	Hook type, see HookFlags

Definition at line 701 of file hook.c.

{
  struct Hook *hook = NULL;
  struct PatternCache cache = { 0 };
  struct Buffer *err = buf_pool_get();
 
  CurrentHookType = 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 (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
        {
          mutt_error("%s", buf_string(err));
          CurrentHookType = MUTT_HOOK_NO_FLAGS;
          buf_pool_release(&err);
 
          return;
        }
        /* Executing arbitrary commands could affect the pattern results,
         * so the cache has to be wiped */
        memset(&cache, 0, sizeof(cache));
      }
    }
  }
  buf_pool_release(&err);
 
  CurrentHookType = MUTT_HOOK_NO_FLAGS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

addr_hook()

static int addr_hook ( struct Buffer *  path, HookFlags  type, struct Mailbox *  m, struct Email *  e  )

static

Perform an address hook (get a path)

Parameters

path	Buffer for path
type	Hook type, see HookFlags
m	Mailbox
e	Email

Return values

0	Success
-1	Failure

Definition at line 747 of file hook.c.

{
  struct Hook *hook = NULL;
  struct PatternCache cache = { 0 };
 
  /* determine if a matching hook exists */
  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)
      {
        buf_alloc(path, PATH_MAX);
        mutt_make_string(path, -1, hook->expando, m, -1, e, MUTT_FORMAT_PLAIN, NULL);
        buf_fix_dptr(path);
        return 0;
      }
    }
  }
 
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_default_save()

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

Find the default save path for an email.

Parameters

path	Buffer for the path
e	Email

Definition at line 779 of file hook.c.

{
  struct Mailbox *m_cur = get_current_mailbox();
  if (addr_hook(path, MUTT_SAVE_HOOK, m_cur, 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 = buf_pool_get();
    mutt_safe_path(tmp, addr);
    buf_add_printf(path, "=%s", buf_string(tmp));
    buf_pool_release(&tmp);
  }
}

Here is the call graph for this function:

Here is the caller 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 817 of file hook.c.

{
  buf_alloc(path, PATH_MAX);
 
  if (addr_hook(path, 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);
    const bool c_save_name = cs_subset_bool(NeoMutt->sub, "save_name");
    const bool c_force_name = cs_subset_bool(NeoMutt->sub, "force_name");
    const char *const c_record = cs_subset_string(NeoMutt->sub, "record");
    if ((c_save_name || c_force_name) && (to || cc || bcc))
    {
      const struct Address *addr = to ? to : (cc ? cc : bcc);
      struct Buffer *buf = buf_pool_get();
      mutt_safe_path(buf, addr);
      const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
      buf_concat_path(path, NONULL(c_folder), buf_string(buf));
      buf_pool_release(&buf);
      if (!c_force_name && (mx_access(buf_string(path), W_OK) != 0))
        buf_strcpy(path, c_record);
    }
    else
    {
      buf_strcpy(path, c_record);
    }
  }
  else
  {
    buf_fix_dptr(path);
  }
 
  buf_pretty_mailbox(path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

list_hook()

static void list_hook ( struct ListHead *  matches, const char *  match, HookFlags  type  )

static

Find hook strings matching.

Parameters

[out]	matches	List of hook strings
[in]	match	String to match
[in]	type	Hook type, see HookFlags

Definition at line 859 of file hook.c.

{
  struct Hook *tmp = NULL;
 
  TAILQ_FOREACH(tmp, &Hooks, entries)
  {
    if ((tmp->type & type) && mutt_regex_match(&tmp->regex, match))
    {
      mutt_list_insert_tail(matches, mutt_str_dup(tmp->command));
    }
  }
}

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 879 of file hook.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_account_hook()

void mutt_account_hook

(

const char *

url

)

Perform an account hook.

Parameters

url	Account URL to match

Definition at line 888 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 = buf_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 (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
      {
        mutt_error("%s", buf_string(err));
        buf_pool_release(&err);
 
        inhook = false;
        goto done;
      }
 
      inhook = false;
    }
  }
done:
  buf_pool_release(&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 933 of file hook.c.

{
  struct Hook *hook = NULL;
  struct Buffer *err = buf_pool_get();
 
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (!(hook->command && (hook->type & MUTT_TIMEOUT_HOOK)))
      continue;
 
    if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
    {
      mutt_error("%s", buf_string(err));
      buf_reset(err);
 
      /* The hooks should be independent of each other, so even though this on
       * failed, we'll carry on with the others. */
    }
  }
  buf_pool_release(&err);
 
  /* Delete temporary attachment files */
  mutt_temp_attachments_cleanup();
}

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 965 of file hook.c.

{
  struct Hook *hook = NULL;
  struct Buffer *err = buf_pool_get();
 
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (!(hook->command && (hook->type & type)))
      continue;
 
    if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
    {
      mutt_error("%s", buf_string(err));
      buf_reset(err);
    }
  }
  buf_pool_release(&err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_idxfmt_hook()

const struct Expando * 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	Expando
NULL	No matching hook

Definition at line 992 of file hook.c.

{
  if (!IdxFmtHooks)
    return NULL;
 
  struct HookList *hl = mutt_hash_find(IdxFmtHooks, name);
  if (!hl)
    return NULL;
 
  CurrentHookType = MUTT_IDXFMTHOOK;
 
  struct PatternCache cache = { 0 };
  const struct Expando *exp = 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)
    {
      exp = hook->expando;
      break;
    }
  }
 
  CurrentHookType = MUTT_HOOK_NO_FLAGS;
 
  return exp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hooks_init()

void hooks_init

(

void

)

Setup feature commands.

Definition at line 1053 of file hook.c.

{
  commands_register(&NeoMutt->commands, HookCommands);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

IndexFormatDef

const struct ExpandoDefinition IndexFormatDef

extern

Expando definitions.

Config:

• $attribution_intro
• $attribution_trailer
• $forward_attribution_intro
• $forward_attribution_trailer
• $forward_format
• $index_format
• $message_format
• $pager_format

Note

Longer Expandos must precede any similar, but shorter Expandos

Definition at line 312 of file mutt_config.c.

Hooks

struct HookList Hooks = TAILQ_HEAD_INITIALIZER(Hooks)

static

All simple hooks, e.g. MUTT_FOLDER_HOOK.

Definition at line 79 of file hook.c.

IdxFmtHooks

struct HashTable* IdxFmtHooks = NULL

static

All Index Format hooks.

Definition at line 82 of file hook.c.

CurrentHookType

HookFlags CurrentHookType = MUTT_HOOK_NO_FLAGS

static

The type of the hook currently being executed, e.g. MUTT_SAVE_HOOK.

Definition at line 85 of file hook.c.

HookCommands

const struct Command HookCommands[]

static

Initial value:

= {
  
  { "account-hook",      mutt_parse_hook,               MUTT_ACCOUNT_HOOK },
  { "charset-hook",      mutt_parse_charset_iconv_hook, MUTT_CHARSET_HOOK },
  { "crypt-hook",        mutt_parse_hook,               MUTT_CRYPT_HOOK },
  { "fcc-hook",          mutt_parse_hook,               MUTT_FCC_HOOK },
  { "fcc-save-hook",     mutt_parse_hook,               MUTT_FCC_HOOK | MUTT_SAVE_HOOK },
  { "folder-hook",       mutt_parse_hook,               MUTT_FOLDER_HOOK },
  { "iconv-hook",        mutt_parse_charset_iconv_hook, MUTT_ICONV_HOOK },
  { "index-format-hook", mutt_parse_idxfmt_hook,        MUTT_IDXFMTHOOK },
  { "mbox-hook",         mutt_parse_hook,               MUTT_MBOX_HOOK },
  { "message-hook",      mutt_parse_hook,               MUTT_MESSAGE_HOOK },
  { "pgp-hook",          mutt_parse_hook,               MUTT_CRYPT_HOOK },
  { "reply-hook",        mutt_parse_hook,               MUTT_REPLY_HOOK },
  { "save-hook",         mutt_parse_hook,               MUTT_SAVE_HOOK },
  { "send-hook",         mutt_parse_hook,               MUTT_SEND_HOOK },
  { "send2-hook",        mutt_parse_hook,               MUTT_SEND2_HOOK },
  { "shutdown-hook",     mutt_parse_hook,               MUTT_SHUTDOWN_HOOK | MUTT_GLOBAL_HOOK },
  { "startup-hook",      mutt_parse_hook,               MUTT_STARTUP_HOOK | MUTT_GLOBAL_HOOK },
  { "timeout-hook",      mutt_parse_hook,               MUTT_TIMEOUT_HOOK | MUTT_GLOBAL_HOOK },
  { "unhook",            mutt_parse_unhook,             0 },
  { NULL, NULL, 0 },
  
}

Hook Commands.

Definition at line 1025 of file hook.c.