exec.h File Reference

Execute user-defined Hooks. More...

#include "core/lib.h"

Include dependency graph for exec.h:

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

Go to the source code of this file.

Functions
void	exec_account_hook (const char *url)
	Perform an account hook.
void	exec_folder_hook (const char *path, const char *desc)
	Perform a folder hook.
void	exec_message_hook (struct Mailbox *m, struct Email *e, enum CommandId id)
	Perform a message hook.
void	exec_startup_shutdown_hook (enum CommandId id)
	Execute any startup/shutdown hooks.
void	exec_timeout_hook (void)
	Execute any timeout hooks.
void	mutt_crypt_hook (struct ListHead *list, struct Address *addr)
	Find crypto hooks for an Address.
void	mutt_default_save (struct Buffer *path, struct Email *e)
	Find the default save path for an email.
void	mutt_delete_hooks (struct HookList *hooks, enum CommandId id)
	Delete matching hooks.
struct Hook *	mutt_find_hook (enum CommandId id, const char *pat)
	Find a matching hook.
const struct Expando *	mutt_idxfmt_hook (const char *name, struct Mailbox *m, struct Email *e)
	Get index-format-hook format string.
void	mutt_select_fcc (struct Buffer *path, struct Email *e)
	Select the FCC path for an email.

Detailed Description

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

Function Documentation

exec_account_hook()

void exec_account_hook

(

const char *

url

)

Perform an account hook.

Parameters

url	Account URL to match

Definition at line 328 of file exec.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 HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  struct ParseContext *pc = parse_context_new();
  struct ParseError *pe = parse_error_new();
 
  mod_data->current_hook_id = CMD_ACCOUNT_HOOK;
 
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if (!(hook->command && (hook->id == CMD_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, pc, pe) == MUTT_CMD_ERROR)
      {
        mutt_error("%s", buf_string(pe->message));
        inhook = false;
        goto done;
      }
 
      inhook = false;
    }
  }
 
done:
  mod_data->current_hook_id = CMD_NONE;
  parse_context_free(&pc);
  parse_error_free(&pe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

exec_folder_hook()

void exec_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 64 of file exec.c.

{
  if (!path && !desc)
    return;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  struct ParseContext *pc = parse_context_new();
  struct ParseError *pe = parse_error_new();
 
  mod_data->current_hook_id = CMD_FOLDER_HOOK;
 
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if (!hook->command)
      continue;
 
    if (!(hook->id == CMD_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, pc, pe) == MUTT_CMD_ERROR)
      {
        mutt_error("%s", buf_string(pe->message));
        break;
      }
    }
  }
 
  mod_data->current_hook_id = CMD_NONE;
  parse_context_free(&pc);
  parse_error_free(&pe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

exec_message_hook()

void exec_message_hook	(	struct Mailbox *	m,
		struct Email *	e,
		enum CommandId	id )

Perform a message hook.

Parameters

m	Mailbox
e	Email
id	Hook CommandId, e.g CMD_FOLDER_HOOK

Definition at line 137 of file exec.c.

{
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  struct PatternCache cache = { 0 };
  struct ParseContext *pc = parse_context_new();
  struct ParseError *pe = parse_error_new();
 
  mod_data->current_hook_id = id;
 
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if (!hook->command)
      continue;
 
    if (hook->id == id)
    {
      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, pc, pe) == MUTT_CMD_ERROR)
        {
          mutt_error("%s", buf_string(pe->message));
          goto done;
        }
        /* Executing arbitrary commands could affect the pattern results,
         * so the cache has to be wiped */
        memset(&cache, 0, sizeof(cache));
      }
    }
  }
 
done:
  mod_data->current_hook_id = CMD_NONE;
  parse_context_free(&pc);
  parse_error_free(&pe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

exec_startup_shutdown_hook()

void exec_startup_shutdown_hook

(

enum CommandId

id

)

Execute any startup/shutdown hooks.

Parameters

id	Hook CommandId: CMD_STARTUP_HOOK or CMD_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 418 of file exec.c.

{
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  struct ParseContext *pc = parse_context_new();
  struct ParseError *pe = parse_error_new();
 
  mod_data->current_hook_id = id;
 
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if (!(hook->command && (hook->id == id)))
      continue;
 
    if (parse_rc_line_cwd(hook->command, hook->source_file, pc, pe) == MUTT_CMD_ERROR)
    {
      mutt_error("%s", buf_string(pe->message));
      parse_error_reset(pe);
    }
  }
 
  mod_data->current_hook_id = CMD_NONE;
  parse_context_free(&pc);
  parse_error_free(&pe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

exec_timeout_hook()

void exec_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 378 of file exec.c.

{
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  struct ParseContext *pc = parse_context_new();
  struct ParseError *pe = parse_error_new();
 
  mod_data->current_hook_id = CMD_TIMEOUT_HOOK;
 
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if (!(hook->command && (hook->id == CMD_TIMEOUT_HOOK)))
      continue;
 
    if (parse_rc_line_cwd(hook->command, hook->source_file, pc, pe) == MUTT_CMD_ERROR)
    {
      mutt_error("%s", buf_string(pe->message));
      parse_error_reset(pe);
 
      /* The hooks should be independent of each other, so even though this one
       * failed, we'll carry on with the others. */
    }
  }
 
  /* Delete temporary attachment files */
  struct AttachModuleData *att_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  mutt_temp_attachments_cleanup(&att_data->temp_attachments);
 
  mod_data->current_hook_id = CMD_NONE;
  parse_context_free(&pc);
  parse_error_free(&pe);
}

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 319 of file exec.c.

{
  list_hook(list, buf_string(addr->mailbox), CMD_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	(	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 218 of file exec.c.

{
  struct Mailbox *m_cur = get_current_mailbox();
  if (addr_hook(path, CMD_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();
    generate_save_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_delete_hooks()

void mutt_delete_hooks	(	struct HookList *	hooks,
		enum CommandId	id )

Delete matching hooks.

Parameters

hooks	Hook list to modify
id	Hook CommandId to delete, e.g. CMD_SEND_HOOK

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

Definition at line 1032 of file parse.c.

{
  struct Hook *h = NULL;
  struct Hook *tmp = NULL;
 
  TAILQ_FOREACH_SAFE(h, hooks, entries, tmp)
  {
    if ((id == CMD_NONE) || (id == h->id))
    {
      TAILQ_REMOVE(hooks, h, entries);
      hook_free(&h);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_find_hook()

struct Hook * mutt_find_hook	(	enum CommandId	id,
		const char *	pat )

Find a matching hook.

Parameters

id	Hook CommandId, e.g CMD_FOLDER_HOOK
pat	Pattern to match

Return values

ptr	Matching Hook

Note

The returned Hook must not be freed.

Definition at line 115 of file exec.c.

{
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
 
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if (hook->id == id)
    {
      if (mutt_regex_match(&hook->regex, pat))
        return hook;
    }
  }
  return NULL;
}

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 452 of file exec.c.

{
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  if (!mod_data->idx_fmt_hooks)
    return NULL;
 
  struct HookList *hl = mutt_hash_find(mod_data->idx_fmt_hooks, name);
  if (!hl)
    return NULL;
 
  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;
    }
  }
 
  return exp;
}

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 256 of file exec.c.

{
  buf_alloc(path, PATH_MAX);
 
  if (addr_hook(path, CMD_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();
      generate_save_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);
  }
 
  pretty_mailbox(path);
}

Here is the call graph for this function:

Here is the caller graph for this function: