NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
hook.h File Reference

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

#include "config.h"
#include <stdint.h>
#include "core/lib.h"
+ Include dependency graph for hook.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define MUTT_HOOK_NO_FLAGS   0
 No flags are set.
 
#define MUTT_FOLDER_HOOK   (1 << 0)
 folder-hook: when entering a mailbox
 
#define MUTT_MBOX_HOOK   (1 << 1)
 mbox-hook: move messages after reading them
 
#define MUTT_SEND_HOOK   (1 << 2)
 send-hook: when composing a new email
 
#define MUTT_FCC_HOOK   (1 << 3)
 fcc-hook: to save outgoing email
 
#define MUTT_SAVE_HOOK   (1 << 4)
 save-hook: set a default folder when saving an email
 
#define MUTT_CHARSET_HOOK   (1 << 5)
 charset-hook: create a charset alias for malformed emails
 
#define MUTT_ICONV_HOOK   (1 << 6)
 iconv-hook: create a system charset alias
 
#define MUTT_MESSAGE_HOOK   (1 << 7)
 message-hook: run before displaying a message
 
#define MUTT_CRYPT_HOOK   (1 << 8)
 crypt-hook: automatically select a PGP/SMIME key
 
#define MUTT_ACCOUNT_HOOK   (1 << 9)
 account-hook: when changing between accounts
 
#define MUTT_REPLY_HOOK   (1 << 10)
 reply-hook: when replying to an email
 
#define MUTT_SEND2_HOOK   (1 << 11)
 send2-hook: when changing fields in the compose menu
 
#define MUTT_OPEN_HOOK   (1 << 12)
 open-hook: to read a compressed mailbox
 
#define MUTT_APPEND_HOOK   (1 << 13)
 append-hook: append to a compressed mailbox
 
#define MUTT_CLOSE_HOOK   (1 << 14)
 close-hook: write to a compressed mailbox
 
#define MUTT_IDXFMTHOOK   (1 << 15)
 index-format-hook: customise the format of the index
 
#define MUTT_TIMEOUT_HOOK   (1 << 16)
 timeout-hook: run a command periodically
 
#define MUTT_STARTUP_HOOK   (1 << 17)
 startup-hook: run when starting NeoMutt
 
#define MUTT_SHUTDOWN_HOOK   (1 << 18)
 shutdown-hook: run when leaving NeoMutt
 
#define MUTT_GLOBAL_HOOK   (1 << 19)
 Hooks which don't take a regex.
 

Typedefs

typedef uint32_t HookFlags
 Flags for mutt_parse_hook(), e.g. MUTT_FOLDER_HOOK.
 

Functions

void hooks_init (void)
 Setup feature commands.
 
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_account_hook (const char *url)
 Perform an account hook.
 
void mutt_crypt_hook (struct ListHead *list, struct Address *addr)
 Find crypto hooks for an Address.
 
void mutt_default_save (struct Buffer *path, struct Email *e)
 Find the default save path for an email.
 
void mutt_delete_hooks (HookFlags type)
 Delete matching hooks.
 
char * mutt_find_hook (HookFlags type, const char *pat)
 Find a matching hook.
 
void mutt_folder_hook (const char *path, const char *desc)
 Perform a folder hook.
 
const struct Expandomutt_idxfmt_hook (const char *name, struct Mailbox *m, struct Email *e)
 Get index-format-hook format string.
 
void mutt_message_hook (struct Mailbox *m, struct Email *e, HookFlags type)
 Perform a message 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() -.
 
void mutt_select_fcc (struct Buffer *path, struct Email *e)
 Select the FCC path for an email.
 
void mutt_startup_shutdown_hook (HookFlags type)
 Execute any startup/shutdown hooks.
 
void mutt_timeout_hook (void)
 Execute any timeout hooks.
 

Detailed Description

Parse and execute user-defined hooks.

Authors
  • Richard Russon

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

Macro Definition Documentation

◆ MUTT_HOOK_NO_FLAGS

#define MUTT_HOOK_NO_FLAGS   0

No flags are set.

Definition at line 36 of file hook.h.

◆ MUTT_FOLDER_HOOK

#define MUTT_FOLDER_HOOK   (1 << 0)

folder-hook: when entering a mailbox

Definition at line 37 of file hook.h.

◆ MUTT_MBOX_HOOK

#define MUTT_MBOX_HOOK   (1 << 1)

mbox-hook: move messages after reading them

Definition at line 38 of file hook.h.

◆ MUTT_SEND_HOOK

#define MUTT_SEND_HOOK   (1 << 2)

send-hook: when composing a new email

Definition at line 39 of file hook.h.

◆ MUTT_FCC_HOOK

#define MUTT_FCC_HOOK   (1 << 3)

fcc-hook: to save outgoing email

Definition at line 40 of file hook.h.

◆ MUTT_SAVE_HOOK

#define MUTT_SAVE_HOOK   (1 << 4)

save-hook: set a default folder when saving an email

Definition at line 41 of file hook.h.

◆ MUTT_CHARSET_HOOK

#define MUTT_CHARSET_HOOK   (1 << 5)

charset-hook: create a charset alias for malformed emails

Definition at line 42 of file hook.h.

◆ MUTT_ICONV_HOOK

#define MUTT_ICONV_HOOK   (1 << 6)

iconv-hook: create a system charset alias

Definition at line 43 of file hook.h.

◆ MUTT_MESSAGE_HOOK

#define MUTT_MESSAGE_HOOK   (1 << 7)

message-hook: run before displaying a message

Definition at line 44 of file hook.h.

◆ MUTT_CRYPT_HOOK

#define MUTT_CRYPT_HOOK   (1 << 8)

crypt-hook: automatically select a PGP/SMIME key

Definition at line 45 of file hook.h.

◆ MUTT_ACCOUNT_HOOK

#define MUTT_ACCOUNT_HOOK   (1 << 9)

account-hook: when changing between accounts

Definition at line 46 of file hook.h.

◆ MUTT_REPLY_HOOK

#define MUTT_REPLY_HOOK   (1 << 10)

reply-hook: when replying to an email

Definition at line 47 of file hook.h.

◆ MUTT_SEND2_HOOK

#define MUTT_SEND2_HOOK   (1 << 11)

send2-hook: when changing fields in the compose menu

Definition at line 48 of file hook.h.

◆ MUTT_OPEN_HOOK

#define MUTT_OPEN_HOOK   (1 << 12)

open-hook: to read a compressed mailbox

Definition at line 49 of file hook.h.

◆ MUTT_APPEND_HOOK

#define MUTT_APPEND_HOOK   (1 << 13)

append-hook: append to a compressed mailbox

Definition at line 50 of file hook.h.

◆ MUTT_CLOSE_HOOK

#define MUTT_CLOSE_HOOK   (1 << 14)

close-hook: write to a compressed mailbox

Definition at line 51 of file hook.h.

◆ MUTT_IDXFMTHOOK

#define MUTT_IDXFMTHOOK   (1 << 15)

index-format-hook: customise the format of the index

Definition at line 52 of file hook.h.

◆ MUTT_TIMEOUT_HOOK

#define MUTT_TIMEOUT_HOOK   (1 << 16)

timeout-hook: run a command periodically

Definition at line 53 of file hook.h.

◆ MUTT_STARTUP_HOOK

#define MUTT_STARTUP_HOOK   (1 << 17)

startup-hook: run when starting NeoMutt

Definition at line 54 of file hook.h.

◆ MUTT_SHUTDOWN_HOOK

#define MUTT_SHUTDOWN_HOOK   (1 << 18)

shutdown-hook: run when leaving NeoMutt

Definition at line 55 of file hook.h.

◆ MUTT_GLOBAL_HOOK

#define MUTT_GLOBAL_HOOK   (1 << 19)

Hooks which don't take a regex.

Definition at line 56 of file hook.h.

Typedef Documentation

◆ HookFlags

typedef uint32_t HookFlags

Flags for mutt_parse_hook(), e.g. MUTT_FOLDER_HOOK.

Definition at line 35 of file hook.h.

Function Documentation

◆ hooks_init()

void hooks_init ( void  )

Setup feature commands.

Definition at line 1043 of file hook.c.

1044{
1046}
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:1016
#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:

◆ mutt_account_hook()

void mutt_account_hook ( const char *  url)

Perform an account hook.

Parameters
urlAccount URL to match

Definition at line 879 of file hook.c.

880{
881 /* parsing commands with URLs in an account hook can cause a recursive
882 * call. We just skip processing if this occurs. Typically such commands
883 * belong in a folder-hook -- perhaps we should warn the user. */
884 static bool inhook = false;
885 if (inhook)
886 return;
887
888 struct Hook *hook = NULL;
889 struct Buffer *err = buf_pool_get();
890
891 TAILQ_FOREACH(hook, &Hooks, entries)
892 {
893 if (!(hook->command && (hook->type & MUTT_ACCOUNT_HOOK)))
894 continue;
895
896 if (mutt_regex_match(&hook->regex, url))
897 {
898 inhook = true;
899 mutt_debug(LL_DEBUG1, "account-hook '%s' matches '%s'\n", hook->regex.pattern, url);
900 mutt_debug(LL_DEBUG5, " %s\n", hook->command);
901
902 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
903 {
904 mutt_error("%s", buf_string(err));
905 buf_pool_release(&err);
906
907 inhook = false;
908 goto done;
909 }
910
911 inhook = false;
912 }
913 }
914done:
915 buf_pool_release(&err);
916}
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 struct HookList Hooks
All simple hooks, e.g. MUTT_FOLDER_HOOK.
Definition: hook.c:80
#define MUTT_ACCOUNT_HOOK
account-hook: when changing between accounts
Definition: hook.h:46
@ 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: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
A list of user hooks.
Definition: hook.c:68
HookFlags type
Hook type.
Definition: hook.c:69
struct Regex regex
Regular expression.
Definition: hook.c:70
char * command
Filename, command or pattern to execute.
Definition: hook.c:71
char * source_file
Used for relative-directory source.
Definition: hook.c:72
char * pattern
printable version
Definition: regex3.h:86
+ 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 870 of file hook.c.

871{
873}
static void list_hook(struct ListHead *matches, const char *match, HookFlags type)
Find hook strings matching.
Definition: hook.c:850
#define MUTT_CRYPT_HOOK
crypt-hook: automatically select a PGP/SMIME key
Definition: hook.h:45
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
+ 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 770 of file hook.c.

771{
772 struct Mailbox *m_cur = get_current_mailbox();
773 if (addr_hook(path, MUTT_SAVE_HOOK, m_cur, e) == 0)
774 return;
775
776 struct Envelope *env = e->env;
777 const struct Address *from = TAILQ_FIRST(&env->from);
778 const struct Address *reply_to = TAILQ_FIRST(&env->reply_to);
779 const struct Address *to = TAILQ_FIRST(&env->to);
780 const struct Address *cc = TAILQ_FIRST(&env->cc);
781 const struct Address *addr = NULL;
782 bool from_me = mutt_addr_is_user(from);
783
784 if (!from_me && reply_to && reply_to->mailbox)
785 addr = reply_to;
786 else if (!from_me && from && from->mailbox)
787 addr = from;
788 else if (to && to->mailbox)
789 addr = to;
790 else if (cc && cc->mailbox)
791 addr = cc;
792 else
793 addr = NULL;
794 if (addr)
795 {
796 struct Buffer *tmp = buf_pool_get();
797 mutt_safe_path(tmp, addr);
798 buf_add_printf(path, "=%s", buf_string(tmp));
799 buf_pool_release(&tmp);
800 }
801}
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:738
#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:723
An email address.
Definition: address.h:36
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_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 391 of file hook.c.

392{
393 struct Hook *h = NULL;
394 struct Hook *tmp = NULL;
395
396 TAILQ_FOREACH_SAFE(h, &Hooks, entries, tmp)
397 {
398 if ((type == MUTT_HOOK_NO_FLAGS) || (type == h->type))
399 {
400 TAILQ_REMOVE(&Hooks, h, entries);
401 hook_free(&h);
402 }
403 }
404}
static void hook_free(struct Hook **ptr)
Free a Hook.
Definition: hook.c:92
#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
+ 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 671 of file hook.c.

672{
673 struct Hook *tmp = NULL;
674
675 TAILQ_FOREACH(tmp, &Hooks, entries)
676 {
677 if (tmp->type & type)
678 {
679 if (mutt_regex_match(&tmp->regex, pat))
680 return tmp->command;
681 }
682 }
683 return NULL;
684}
+ 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 623 of file hook.c.

624{
625 if (!path && !desc)
626 return;
627
628 struct Hook *hook = NULL;
629 struct Buffer *err = buf_pool_get();
630
632
633 TAILQ_FOREACH(hook, &Hooks, entries)
634 {
635 if (!hook->command)
636 continue;
637
638 if (!(hook->type & MUTT_FOLDER_HOOK))
639 continue;
640
641 const char *match = NULL;
642 if (mutt_regex_match(&hook->regex, path))
643 match = path;
644 else if (mutt_regex_match(&hook->regex, desc))
645 match = desc;
646
647 if (match)
648 {
649 mutt_debug(LL_DEBUG1, "folder-hook '%s' matches '%s'\n", hook->regex.pattern, match);
650 mutt_debug(LL_DEBUG5, " %s\n", hook->command);
651 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
652 {
653 mutt_error("%s", buf_string(err));
654 break;
655 }
656 }
657 }
658 buf_pool_release(&err);
659
661}
static HookFlags CurrentHookType
The type of the hook currently being executed, e.g. MUTT_SAVE_HOOK.
Definition: hook.c:86
#define MUTT_FOLDER_HOOK
folder-hook: when entering a mailbox
Definition: hook.h:37
+ 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 983 of file hook.c.

984{
985 if (!IdxFmtHooks)
986 return NULL;
987
988 struct HookList *hl = mutt_hash_find(IdxFmtHooks, name);
989 if (!hl)
990 return NULL;
991
993
994 struct PatternCache cache = { 0 };
995 const struct Expando *exp = NULL;
996 struct Hook *hook = NULL;
997
998 TAILQ_FOREACH(hook, hl, entries)
999 {
1000 struct Pattern *pat = SLIST_FIRST(hook->pattern);
1001 if ((mutt_pattern_exec(pat, 0, m, e, &cache) > 0) ^ hook->regex.pat_not)
1002 {
1003 exp = hook->expando;
1004 break;
1005 }
1006 }
1007
1009
1010 return exp;
1011}
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:1132
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
static struct HashTable * IdxFmtHooks
All Index Format hooks.
Definition: hook.c:83
#define MUTT_IDXFMTHOOK
index-format-hook: customise the format of the index
Definition: hook.h:52
#define SLIST_FIRST(head)
Definition: queue.h:229
Parsed Expando trees.
Definition: expando.h:41
struct PatternList * pattern
Used for fcc,save,send-hook.
Definition: hook.c:73
struct Expando * expando
Used for format hooks.
Definition: hook.c:74
Cache commonly-used patterns.
Definition: lib.h:117
A simple (non-regex) pattern.
Definition: lib.h:77
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:

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

693{
694 struct Hook *hook = NULL;
695 struct PatternCache cache = { 0 };
696 struct Buffer *err = buf_pool_get();
697
698 CurrentHookType = type;
699
700 TAILQ_FOREACH(hook, &Hooks, entries)
701 {
702 if (!hook->command)
703 continue;
704
705 if (hook->type & type)
706 {
707 if ((mutt_pattern_exec(SLIST_FIRST(hook->pattern), 0, m, e, &cache) > 0) ^
708 hook->regex.pat_not)
709 {
710 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
711 {
712 mutt_error("%s", buf_string(err));
714 buf_pool_release(&err);
715
716 return;
717 }
718 /* Executing arbitrary commands could affect the pattern results,
719 * so the cache has to be wiped */
720 memset(&cache, 0, sizeof(cache));
721 }
722 }
723 }
724 buf_pool_release(&err);
725
727}
+ 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 808 of file hook.c.

809{
810 buf_alloc(path, PATH_MAX);
811
812 if (addr_hook(path, MUTT_FCC_HOOK, NULL, e) != 0)
813 {
814 const struct Address *to = TAILQ_FIRST(&e->env->to);
815 const struct Address *cc = TAILQ_FIRST(&e->env->cc);
816 const struct Address *bcc = TAILQ_FIRST(&e->env->bcc);
817 const bool c_save_name = cs_subset_bool(NeoMutt->sub, "save_name");
818 const bool c_force_name = cs_subset_bool(NeoMutt->sub, "force_name");
819 const char *const c_record = cs_subset_string(NeoMutt->sub, "record");
820 if ((c_save_name || c_force_name) && (to || cc || bcc))
821 {
822 const struct Address *addr = to ? to : (cc ? cc : bcc);
823 struct Buffer *buf = buf_pool_get();
824 mutt_safe_path(buf, addr);
825 const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
826 buf_concat_path(path, NONULL(c_folder), buf_string(buf));
827 buf_pool_release(&buf);
828 if (!c_force_name && (mx_access(buf_string(path), W_OK) != 0))
829 buf_strcpy(path, c_record);
830 }
831 else
832 {
833 buf_strcpy(path, c_record);
834 }
835 }
836 else
837 {
838 buf_fix_dptr(path);
839 }
840
841 buf_pretty_mailbox(path);
842}
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:182
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
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
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
#define PATH_MAX
Definition: mutt.h:42
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:

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

957{
958 struct Hook *hook = NULL;
959 struct Buffer *err = buf_pool_get();
960
961 TAILQ_FOREACH(hook, &Hooks, entries)
962 {
963 if (!(hook->command && (hook->type & type)))
964 continue;
965
966 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
967 {
968 mutt_error("%s", buf_string(err));
969 buf_reset(err);
970 }
971 }
972 buf_pool_release(&err);
973}
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
+ 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 924 of file hook.c.

925{
926 struct Hook *hook = NULL;
927 struct Buffer *err = buf_pool_get();
928
929 TAILQ_FOREACH(hook, &Hooks, entries)
930 {
931 if (!(hook->command && (hook->type & MUTT_TIMEOUT_HOOK)))
932 continue;
933
934 if (parse_rc_line_cwd(hook->command, hook->source_file, err) == MUTT_CMD_ERROR)
935 {
936 mutt_error("%s", buf_string(err));
937 buf_reset(err);
938
939 /* The hooks should be independent of each other, so even though this on
940 * failed, we'll carry on with the others. */
941 }
942 }
943 buf_pool_release(&err);
944
945 /* Delete temporary attachment files */
947}
#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:1309
+ Here is the call graph for this function:
+ Here is the caller graph for this function: