NeoMutt  2024-02-01-23-g345d7b
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
hook.c
Go to the documentation of this file.
1
36#include "config.h"
37#include <limits.h>
38#include <stdbool.h>
39#include <string.h>
40#include <unistd.h>
41#include "mutt/lib.h"
42#include "address/lib.h"
43#include "config/lib.h"
44#include "email/lib.h"
45#include "core/lib.h"
46#include "alias/lib.h"
47#include "hook.h"
48#include "attach/lib.h"
49#include "compmbox/lib.h"
50#include "index/lib.h"
51#include "ncrypt/lib.h"
52#include "parse/lib.h"
53#include "pattern/lib.h"
54#include "commands.h"
55#include "format_flags.h"
56#include "globals.h"
57#include "hdrline.h"
58#include "muttlib.h"
59#include "mx.h"
60
64struct Hook
65{
67 struct Regex regex;
68 char *command;
70 struct PatternList *pattern;
71 TAILQ_ENTRY(Hook) entries;
72};
73TAILQ_HEAD(HookList, Hook);
74
76static struct HookList Hooks = TAILQ_HEAD_INITIALIZER(Hooks);
77
79static struct HashTable *IdxFmtHooks = NULL;
80
83
88static void hook_free(struct Hook **ptr)
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}
106
111static struct Hook *hook_new(void)
112{
113 return mutt_mem_calloc(1, sizeof(struct Hook));
114}
115
120 intptr_t data, struct Buffer *err)
121{
122 struct Buffer *alias = buf_pool_get();
123 struct Buffer *charset = buf_pool_get();
124
125 int rc = MUTT_CMD_ERROR;
126
127 if (parse_extract_token(alias, s, TOKEN_NO_FLAGS) < 0)
128 goto done;
129 if (parse_extract_token(charset, s, TOKEN_NO_FLAGS) < 0)
130 goto done;
131
133
134 if (buf_is_empty(alias) || buf_is_empty(charset))
135 {
136 buf_printf(err, _("%s: too few arguments"), buf->data);
137 rc = MUTT_CMD_WARNING;
138 }
139 else if (MoreArgs(s))
140 {
141 buf_printf(err, _("%s: too many arguments"), buf->data);
142 buf_reset(s); // clean up buffer to avoid a mess with further rcfile processing
143 rc = MUTT_CMD_WARNING;
144 }
145 else if (mutt_ch_lookup_add(type, buf_string(alias), buf_string(charset), err))
146 {
147 rc = MUTT_CMD_SUCCESS;
148 }
149
150done:
151 buf_pool_release(&alias);
152 buf_pool_release(&charset);
153
154 return rc;
155}
156
162enum CommandResult mutt_parse_hook(struct Buffer *buf, struct Buffer *s,
163 intptr_t data, struct Buffer *err)
164{
165 struct Hook *hook = NULL;
166 int rc = MUTT_CMD_ERROR;
167 bool pat_not = false;
168 bool use_regex = true;
169 regex_t *rx = NULL;
170 struct PatternList *pat = NULL;
171 const bool folder_or_mbox = (data & (MUTT_FOLDER_HOOK | MUTT_MBOX_HOOK));
172
173 struct Buffer *cmd = buf_pool_get();
174 struct Buffer *pattern = buf_pool_get();
175
176 if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
177 {
178 if (*s->dptr == '!')
179 {
180 s->dptr++;
181 SKIPWS(s->dptr);
182 pat_not = true;
183 }
184
186 if (folder_or_mbox && mutt_str_equal(buf_string(pattern), "-noregex"))
187 {
188 use_regex = false;
189 if (!MoreArgs(s))
190 {
191 buf_printf(err, _("%s: too few arguments"), buf->data);
192 rc = MUTT_CMD_WARNING;
193 goto cleanup;
194 }
196 }
197
198 if (!MoreArgs(s))
199 {
200 buf_printf(err, _("%s: too few arguments"), buf->data);
201 rc = MUTT_CMD_WARNING;
202 goto cleanup;
203 }
204 }
205
206 parse_extract_token(cmd, s,
211
212 if (buf_is_empty(cmd))
213 {
214 buf_printf(err, _("%s: too few arguments"), buf->data);
215 rc = MUTT_CMD_WARNING;
216 goto cleanup;
217 }
218
219 if (MoreArgs(s))
220 {
221 buf_printf(err, _("%s: too many arguments"), buf->data);
222 rc = MUTT_CMD_WARNING;
223 goto cleanup;
224 }
225
226 const char *const c_default_hook = cs_subset_string(NeoMutt->sub, "default_hook");
227 if (folder_or_mbox)
228 {
229 /* Accidentally using the ^ mailbox shortcut in the .neomuttrc is a
230 * common mistake */
231 if ((pattern->data[0] == '^') && !CurrentFolder)
232 {
233 buf_strcpy(err, _("current mailbox shortcut '^' is unset"));
234 goto cleanup;
235 }
236
237 struct Buffer *tmp = buf_pool_get();
238 buf_copy(tmp, pattern);
239 buf_expand_path_regex(tmp, use_regex);
240
241 /* Check for other mailbox shortcuts that expand to the empty string.
242 * This is likely a mistake too */
243 if (buf_is_empty(tmp) && !buf_is_empty(pattern))
244 {
245 buf_strcpy(err, _("mailbox shortcut expanded to empty regex"));
246 buf_pool_release(&tmp);
247 goto cleanup;
248 }
249
250 if (use_regex)
251 {
252 buf_copy(pattern, tmp);
253 }
254 else
255 {
257 }
258 buf_pool_release(&tmp);
259 }
261 {
262 if (mutt_comp_valid_command(buf_string(cmd)) == 0)
263 {
264 buf_strcpy(err, _("badly formatted command string"));
265 goto cleanup;
266 }
267 }
268 else if (c_default_hook && (~data & MUTT_GLOBAL_HOOK) &&
270 {
271 /* At this stage only these hooks remain:
272 * fcc-, fcc-save-, index-format-, message-, reply-, save-, send- and send2-hook
273 * If given a plain string, or regex, we expand it using $default_hook. */
274 mutt_check_simple(pattern, c_default_hook);
275 }
276
278 {
279 buf_expand_path(cmd);
280 }
281
282 /* check to make sure that a matching hook doesn't already exist */
283 TAILQ_FOREACH(hook, &Hooks, entries)
284 {
286 {
287 /* Ignore duplicate global hooks */
288 if (mutt_str_equal(hook->command, buf_string(cmd)))
289 {
290 rc = MUTT_CMD_SUCCESS;
291 goto cleanup;
292 }
293 }
294 else if ((hook->type == data) && (hook->regex.pat_not == pat_not) &&
295 mutt_str_equal(buf_string(pattern), hook->regex.pattern))
296 {
300 {
301 /* these hooks allow multiple commands with the same
302 * pattern, so if we've already seen this pattern/command pair, just
303 * ignore it instead of creating a duplicate */
304 if (mutt_str_equal(hook->command, buf_string(cmd)))
305 {
306 rc = MUTT_CMD_SUCCESS;
307 goto cleanup;
308 }
309 }
310 else
311 {
312 /* other hooks only allow one command per pattern, so update the
313 * entry with the new command. this currently does not change the
314 * order of execution of the hooks, which i think is desirable since
315 * a common action to perform is to change the default (.) entry
316 * based upon some other information. */
317 FREE(&hook->command);
318 hook->command = buf_strdup(cmd);
320 rc = MUTT_CMD_SUCCESS;
321 goto cleanup;
322 }
323 }
324 }
325
328 {
329 PatternCompFlags comp_flags;
330
331 if (data & (MUTT_SEND2_HOOK))
332 comp_flags = MUTT_PC_SEND_MODE_SEARCH;
333 else if (data & (MUTT_SEND_HOOK | MUTT_FCC_HOOK))
334 comp_flags = MUTT_PC_NO_FLAGS;
335 else
336 comp_flags = MUTT_PC_FULL_MSG;
337
338 struct MailboxView *mv_cur = get_current_mailbox_view();
339 struct Menu *menu = get_current_menu();
340 pat = mutt_pattern_comp(mv_cur, menu, buf_string(pattern), comp_flags, err);
341 if (!pat)
342 goto cleanup;
343 }
344 else if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
345 {
346 /* Hooks not allowing full patterns: Check syntax of regex */
347 rx = mutt_mem_calloc(1, sizeof(regex_t));
348 int rc2 = REG_COMP(rx, buf_string(pattern), ((data & MUTT_CRYPT_HOOK) ? REG_ICASE : 0));
349 if (rc2 != 0)
350 {
351 regerror(rc2, rx, err->data, err->dsize);
352 FREE(&rx);
353 goto cleanup;
354 }
355 }
356
357 hook = hook_new();
358 hook->type = data;
359 hook->command = buf_strdup(cmd);
361 hook->pattern = pat;
362 hook->regex.pattern = buf_strdup(pattern);
363 hook->regex.regex = rx;
364 hook->regex.pat_not = pat_not;
365 TAILQ_INSERT_TAIL(&Hooks, hook, entries);
366 rc = MUTT_CMD_SUCCESS;
367
368cleanup:
369 buf_pool_release(&cmd);
370 buf_pool_release(&pattern);
371 return rc;
372}
373
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}
394
398static void idxfmt_hashelem_free(int type, void *obj, intptr_t data)
399{
400 struct HookList *hl = obj;
401 struct Hook *h = NULL;
402 struct Hook *tmp = NULL;
403
404 TAILQ_FOREACH_SAFE(h, hl, entries, tmp)
405 {
406 TAILQ_REMOVE(hl, h, entries);
407 hook_free(&h);
408 }
409
410 FREE(&hl);
411}
412
416static void delete_idxfmt_hooks(void)
417{
419}
420
424static enum CommandResult mutt_parse_idxfmt_hook(struct Buffer *buf, struct Buffer *s,
425 intptr_t data, struct Buffer *err)
426{
428 bool pat_not = false;
429
430 struct Buffer *name = buf_pool_get();
431 struct Buffer *pattern = buf_pool_get();
432 struct Buffer *fmtstring = buf_pool_get();
433
434 if (!IdxFmtHooks)
435 {
438 }
439
440 if (!MoreArgs(s))
441 {
442 buf_printf(err, _("%s: too few arguments"), buf->data);
443 goto out;
444 }
446 struct HookList *hl = mutt_hash_find(IdxFmtHooks, buf_string(name));
447
448 if (*s->dptr == '!')
449 {
450 s->dptr++;
451 SKIPWS(s->dptr);
452 pat_not = true;
453 }
455
456 if (!MoreArgs(s))
457 {
458 buf_printf(err, _("%s: too few arguments"), buf->data);
459 goto out;
460 }
461 parse_extract_token(fmtstring, s, TOKEN_NO_FLAGS);
462
463 if (MoreArgs(s))
464 {
465 buf_printf(err, _("%s: too many arguments"), buf->data);
466 goto out;
467 }
468
469 const char *const c_default_hook = cs_subset_string(NeoMutt->sub, "default_hook");
470 if (c_default_hook)
471 mutt_check_simple(pattern, c_default_hook);
472
473 /* check to make sure that a matching hook doesn't already exist */
474 struct Hook *hook = NULL;
475 if (hl)
476 {
477 TAILQ_FOREACH(hook, hl, entries)
478 {
479 if ((hook->regex.pat_not == pat_not) &&
481 {
482 mutt_str_replace(&hook->command, buf_string(fmtstring));
483 rc = MUTT_CMD_SUCCESS;
484 goto out;
485 }
486 }
487 }
488
489 /* MUTT_PC_PATTERN_DYNAMIC sets so that date ranges are regenerated during
490 * matching. This of course is slower, but index-format-hook is commonly
491 * used for date ranges, and they need to be evaluated relative to "now", not
492 * the hook compilation time. */
493 struct MailboxView *mv_cur = get_current_mailbox_view();
494 struct Menu *menu = get_current_menu();
495 struct PatternList *pat = mutt_pattern_comp(mv_cur, menu, buf_string(pattern),
497 err);
498 if (!pat)
499 goto out;
500
501 hook = hook_new();
502 hook->type = MUTT_IDXFMTHOOK;
503 hook->command = buf_strdup(fmtstring);
505 hook->pattern = pat;
506 hook->regex.pattern = buf_strdup(pattern);
507 hook->regex.regex = NULL;
508 hook->regex.pat_not = pat_not;
509
510 if (!hl)
511 {
512 hl = mutt_mem_calloc(1, sizeof(*hl));
513 TAILQ_INIT(hl);
515 }
516
517 TAILQ_INSERT_TAIL(hl, hook, entries);
518 rc = MUTT_CMD_SUCCESS;
519
520out:
521 buf_pool_release(&name);
522 buf_pool_release(&pattern);
523 buf_pool_release(&fmtstring);
524
525 return rc;
526}
527
534static HookFlags mutt_get_hook_type(const char *name)
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}
547
551static enum CommandResult mutt_parse_unhook(struct Buffer *buf, struct Buffer *s,
552 intptr_t data, struct Buffer *err)
553{
554 while (MoreArgs(s))
555 {
557 if (mutt_str_equal("*", buf->data))
558 {
560 {
561 buf_addstr(err, _("unhook: Can't do unhook * from within a hook"));
562 return MUTT_CMD_WARNING;
563 }
567 }
568 else
569 {
570 HookFlags type = mutt_get_hook_type(buf->data);
571
572 if (type == MUTT_HOOK_NO_FLAGS)
573 {
574 buf_printf(err, _("unhook: unknown hook type: %s"), buf->data);
575 return MUTT_CMD_ERROR;
576 }
577 if (type & (MUTT_CHARSET_HOOK | MUTT_ICONV_HOOK))
578 {
580 return MUTT_CMD_SUCCESS;
581 }
582 if (CurrentHookType == type)
583 {
584 buf_printf(err, _("unhook: Can't delete a %s from within a %s"),
585 buf->data, buf->data);
586 return MUTT_CMD_WARNING;
587 }
588 if (type == MUTT_IDXFMTHOOK)
590 else
591 mutt_delete_hooks(type);
592 }
593 }
594 return MUTT_CMD_SUCCESS;
595}
596
602void mutt_folder_hook(const char *path, const char *desc)
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}
641
650char *mutt_find_hook(HookFlags type, const char *pat)
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}
664
671void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
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}
707
717static int addr_hook(struct Buffer *path, HookFlags type, struct Mailbox *m, struct Email *e)
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}
742
748void mutt_default_save(struct Buffer *path, struct Email *e)
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}
780
786void mutt_select_fcc(struct Buffer *path, struct Email *e)
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}
821
828static void list_hook(struct ListHead *matches, const char *match, HookFlags type)
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}
840
848void mutt_crypt_hook(struct ListHead *list, struct Address *addr)
849{
851}
852
857void mutt_account_hook(const char *url)
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}
895
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}
926
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}
955
964const char *mutt_idxfmt_hook(const char *name, struct Mailbox *m, struct Email *e)
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}
993
997static const struct Command HookCommands[] = {
998 // clang-format off
999 { "account-hook", mutt_parse_hook, MUTT_ACCOUNT_HOOK },
1001 { "crypt-hook", mutt_parse_hook, MUTT_CRYPT_HOOK },
1002 { "fcc-hook", mutt_parse_hook, MUTT_FCC_HOOK },
1003 { "fcc-save-hook", mutt_parse_hook, MUTT_FCC_HOOK | MUTT_SAVE_HOOK },
1004 { "folder-hook", mutt_parse_hook, MUTT_FOLDER_HOOK },
1006 { "index-format-hook", mutt_parse_idxfmt_hook, MUTT_IDXFMTHOOK },
1007 { "mbox-hook", mutt_parse_hook, MUTT_MBOX_HOOK },
1008 { "message-hook", mutt_parse_hook, MUTT_MESSAGE_HOOK },
1009 { "pgp-hook", mutt_parse_hook, MUTT_CRYPT_HOOK },
1010 { "reply-hook", mutt_parse_hook, MUTT_REPLY_HOOK },
1011 { "save-hook", mutt_parse_hook, MUTT_SAVE_HOOK },
1012 { "send-hook", mutt_parse_hook, MUTT_SEND_HOOK },
1013 { "send2-hook", mutt_parse_hook, MUTT_SEND2_HOOK },
1014 { "shutdown-hook", mutt_parse_hook, MUTT_SHUTDOWN_HOOK | MUTT_GLOBAL_HOOK },
1015 { "startup-hook", mutt_parse_hook, MUTT_STARTUP_HOOK | MUTT_GLOBAL_HOOK },
1016 { "timeout-hook", mutt_parse_hook, MUTT_TIMEOUT_HOOK | MUTT_GLOBAL_HOOK },
1017 { "unhook", mutt_parse_unhook, 0 },
1018 // clang-format on
1019};
1020
1024void hooks_init(void)
1025{
1027}
Email Address Handling.
Email Aliases.
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:605
GUI display the mailboxes in a side panel.
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:178
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:221
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:93
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:308
struct Buffer buf_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:75
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:199
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:243
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:412
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer's contents to another Buffer.
Definition: buffer.c:618
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:588
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
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:97
CommandResult
Error codes for command_t parse functions.
Definition: command.h:36
@ MUTT_CMD_SUCCESS
Success: Command worked.
Definition: command.h:39
@ MUTT_CMD_ERROR
Error: Can't help the user.
Definition: command.h:37
@ MUTT_CMD_WARNING
Warning: Help given to the user.
Definition: command.h:38
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
char * mutt_get_sourced_cwd(void)
Get the current file path that is being parsed.
Definition: commands.c:184
Functions to parse commands in a config file.
struct PatternList * mutt_pattern_comp(struct MailboxView *mv, struct Menu *menu, const char *s, PatternCompFlags flags, struct Buffer *err)
Create a Pattern.
Definition: compile.c:905
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: compile.c:777
int mutt_comp_valid_command(const char *cmd)
Is this command string allowed?
Definition: compress.c:392
Compressed mbox local mailbox type.
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
Convenience wrapper for the config headers.
void commands_register(const struct Command *cmds, const size_t num_cmds)
Add commands to Commands array.
Definition: command.c:53
size_t commands_array(struct Command **first)
Get Commands array.
Definition: command.c:75
Convenience wrapper for the core headers.
Structs that make up an email.
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
int parse_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: extract.c:50
#define TOKEN_SPACE
Don't treat whitespace as a term.
Definition: extract.h:49
#define MoreArgs(buf)
Definition: extract.h:32
#define TOKEN_NO_FLAGS
No flags are set.
Definition: extract.h:46
int mutt_file_sanitize_regex(struct Buffer *dest, const char *src)
Escape any regex-magic characters in a string.
Definition: file.c:747
Flags to control mutt_expando_format()
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
char * CurrentFolder
Currently selected mailbox.
Definition: globals.c:43
Global variables.
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
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
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
static void idxfmt_hashelem_free(int type, void *obj, intptr_t data)
Free our hash table data - Implements hash_hdata_free_t -.
Definition: hook.c:398
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
struct HashElem * mutt_hash_insert(struct HashTable *table, const char *strkey, void *data)
Add a new element to the Hash Table (with string keys)
Definition: hash.c:335
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
struct HashTable * mutt_hash_new(size_t num_elems, HashFlags flags)
Create a new Hash Table (with string keys)
Definition: hash.c:259
void mutt_hash_set_destructor(struct HashTable *table, hash_hdata_free_t fn, intptr_t fn_data)
Set the destructor for a Hash Table.
Definition: hash.c:301
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:457
#define MUTT_HASH_STRDUP_KEYS
make a copy of the keys
Definition: hash.h:111
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
String processing routines to generate the mail index.
void mutt_default_save(struct Buffer *path, struct Email *e)
Find the default save path for an email.
Definition: hook.c:748
void mutt_timeout_hook(void)
Execute any timeout hooks.
Definition: hook.c:902
static struct HashTable * IdxFmtHooks
All Index Format hooks.
Definition: hook.c:79
char * mutt_find_hook(HookFlags type, const char *pat)
Find a matching hook.
Definition: hook.c:650
void mutt_startup_shutdown_hook(HookFlags type)
Execute any startup/shutdown hooks.
Definition: hook.c:934
void mutt_delete_hooks(HookFlags type)
Delete matching hooks.
Definition: hook.c:380
static void list_hook(struct ListHead *matches, const char *match, HookFlags type)
Find hook strings matching.
Definition: hook.c:828
void mutt_account_hook(const char *url)
Perform an account hook.
Definition: hook.c:857
static void delete_idxfmt_hooks(void)
Delete all the index-format-hooks.
Definition: hook.c:416
const char * mutt_idxfmt_hook(const char *name, struct Mailbox *m, struct Email *e)
Get index-format-hook format string.
Definition: hook.c:964
static void hook_free(struct Hook **ptr)
Free a Hook.
Definition: hook.c:88
void mutt_folder_hook(const char *path, const char *desc)
Perform a folder hook.
Definition: hook.c:602
void mutt_select_fcc(struct Buffer *path, struct Email *e)
Select the FCC path for an email.
Definition: hook.c:786
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
void hooks_init(void)
Setup feature commands.
Definition: hook.c:1024
static struct HookList Hooks
All simple hooks, e.g. MUTT_FOLDER_HOOK.
Definition: hook.c:76
static HookFlags mutt_get_hook_type(const char *name)
Find a hook by name.
Definition: hook.c:534
static HookFlags CurrentHookType
The type of the hook currently being executed, e.g. MUTT_SAVE_HOOK.
Definition: hook.c:82
static const struct Command HookCommands[]
Hook Commands.
Definition: hook.c:997
void mutt_crypt_hook(struct ListHead *list, struct Address *addr)
Find crypto hooks for an Address.
Definition: hook.c:848
static struct Hook * hook_new(void)
Create a Hook.
Definition: hook.c:111
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:671
Parse and execute user-defined hooks.
#define MUTT_OPEN_HOOK
open-hook: to read a compressed mailbox
Definition: hook.h:49
#define MUTT_ICONV_HOOK
iconv-hook: create a system charset alias
Definition: hook.h:43
#define MUTT_FOLDER_HOOK
folder-hook: when entering a mailbox
Definition: hook.h:37
#define MUTT_SAVE_HOOK
save-hook: set a default folder when saving an email
Definition: hook.h:41
#define MUTT_SEND_HOOK
send-hook: when composing a new email
Definition: hook.h:39
uint32_t HookFlags
Flags for mutt_parse_hook(), e.g. MUTT_FOLDER_HOOK.
Definition: hook.h:35
#define MUTT_FCC_HOOK
fcc-hook: to save outgoing email
Definition: hook.h:40
#define MUTT_CLOSE_HOOK
close-hook: write to a compressed mailbox
Definition: hook.h:51
#define MUTT_ACCOUNT_HOOK
account-hook: when changing between accounts
Definition: hook.h:46
#define MUTT_APPEND_HOOK
append-hook: append to a compressed mailbox
Definition: hook.h:50
#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_CRYPT_HOOK
crypt-hook: automatically select a PGP/SMIME key
Definition: hook.h:45
#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_TIMEOUT_HOOK
timeout-hook: run a command periodically
Definition: hook.h:53
#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_IDXFMTHOOK
index-format-hook: customise the format of the index
Definition: hook.h:52
#define MUTT_CHARSET_HOOK
charset-hook: create a charset alias for malformed emails
Definition: hook.h:42
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:36
GUI manage the main index (list of emails)
struct MailboxView * get_current_mailbox_view(void)
Get the current Mailbox view.
Definition: index.c:683
struct Mailbox * get_current_mailbox(void)
Get the current Mailbox.
Definition: index.c:715
struct Menu * get_current_menu(void)
Get the current Menu.
Definition: index.c:731
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:64
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
#define FREE(x)
Definition: memory.h:45
#define mutt_array_size(x)
Definition: memory.h:38
void mutt_ch_lookup_remove(void)
Remove all the character set lookups.
Definition: charset.c:540
bool mutt_ch_lookup_add(enum LookupType type, const char *pat, const char *replace, struct Buffer *err)
Add a new character set lookup.
Definition: charset.c:508
LookupType
Types of character set lookups.
Definition: charset.h:67
@ MUTT_LOOKUP_ICONV
Character set conversion.
Definition: charset.h:69
@ MUTT_LOOKUP_CHARSET
Alias for another character set.
Definition: charset.h:68
Convenience wrapper for the library headers.
#define _(a)
Definition: message.h:28
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:639
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:721
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:709
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:329
#define PATH_MAX
Definition: mutt.h:42
void mutt_temp_attachments_cleanup(void)
Delete all temporary attachments.
Definition: mutt_attach.c:1307
void buf_expand_path_regex(struct Buffer *buf, bool regex)
Create the canonical path (with regex char escaping)
Definition: muttlib.c:138
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:557
void buf_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:331
void mutt_safe_path(struct Buffer *dest, const struct Address *a)
Make a safe filename from an email address.
Definition: muttlib.c:721
Some miscellaneous functions.
int mx_access(const char *path, int flags)
Wrapper for access, checks permissions on a given mailbox.
Definition: mx.c:168
API for mailboxes.
API for encryption/signing of emails.
#define WithCrypto
Definition: lib.h:116
Text parsing functions.
Match patterns to emails.
#define MUTT_PC_SEND_MODE_SEARCH
Allow send-mode body searching.
Definition: lib.h:71
uint8_t PatternCompFlags
Flags for mutt_pattern_comp(), e.g. MUTT_PC_FULL_MSG.
Definition: lib.h:67
#define MUTT_PC_FULL_MSG
Enable body and header matching.
Definition: lib.h:69
void mutt_check_simple(struct Buffer *s, const char *simple)
Convert a simple search into a real request.
Definition: pattern.c:112
#define MUTT_PC_NO_FLAGS
No flags are set.
Definition: lib.h:68
#define MUTT_PC_PATTERN_DYNAMIC
Enable runtime date range evaluation.
Definition: lib.h:70
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
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:735
#define TAILQ_INIT(head)
Definition: queue.h:765
#define TAILQ_HEAD(name, type)
Definition: queue.h:623
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:809
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define SLIST_FIRST(head)
Definition: queue.h:229
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:841
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
#define TAILQ_ENTRY(type)
Definition: queue.h:640
#define REG_COMP(preg, regex, cflags)
Compile a regular expression.
Definition: regex3.h:49
#define NONULL(x)
Definition: string2.h:37
#define SKIPWS(ch)
Definition: string2.h:45
An email address.
Definition: address.h:36
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
String manipulation buffer.
Definition: buffer.h:36
char * dptr
Current read/write position.
Definition: buffer.h:38
size_t dsize
Length of data.
Definition: buffer.h:39
char * data
Pointer to data.
Definition: buffer.h:37
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
The envelope/body of an email.
Definition: email.h:39
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 bcc
Email's 'Bcc' list.
Definition: envelope.h:62
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
A Hash Table.
Definition: hash.h:97
A list of user hooks.
Definition: hook.c:65
HookFlags type
Hook type.
Definition: hook.c:66
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
View of a Mailbox.
Definition: mview.h:40
A mailbox.
Definition: mailbox.h:79
Definition: lib.h:69
enum MenuType type
Menu definition for keymap entries.
Definition: lib.h:73
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
Cache commonly-used patterns.
Definition: lib.h:117
A simple (non-regex) pattern.
Definition: lib.h:77
Cached regular expression.
Definition: regex3.h:85
char * pattern
printable version
Definition: regex3.h:86
bool pat_not
do not match
Definition: regex3.h:88
regex_t * regex
compiled expression
Definition: regex3.h:87