NeoMutt  2024-02-01-23-g345d7b
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 "index/lib.h"
#include "ncrypt/lib.h"
#include "parse/lib.h"
#include "pattern/lib.h"
#include "commands.h"
#include "format_flags.h"
#include "globals.h"
#include "hdrline.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 char * 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

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

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

89{
90 if (!ptr || !*ptr)
91 return;
92
93 struct Hook *h = *ptr;
94
95 FREE(&h->command);
96 FREE(&h->source_file);
97 FREE(&h->regex.pattern);
98 if (h->regex.regex)
99 {
100 regfree(h->regex.regex);
101 FREE(&h->regex.regex);
102 }
104 FREE(ptr);
105}
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: compile.c:777
#define FREE(x)
Definition: memory.h:45
A list of user hooks.
Definition: hook.c:65
struct PatternList * pattern
Used for fcc,save,send-hook.
Definition: hook.c:70
struct Regex regex
Regular expression.
Definition: hook.c:67
char * command
Filename, command or pattern to execute.
Definition: hook.c:68
char * source_file
Used for relative-directory source.
Definition: hook.c:69
char * pattern
printable version
Definition: regex3.h:86
regex_t * regex
compiled expression
Definition: regex3.h:87
+ 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 111 of file hook.c.

112{
113 return mutt_mem_calloc(1, sizeof(struct Hook));
114}
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
+ 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
typeHook type to delete, see HookFlags

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

Definition at line 380 of file hook.c.

381{
382 struct Hook *h = NULL;
383 struct Hook *tmp = NULL;
384
385 TAILQ_FOREACH_SAFE(h, &Hooks, entries, tmp)
386 {
387 if ((type == MUTT_HOOK_NO_FLAGS) || (type == h->type))
388 {
389 TAILQ_REMOVE(&Hooks, h, entries);
390 hook_free(&h);
391 }
392 }
393}
static void hook_free(struct Hook **ptr)
Free a Hook.
Definition: hook.c:88
static struct HookList Hooks
All simple hooks, e.g. MUTT_FOLDER_HOOK.
Definition: hook.c:76
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:36
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:735
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:841
HookFlags type
Hook type.
Definition: hook.c:66
+ 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 416 of file hook.c.

417{
419}
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:79
+ 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 534 of file hook.c.

535{
536 struct Command *c = NULL;
537 for (size_t i = 0, size = commands_array(&c); i < size; i++)
538 {
539 if (((c[i].parse == mutt_parse_hook) || (c[i].parse == mutt_parse_idxfmt_hook)) &&
541 {
542 return c[i].data;
543 }
544 }
545 return MUTT_HOOK_NO_FLAGS;
546}
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:424
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:162
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:721
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 602 of file hook.c.

603{
604 if (!path && !desc)
605 return;
606
607 struct Hook *hook = NULL;
608 struct Buffer *err = buf_pool_get();
609
611
612 TAILQ_FOREACH(hook, &Hooks, entries)
613 {
614 if (!hook->command)
615 continue;
616
617 if (!(hook->type & MUTT_FOLDER_HOOK))
618 continue;
619
620 const char *match = NULL;
621 if (mutt_regex_match(&hook->regex, path))
622 match = path;
623 else if (mutt_regex_match(&hook->regex, desc))
624 match = desc;
625
626 if (match)
627 {
628 mutt_debug(LL_DEBUG1, "folder-hook '%s' matches '%s'\n", hook->regex.pattern, match);
629 mutt_debug(LL_DEBUG5, " %s\n", hook->command);
630 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
631 {
632 mutt_error("%s", buf_string(err));
633 break;
634 }
635 }
636 }
637 buf_pool_release(&err);
638
640}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:97
@ 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:164
#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:82
#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:639
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
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 650 of file hook.c.

651{
652 struct Hook *tmp = NULL;
653
654 TAILQ_FOREACH(tmp, &Hooks, entries)
655 {
656 if (tmp->type & type)
657 {
658 if (mutt_regex_match(&tmp->regex, pat))
659 return tmp->command;
660 }
661 }
662 return NULL;
663}
+ 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 671 of file hook.c.

672{
673 struct Hook *hook = NULL;
674 struct PatternCache cache = { 0 };
675 struct Buffer *err = buf_pool_get();
676
677 CurrentHookType = type;
678
679 TAILQ_FOREACH(hook, &Hooks, entries)
680 {
681 if (!hook->command)
682 continue;
683
684 if (hook->type & type)
685 {
686 if ((mutt_pattern_exec(SLIST_FIRST(hook->pattern), 0, m, e, &cache) > 0) ^
687 hook->regex.pat_not)
688 {
689 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
690 {
691 mutt_error("%s", buf_string(err));
693 buf_pool_release(&err);
694
695 return;
696 }
697 /* Executing arbitrary commands could affect the pattern results,
698 * so the cache has to be wiped */
699 memset(&cache, 0, sizeof(cache));
700 }
701 }
702 }
703 buf_pool_release(&err);
704
706}
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:1133
#define SLIST_FIRST(head)
Definition: queue.h:229
Cache commonly-used patterns.
Definition: lib.h:117
bool pat_not
do not match
Definition: regex3.h:88
+ 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 717 of file hook.c.

718{
719 struct Hook *hook = NULL;
720 struct PatternCache cache = { 0 };
721
722 /* determine if a matching hook exists */
723 TAILQ_FOREACH(hook, &Hooks, entries)
724 {
725 if (!hook->command)
726 continue;
727
728 if (hook->type & type)
729 {
730 if ((mutt_pattern_exec(SLIST_FIRST(hook->pattern), 0, m, e, &cache) > 0) ^
731 hook->regex.pat_not)
732 {
733 mutt_make_string(path, 0, hook->command, m, -1, e, MUTT_FORMAT_PLAIN, NULL);
734 buf_fix_dptr(path);
735 return 0;
736 }
737 }
738 }
739
740 return -1;
741}
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:199
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
void mutt_make_string(struct Buffer *buf, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1438
+ 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 748 of file hook.c.

749{
750 struct Mailbox *m_cur = get_current_mailbox();
751 if (addr_hook(path, MUTT_SAVE_HOOK, m_cur, e) == 0)
752 return;
753
754 struct Envelope *env = e->env;
755 const struct Address *from = TAILQ_FIRST(&env->from);
756 const struct Address *reply_to = TAILQ_FIRST(&env->reply_to);
757 const struct Address *to = TAILQ_FIRST(&env->to);
758 const struct Address *cc = TAILQ_FIRST(&env->cc);
759 const struct Address *addr = NULL;
760 bool from_me = mutt_addr_is_user(from);
761
762 if (!from_me && reply_to && reply_to->mailbox)
763 addr = reply_to;
764 else if (!from_me && from && from->mailbox)
765 addr = from;
766 else if (to && to->mailbox)
767 addr = to;
768 else if (cc && cc->mailbox)
769 addr = cc;
770 else
771 addr = NULL;
772 if (addr)
773 {
774 struct Buffer *tmp = buf_pool_get();
775 mutt_safe_path(tmp, addr);
776 buf_add_printf(path, "=%s", buf_string(tmp));
777 buf_pool_release(&tmp);
778 }
779}
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:605
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:221
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:717
#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:721
#define TAILQ_FIRST(head)
Definition: queue.h:723
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 786 of file hook.c.

787{
788 buf_alloc(path, PATH_MAX);
789
790 if (addr_hook(path, MUTT_FCC_HOOK, NULL, e) != 0)
791 {
792 const struct Address *to = TAILQ_FIRST(&e->env->to);
793 const struct Address *cc = TAILQ_FIRST(&e->env->cc);
794 const struct Address *bcc = TAILQ_FIRST(&e->env->bcc);
795 const bool c_save_name = cs_subset_bool(NeoMutt->sub, "save_name");
796 const bool c_force_name = cs_subset_bool(NeoMutt->sub, "force_name");
797 const char *const c_record = cs_subset_string(NeoMutt->sub, "record");
798 if ((c_save_name || c_force_name) && (to || cc || bcc))
799 {
800 const struct Address *addr = to ? to : (cc ? cc : bcc);
801 struct Buffer *buf = buf_pool_get();
802 mutt_safe_path(buf, addr);
803 const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
804 buf_concat_path(path, NONULL(c_folder), buf_string(buf));
805 buf_pool_release(&buf);
806 if (!c_force_name && (mx_access(buf_string(path), W_OK) != 0))
807 buf_strcpy(path, c_record);
808 }
809 else
810 {
811 buf_strcpy(path, c_record);
812 }
813 }
814 else
815 {
816 buf_fix_dptr(path);
817 }
818
819 buf_pretty_mailbox(path);
820}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:412
size_t buf_concat_path(struct Buffer *buf, const char *dir, const char *fname)
Join a directory name and a filename.
Definition: buffer.c:526
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:354
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
#define MUTT_FCC_HOOK
fcc-hook: to save outgoing email
Definition: hook.h:40
#define PATH_MAX
Definition: mutt.h:42
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:557
int mx_access(const char *path, int flags)
Wrapper for access, checks permissions on a given mailbox.
Definition: mx.c:168
#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:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
+ 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 828 of file hook.c.

829{
830 struct Hook *tmp = NULL;
831
832 TAILQ_FOREACH(tmp, &Hooks, entries)
833 {
834 if ((tmp->type & type) && mutt_regex_match(&tmp->regex, match))
835 {
837 }
838 }
839}
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:64
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 848 of file hook.c.

849{
851}
static void list_hook(struct ListHead *matches, const char *match, HookFlags type)
Find hook strings matching.
Definition: hook.c:828
#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 857 of file hook.c.

858{
859 /* parsing commands with URLs in an account hook can cause a recursive
860 * call. We just skip processing if this occurs. Typically such commands
861 * belong in a folder-hook -- perhaps we should warn the user. */
862 static bool inhook = false;
863 if (inhook)
864 return;
865
866 struct Hook *hook = NULL;
867 struct Buffer *err = buf_pool_get();
868
869 TAILQ_FOREACH(hook, &Hooks, entries)
870 {
871 if (!(hook->command && (hook->type & MUTT_ACCOUNT_HOOK)))
872 continue;
873
874 if (mutt_regex_match(&hook->regex, url))
875 {
876 inhook = true;
877 mutt_debug(LL_DEBUG1, "account-hook '%s' matches '%s'\n", hook->regex.pattern, url);
878 mutt_debug(LL_DEBUG5, " %s\n", hook->command);
879
880 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
881 {
882 mutt_error("%s", buf_string(err));
883 buf_pool_release(&err);
884
885 inhook = false;
886 goto done;
887 }
888
889 inhook = false;
890 }
891 }
892done:
893 buf_pool_release(&err);
894}
#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 902 of file hook.c.

903{
904 struct Hook *hook = NULL;
905 struct Buffer *err = buf_pool_get();
906
907 TAILQ_FOREACH(hook, &Hooks, entries)
908 {
909 if (!(hook->command && (hook->type & MUTT_TIMEOUT_HOOK)))
910 continue;
911
912 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
913 {
914 mutt_error("%s", buf_string(err));
915 buf_reset(err);
916
917 /* The hooks should be independent of each other, so even though this on
918 * failed, we'll carry on with the others. */
919 }
920 }
921 buf_pool_release(&err);
922
923 /* Delete temporary attachment files */
925}
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:93
#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:1307
+ 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 934 of file hook.c.

935{
936 struct Hook *hook = NULL;
937 struct Buffer err = buf_make(0);
938 char buf[256] = { 0 };
939
940 err.data = buf;
941 err.dsize = sizeof(buf);
942
943 TAILQ_FOREACH(hook, &Hooks, entries)
944 {
945 if (!(hook->command && (hook->type & type)))
946 continue;
947
948 if (parse_rc_line_cwd(hook->command, hook->source_file, &err) == MUTT_CMD_ERROR)
949 {
950 mutt_error("%s", err.data);
951 buf_reset(&err);
952 }
953 }
954}
struct Buffer buf_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:75
size_t dsize
Length of data.
Definition: buffer.h:39
char * data
Pointer to data.
Definition: buffer.h:37
+ 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
nameHook name
mMailbox
eEmail
Return values
ptrprintf(3)-like format string
NULLNo matching hook

Definition at line 964 of file hook.c.

965{
966 if (!IdxFmtHooks)
967 return NULL;
968
969 struct HookList *hl = mutt_hash_find(IdxFmtHooks, name);
970 if (!hl)
971 return NULL;
972
974
975 struct PatternCache cache = { 0 };
976 const char *fmtstring = NULL;
977 struct Hook *hook = NULL;
978
979 TAILQ_FOREACH(hook, hl, entries)
980 {
981 struct Pattern *pat = SLIST_FIRST(hook->pattern);
982 if ((mutt_pattern_exec(pat, 0, m, e, &cache) > 0) ^ hook->regex.pat_not)
983 {
984 fmtstring = hook->command;
985 break;
986 }
987 }
988
990
991 return fmtstring;
992}
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
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 1024 of file hook.c.

1025{
1027}
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:997
#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

◆ Hooks

struct HookList Hooks = TAILQ_HEAD_INITIALIZER(Hooks)
static

All simple hooks, e.g. MUTT_FOLDER_HOOK.

Definition at line 76 of file hook.c.

◆ IdxFmtHooks

struct HashTable* IdxFmtHooks = NULL
static

All Index Format hooks.

Definition at line 79 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 82 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:551
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:119
#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 997 of file hook.c.