NeoMutt  2024-12-12-14-g7b49f7
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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 Hookhook_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 Expandomutt_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 HashTableIdxFmtHooks = 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

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
ptrHook to free

Definition at line 91 of file hook.c.

92{
93 if (!ptr || !*ptr)
94 return;
95
96 struct Hook *h = *ptr;
97
98 FREE(&h->command);
99 FREE(&h->source_file);
100 FREE(&h->regex.pattern);
101 if (h->regex.regex)
102 {
103 regfree(h->regex.regex);
104 FREE(&h->regex.regex);
105 }
108 FREE(ptr);
109}
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: compile.c:778
void expando_free(struct Expando **ptr)
Free an Expando object.
Definition: expando.c:61
#define FREE(x)
Definition: memory.h:55
A list of user hooks.
Definition: hook.c:67
struct PatternList * pattern
Used for fcc,save,send-hook.
Definition: hook.c:72
struct Regex regex
Regular expression.
Definition: hook.c:69
char * command
Filename, command or pattern to execute.
Definition: hook.c:70
struct Expando * expando
Used for format hooks.
Definition: hook.c:73
char * source_file
Used for relative-directory source.
Definition: hook.c:71
char * pattern
printable version
Definition: regex3.h:87
regex_t * regex
compiled expression
Definition: regex3.h:88
+ 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
ptrNew Hook

Definition at line 115 of file hook.c.

116{
117 return MUTT_MEM_CALLOC(1, struct Hook);
118}
#define MUTT_MEM_CALLOC(n, type)
Definition: memory.h:40
+ Here is the caller graph for this function:

◆ mutt_delete_hooks()

void mutt_delete_hooks ( HookFlags  type)

Delete matching hooks.

Parameters
typeHook 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.

399{
400 struct Hook *h = NULL;
401 struct Hook *tmp = NULL;
402
403 TAILQ_FOREACH_SAFE(h, &Hooks, entries, tmp)
404 {
405 if ((type == MUTT_HOOK_NO_FLAGS) || (type == h->type))
406 {
407 TAILQ_REMOVE(&Hooks, h, entries);
408 hook_free(&h);
409 }
410 }
411}
static void hook_free(struct Hook **ptr)
Free a Hook.
Definition: hook.c:91
static struct HookList Hooks
All simple hooks, e.g. MUTT_FOLDER_HOOK.
Definition: hook.c:79
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:36
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:753
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:862
HookFlags type
Hook type.
Definition: hook.c:68
+ 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.

435{
437}
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:457
static struct HashTable * IdxFmtHooks
All Index Format hooks.
Definition: hook.c:82
+ 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
nameName to find
Return values
numHook ID, e.g. MUTT_FOLDER_HOOK
MUTT_HOOK_NO_FLAGSError, no matching hook

Definition at line 562 of file hook.c.

563{
564 struct Command *c = NULL;
565 for (size_t i = 0, size = commands_array(&c); i < size; i++)
566 {
567 if (((c[i].parse == mutt_parse_hook) || (c[i].parse == mutt_parse_idxfmt_hook)) &&
569 {
570 return c[i].data;
571 }
572 }
573 return MUTT_HOOK_NO_FLAGS;
574}
size_t commands_array(struct Command **first)
Get Commands array.
Definition: command.c:75
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() -.
Definition: hook.c:442
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() -.
Definition: hook.c:166
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
enum CommandResult(* parse)(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Definition: command.h:65
intptr_t data
Data or flags to pass to the command.
Definition: command.h:67
const char * name
Name of the command.
Definition: command.h:52
+ 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
pathPath to potentially match
descDescription to potentially match

Definition at line 630 of file hook.c.

631{
632 if (!path && !desc)
633 return;
634
635 struct Hook *hook = NULL;
636 struct Buffer *err = buf_pool_get();
637
639
640 TAILQ_FOREACH(hook, &Hooks, entries)
641 {
642 if (!hook->command)
643 continue;
644
645 if (!(hook->type & MUTT_FOLDER_HOOK))
646 continue;
647
648 const char *match = NULL;
649 if (mutt_regex_match(&hook->regex, path))
650 match = path;
651 else if (mutt_regex_match(&hook->regex, desc))
652 match = desc;
653
654 if (match)
655 {
656 mutt_debug(LL_DEBUG1, "folder-hook '%s' matches '%s'\n", hook->regex.pattern, match);
657 mutt_debug(LL_DEBUG5, " %s\n", hook->command);
658 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
659 {
660 mutt_error("%s", buf_string(err));
661 break;
662 }
663 }
664 }
665 buf_pool_release(&err);
666
668}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
@ MUTT_CMD_ERROR
Error: Can't help the user.
Definition: command.h:37
enum CommandResult parse_rc_line_cwd(const char *line, char *cwd, struct Buffer *err)
Parse and run a muttrc line in a relative directory.
Definition: commands.c:165
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
static HookFlags CurrentHookType
The type of the hook currently being executed, e.g. MUTT_SAVE_HOOK.
Definition: hook.c:85
#define MUTT_FOLDER_HOOK
folder-hook: when entering a mailbox
Definition: hook.h:37
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:614
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:82
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:96
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:743
String manipulation buffer.
Definition: buffer.h:36
+ 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
typeHook type, see HookFlags
patPattern to match
Return values
ptrCommand string
Note
The returned string must not be freed.

Definition at line 678 of file hook.c.

679{
680 struct Hook *tmp = NULL;
681
682 TAILQ_FOREACH(tmp, &Hooks, entries)
683 {
684 if (tmp->type & type)
685 {
686 if (mutt_regex_match(&tmp->regex, pat))
687 return tmp->command;
688 }
689 }
690 return NULL;
691}
+ 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
mMailbox
eEmail
typeHook type, see HookFlags

Definition at line 699 of file hook.c.

700{
701 struct Hook *hook = NULL;
702 struct PatternCache cache = { 0 };
703 struct Buffer *err = buf_pool_get();
704
705 CurrentHookType = type;
706
707 TAILQ_FOREACH(hook, &Hooks, entries)
708 {
709 if (!hook->command)
710 continue;
711
712 if (hook->type & type)
713 {
714 if ((mutt_pattern_exec(SLIST_FIRST(hook->pattern), 0, m, e, &cache) > 0) ^
715 hook->regex.pat_not)
716 {
717 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
718 {
719 mutt_error("%s", buf_string(err));
721 buf_pool_release(&err);
722
723 return;
724 }
725 /* Executing arbitrary commands could affect the pattern results,
726 * so the cache has to be wiped */
727 memset(&cache, 0, sizeof(cache));
728 }
729 }
730 }
731 buf_pool_release(&err);
732
734}
bool mutt_pattern_exec(struct Pattern *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct PatternCache *cache)
Match a pattern against an email header.
Definition: exec.c:1147
#define SLIST_FIRST(head)
Definition: queue.h:227
Cache commonly-used patterns.
Definition: lib.h:117
bool pat_not
do not match
Definition: regex3.h:89
+ 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
pathBuffer for path
typeHook type, see HookFlags
mMailbox
eEmail
Return values
0Success
-1Failure

Definition at line 745 of file hook.c.

746{
747 struct Hook *hook = NULL;
748 struct PatternCache cache = { 0 };
749
750 /* determine if a matching hook exists */
751 TAILQ_FOREACH(hook, &Hooks, entries)
752 {
753 if (!hook->command)
754 continue;
755
756 if (hook->type & type)
757 {
758 if ((mutt_pattern_exec(SLIST_FIRST(hook->pattern), 0, m, e, &cache) > 0) ^
759 hook->regex.pat_not)
760 {
761 buf_alloc(path, PATH_MAX);
762 mutt_make_string(path, -1, hook->expando, m, -1, e, MUTT_FORMAT_PLAIN, NULL);
763 buf_fix_dptr(path);
764 return 0;
765 }
766 }
767 }
768
769 return -1;
770}
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:182
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:337
int mutt_make_string(struct Buffer *buf, size_t max_cols, const struct Expando *exp, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: dlg_index.c:803
#define PATH_MAX
Definition: mutt.h:42
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: render.h:39
+ 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
pathBuffer for the path
eEmail

Definition at line 777 of file hook.c.

778{
779 struct Mailbox *m_cur = get_current_mailbox();
780 if (addr_hook(path, MUTT_SAVE_HOOK, m_cur, e) == 0)
781 return;
782
783 struct Envelope *env = e->env;
784 const struct Address *from = TAILQ_FIRST(&env->from);
785 const struct Address *reply_to = TAILQ_FIRST(&env->reply_to);
786 const struct Address *to = TAILQ_FIRST(&env->to);
787 const struct Address *cc = TAILQ_FIRST(&env->cc);
788 const struct Address *addr = NULL;
789 bool from_me = mutt_addr_is_user(from);
790
791 if (!from_me && reply_to && reply_to->mailbox)
792 addr = reply_to;
793 else if (!from_me && from && from->mailbox)
794 addr = from;
795 else if (to && to->mailbox)
796 addr = to;
797 else if (cc && cc->mailbox)
798 addr = cc;
799 else
800 addr = NULL;
801 if (addr)
802 {
803 struct Buffer *tmp = buf_pool_get();
804 mutt_safe_path(tmp, addr);
805 buf_add_printf(path, "=%s", buf_string(tmp));
806 buf_pool_release(&tmp);
807 }
808}
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:600
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:204
static int addr_hook(struct Buffer *path, HookFlags type, struct Mailbox *m, struct Email *e)
Perform an address hook (get a path)
Definition: hook.c:745
#define MUTT_SAVE_HOOK
save-hook: set a default folder when saving an email
Definition: hook.h:41
struct Mailbox * get_current_mailbox(void)
Get the current Mailbox.
Definition: index.c:715
void mutt_safe_path(struct Buffer *dest, const struct Address *a)
Make a safe filename from an email address.
Definition: muttlib.c:683
#define TAILQ_FIRST(head)
Definition: queue.h:741
An email address.
Definition: address.h:36
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
struct Envelope * env
Envelope information.
Definition: email.h:68
The header of an Email.
Definition: envelope.h:57
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
struct AddressList reply_to
Email's 'reply-to'.
Definition: envelope.h:64
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
A mailbox.
Definition: mailbox.h:79
+ 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
pathBuffer for the path
eEmail

Definition at line 815 of file hook.c.

816{
817 buf_alloc(path, PATH_MAX);
818
819 if (addr_hook(path, MUTT_FCC_HOOK, NULL, e) != 0)
820 {
821 const struct Address *to = TAILQ_FIRST(&e->env->to);
822 const struct Address *cc = TAILQ_FIRST(&e->env->cc);
823 const struct Address *bcc = TAILQ_FIRST(&e->env->bcc);
824 const bool c_save_name = cs_subset_bool(NeoMutt->sub, "save_name");
825 const bool c_force_name = cs_subset_bool(NeoMutt->sub, "force_name");
826 const char *const c_record = cs_subset_string(NeoMutt->sub, "record");
827 if ((c_save_name || c_force_name) && (to || cc || bcc))
828 {
829 const struct Address *addr = to ? to : (cc ? cc : bcc);
830 struct Buffer *buf = buf_pool_get();
831 mutt_safe_path(buf, addr);
832 const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
833 buf_concat_path(path, NONULL(c_folder), buf_string(buf));
834 buf_pool_release(&buf);
835 if (!c_force_name && (mx_access(buf_string(path), W_OK) != 0))
836 buf_strcpy(path, c_record);
837 }
838 else
839 {
840 buf_strcpy(path, c_record);
841 }
842 }
843 else
844 {
845 buf_fix_dptr(path);
846 }
847
848 buf_pretty_mailbox(path);
849}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
size_t buf_concat_path(struct Buffer *buf, const char *dir, const char *fname)
Join a directory name and a filename.
Definition: buffer.c:509
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
#define MUTT_FCC_HOOK
fcc-hook: to save outgoing email
Definition: hook.h:40
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:519
int mx_access(const char *path, int flags)
Wrapper for access, checks permissions on a given mailbox.
Definition: mx.c:170
#define NONULL(x)
Definition: string2.h:37
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ 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]matchesList of hook strings
[in]matchString to match
[in]typeHook type, see HookFlags

Definition at line 857 of file hook.c.

858{
859 struct Hook *tmp = NULL;
860
861 TAILQ_FOREACH(tmp, &Hooks, entries)
862 {
863 if ((tmp->type & type) && mutt_regex_match(&tmp->regex, match))
864 {
866 }
867 }
868}
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:65
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
+ 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]listList of keys
[in]addrAddress to match

The crypt-hook associates keys with addresses.

Definition at line 877 of file hook.c.

878{
880}
static void list_hook(struct ListHead *matches, const char *match, HookFlags type)
Find hook strings matching.
Definition: hook.c:857
#define MUTT_CRYPT_HOOK
crypt-hook: automatically select a PGP/SMIME key
Definition: hook.h:45
+ 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
urlAccount URL to match

Definition at line 886 of file hook.c.

887{
888 /* parsing commands with URLs in an account hook can cause a recursive
889 * call. We just skip processing if this occurs. Typically such commands
890 * belong in a folder-hook -- perhaps we should warn the user. */
891 static bool inhook = false;
892 if (inhook)
893 return;
894
895 struct Hook *hook = NULL;
896 struct Buffer *err = buf_pool_get();
897
898 TAILQ_FOREACH(hook, &Hooks, entries)
899 {
900 if (!(hook->command && (hook->type & MUTT_ACCOUNT_HOOK)))
901 continue;
902
903 if (mutt_regex_match(&hook->regex, url))
904 {
905 inhook = true;
906 mutt_debug(LL_DEBUG1, "account-hook '%s' matches '%s'\n", hook->regex.pattern, url);
907 mutt_debug(LL_DEBUG5, " %s\n", hook->command);
908
909 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
910 {
911 mutt_error("%s", buf_string(err));
912 buf_pool_release(&err);
913
914 inhook = false;
915 goto done;
916 }
917
918 inhook = false;
919 }
920 }
921done:
922 buf_pool_release(&err);
923}
#define MUTT_ACCOUNT_HOOK
account-hook: when changing between accounts
Definition: hook.h:46
+ 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 931 of file hook.c.

932{
933 struct Hook *hook = NULL;
934 struct Buffer *err = buf_pool_get();
935
936 TAILQ_FOREACH(hook, &Hooks, entries)
937 {
938 if (!(hook->command && (hook->type & MUTT_TIMEOUT_HOOK)))
939 continue;
940
941 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
942 {
943 mutt_error("%s", buf_string(err));
944 buf_reset(err);
945
946 /* The hooks should be independent of each other, so even though this on
947 * failed, we'll carry on with the others. */
948 }
949 }
950 buf_pool_release(&err);
951
952 /* Delete temporary attachment files */
954}
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
#define MUTT_TIMEOUT_HOOK
timeout-hook: run a command periodically
Definition: hook.h:53
void mutt_temp_attachments_cleanup(void)
Delete all temporary attachments.
Definition: mutt_attach.c:1310
+ 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
typeHook 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 963 of file hook.c.

964{
965 struct Hook *hook = NULL;
966 struct Buffer *err = buf_pool_get();
967
968 TAILQ_FOREACH(hook, &Hooks, entries)
969 {
970 if (!(hook->command && (hook->type & type)))
971 continue;
972
973 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
974 {
975 mutt_error("%s", buf_string(err));
976 buf_reset(err);
977 }
978 }
979 buf_pool_release(&err);
980}
+ 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
nameHook name
mMailbox
eEmail
Return values
ptrExpando
NULLNo matching hook

Definition at line 990 of file hook.c.

991{
992 if (!IdxFmtHooks)
993 return NULL;
994
995 struct HookList *hl = mutt_hash_find(IdxFmtHooks, name);
996 if (!hl)
997 return NULL;
998
1000
1001 struct PatternCache cache = { 0 };
1002 const struct Expando *exp = NULL;
1003 struct Hook *hook = NULL;
1004
1005 TAILQ_FOREACH(hook, hl, entries)
1006 {
1007 struct Pattern *pat = SLIST_FIRST(hook->pattern);
1008 if ((mutt_pattern_exec(pat, 0, m, e, &cache) > 0) ^ hook->regex.pat_not)
1009 {
1010 exp = hook->expando;
1011 break;
1012 }
1013 }
1014
1016
1017 return exp;
1018}
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:362
#define MUTT_IDXFMTHOOK
index-format-hook: customise the format of the index
Definition: hook.h:52
Parsed Expando trees.
Definition: expando.h:41
A simple (non-regex) pattern.
Definition: lib.h:77
+ 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 1050 of file hook.c.

1051{
1053}
void commands_register(const struct Command *cmds, const size_t num_cmds)
Add commands to Commands array.
Definition: command.c:53
static const struct Command HookCommands[]
Hook Commands.
Definition: hook.c:1023
#define mutt_array_size(x)
Definition: memory.h:38
+ 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 314 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 },
{ "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 },
{ "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 },
{ "unhook", mutt_parse_unhook, 0 },
}
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() -.
Definition: hook.c:579
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() -.
Definition: hook.c:123
#define MUTT_ICONV_HOOK
iconv-hook: create a system charset alias
Definition: hook.h:43
#define MUTT_SEND_HOOK
send-hook: when composing a new email
Definition: hook.h:39
#define MUTT_GLOBAL_HOOK
Hooks which don't take a regex.
Definition: hook.h:56
#define MUTT_STARTUP_HOOK
startup-hook: run when starting NeoMutt
Definition: hook.h:54
#define MUTT_SEND2_HOOK
send2-hook: when changing fields in the compose menu
Definition: hook.h:48
#define MUTT_MBOX_HOOK
mbox-hook: move messages after reading them
Definition: hook.h:38
#define MUTT_REPLY_HOOK
reply-hook: when replying to an email
Definition: hook.h:47
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:44
#define MUTT_SHUTDOWN_HOOK
shutdown-hook: run when leaving NeoMutt
Definition: hook.h:55
#define MUTT_CHARSET_HOOK
charset-hook: create a charset alias for malformed emails
Definition: hook.h:42

Hook Commands.

Definition at line 1023 of file hook.c.