NeoMutt  2020-04-24
Teaching an old dog new tricks
DOXYGEN
hook.h File Reference

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

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

Typedefs

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

Functions

void mutt_account_hook (const char *url)
 Perform an account hook. More...
 
void mutt_crypt_hook (struct ListHead *list, struct Address *addr)
 Find crypto hooks for an Address. More...
 
void mutt_default_save (char *path, size_t pathlen, struct Email *e)
 Find the default save path for an email. More...
 
void mutt_delete_hooks (HookFlags type)
 Delete matching hooks. More...
 
char * mutt_find_hook (HookFlags type, const char *pat)
 Find a matching hook. More...
 
void mutt_folder_hook (const char *path, const char *desc)
 Perform a folder hook. More...
 
const char * mutt_idxfmt_hook (const char *name, struct Mailbox *m, struct Email *e)
 Get index-format-hook format string. More...
 
void mutt_message_hook (struct Mailbox *m, struct Email *e, HookFlags type)
 Perform a message hook. More...
 
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() More...
 
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() More...
 
enum CommandResult mutt_parse_unhook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unhook' command - Implements Command::parse() More...
 
void mutt_select_fcc (struct Buffer *path, struct Email *e)
 Select the FCC path for an email. More...
 
void mutt_startup_shutdown_hook (HookFlags type)
 Execute any startup/shutdown hooks. More...
 
void mutt_timeout_hook (void)
 Execute any timeout hooks. More...
 

Variables

char * C_DefaultHook
 Config: Pattern to use for hooks that only have a simple regex. More...
 
bool C_ForceName
 Config: Save outgoing mail in a folder of their name. More...
 
bool C_SaveName
 Config: Save outgoing message to mailbox of recipient's name if it exists. More...
 

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 44 of file hook.h.

◆ MUTT_FOLDER_HOOK

#define MUTT_FOLDER_HOOK   (1 << 0)

folder-hook: when entering a mailbox

Definition at line 45 of file hook.h.

◆ MUTT_MBOX_HOOK

#define MUTT_MBOX_HOOK   (1 << 1)

mbox-hook: move messages after reading them

Definition at line 46 of file hook.h.

◆ MUTT_SEND_HOOK

#define MUTT_SEND_HOOK   (1 << 2)

send-hook: when composing a new email

Definition at line 47 of file hook.h.

◆ MUTT_FCC_HOOK

#define MUTT_FCC_HOOK   (1 << 3)

fcc-hook: to save outgoing email

Definition at line 48 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 49 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 50 of file hook.h.

◆ MUTT_ICONV_HOOK

#define MUTT_ICONV_HOOK   (1 << 6)

iconv-hook: create a system charset alias

Definition at line 51 of file hook.h.

◆ MUTT_MESSAGE_HOOK

#define MUTT_MESSAGE_HOOK   (1 << 7)

message-hook: run before displaying a message

Definition at line 52 of file hook.h.

◆ MUTT_CRYPT_HOOK

#define MUTT_CRYPT_HOOK   (1 << 8)

crypt-hook: automatically select a PGP/SMIME key

Definition at line 53 of file hook.h.

◆ MUTT_ACCOUNT_HOOK

#define MUTT_ACCOUNT_HOOK   (1 << 9)

account-hook: when changing between accounts

Definition at line 54 of file hook.h.

◆ MUTT_REPLY_HOOK

#define MUTT_REPLY_HOOK   (1 << 10)

reply-hook: when replying to an email

Definition at line 55 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 56 of file hook.h.

◆ MUTT_OPEN_HOOK

#define MUTT_OPEN_HOOK   (1 << 12)

open-hook: to read a compressed mailbox

Definition at line 58 of file hook.h.

◆ MUTT_APPEND_HOOK

#define MUTT_APPEND_HOOK   (1 << 13)

append-hook: append to a compressed mailbox

Definition at line 59 of file hook.h.

◆ MUTT_CLOSE_HOOK

#define MUTT_CLOSE_HOOK   (1 << 14)

close-hook: write to a compressed mailbox

Definition at line 60 of file hook.h.

◆ MUTT_IDXFMTHOOK

#define MUTT_IDXFMTHOOK   (1 << 15)

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

Definition at line 62 of file hook.h.

◆ MUTT_TIMEOUT_HOOK

#define MUTT_TIMEOUT_HOOK   (1 << 16)

timeout-hook: run a command periodically

Definition at line 63 of file hook.h.

◆ MUTT_STARTUP_HOOK

#define MUTT_STARTUP_HOOK   (1 << 17)

startup-hook: run when starting NeoMutt

Definition at line 64 of file hook.h.

◆ MUTT_SHUTDOWN_HOOK

#define MUTT_SHUTDOWN_HOOK   (1 << 18)

shutdown-hook: run when leaving NeoMutt

Definition at line 65 of file hook.h.

◆ MUTT_GLOBAL_HOOK

#define MUTT_GLOBAL_HOOK   (1 << 19)

Hooks which don't take a regex.

Definition at line 66 of file hook.h.

Typedef Documentation

◆ HookFlags

typedef uint32_t HookFlags

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

Definition at line 43 of file hook.h.

Function Documentation

◆ mutt_account_hook()

void mutt_account_hook ( const char *  url)

Perform an account hook.

Parameters
urlAccount URL to match

Definition at line 758 of file hook.c.

759 {
760  /* parsing commands with URLs in an account hook can cause a recursive
761  * call. We just skip processing if this occurs. Typically such commands
762  * belong in a folder-hook -- perhaps we should warn the user. */
763  static bool inhook = false;
764  if (inhook)
765  return;
766 
767  struct Hook *hook = NULL;
768  struct Buffer *err = mutt_buffer_pool_get();
769 
770  TAILQ_FOREACH(hook, &Hooks, entries)
771  {
772  if (!(hook->command && (hook->type & MUTT_ACCOUNT_HOOK)))
773  continue;
774 
775  if (mutt_regex_match(&hook->regex, url))
776  {
777  inhook = true;
778  mutt_debug(LL_DEBUG1, "account-hook '%s' matches '%s'\n", hook->regex.pattern, url);
779  mutt_debug(LL_DEBUG5, " %s\n", hook->command);
780 
781  if (mutt_parse_rc_line(hook->command, err) == MUTT_CMD_ERROR)
782  {
783  mutt_error("%s", mutt_b2s(err));
785 
786  inhook = false;
787  goto done;
788  }
789 
790  inhook = false;
791  }
792  }
793 done:
795 }
static struct HookList Hooks
Definition: hook.c:75
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
HookFlags type
Hook type.
Definition: hook.c:67
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
A list of user hooks.
Definition: hook.c:65
enum CommandResult mutt_parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: init.c:1038
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
struct Regex regex
Regular expression.
Definition: hook.c:68
#define mutt_b2s(buf)
Definition: buffer.h:41
Log at debug level 1.
Definition: logging.h:40
#define mutt_error(...)
Definition: logging.h:84
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:609
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
char * pattern
printable version
Definition: regex3.h:90
Log at debug level 5.
Definition: logging.h:44
#define MUTT_ACCOUNT_HOOK
account-hook: when changing between accounts
Definition: hook.h:54
+ 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 748 of file hook.c.

749 {
750  list_hook(list, addr->mailbox, MUTT_CRYPT_HOOK);
751 }
char * mailbox
Mailbox and host address.
Definition: address.h:37
static void list_hook(struct ListHead *matches, const char *match, HookFlags hook)
Find hook strings matching.
Definition: hook.c:728
#define MUTT_CRYPT_HOOK
crypt-hook: automatically select a PGP/SMIME key
Definition: hook.h:53
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_default_save()

void mutt_default_save ( char *  path,
size_t  pathlen,
struct Email e 
)

Find the default save path for an email.

Parameters
pathBuffer for the path
pathlenLength of buffer
eEmail

Definition at line 656 of file hook.c.

657 {
658  *path = '\0';
659  if (addr_hook(path, pathlen, MUTT_SAVE_HOOK, Context, e) == 0)
660  return;
661 
662  struct Envelope *env = e->env;
663  const struct Address *from = TAILQ_FIRST(&env->from);
664  const struct Address *reply_to = TAILQ_FIRST(&env->reply_to);
665  const struct Address *to = TAILQ_FIRST(&env->to);
666  const struct Address *cc = TAILQ_FIRST(&env->cc);
667  const struct Address *addr = NULL;
668  bool from_me = mutt_addr_is_user(from);
669 
670  if (!from_me && reply_to && reply_to->mailbox)
671  addr = reply_to;
672  else if (!from_me && from && from->mailbox)
673  addr = from;
674  else if (to && to->mailbox)
675  addr = to;
676  else if (cc && cc->mailbox)
677  addr = cc;
678  else
679  addr = NULL;
680  if (addr)
681  {
682  struct Buffer *tmp = mutt_buffer_pool_get();
683  mutt_safe_path(tmp, addr);
684  snprintf(path, pathlen, "=%s", mutt_b2s(tmp));
686  }
687 }
The "current" mailbox.
Definition: context.h:37
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define TAILQ_FIRST(head)
Definition: queue.h:716
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:62
static int addr_hook(char *path, size_t pathlen, HookFlags type, struct Context *ctx, struct Email *e)
Perform an address hook (get a path)
Definition: hook.c:623
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
An email address.
Definition: address.h:34
char * mailbox
Mailbox and host address.
Definition: address.h:37
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct Envelope * env
Envelope information.
Definition: email.h:89
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
void mutt_safe_path(struct Buffer *dest, const struct Address *a)
Make a safe filename from an email address.
Definition: muttlib.c:843
#define mutt_b2s(buf)
Definition: buffer.h:41
#define MUTT_SAVE_HOOK
save-hook: set a default folder when saving an email
Definition: hook.h:49
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:686
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
The header of an Email.
Definition: envelope.h:54
+ 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 0 is passed, all the hooks will be deleted.

Definition at line 307 of file hook.c.

308 {
309  struct Hook *h = NULL;
310  struct Hook *tmp = NULL;
311 
312  TAILQ_FOREACH_SAFE(h, &Hooks, entries, tmp)
313  {
314  if ((type == MUTT_HOOK_NO_FLAGS) || (type == h->type))
315  {
316  TAILQ_REMOVE(&Hooks, h, entries);
317  delete_hook(h);
318  }
319  }
320 }
static struct HookList Hooks
Definition: hook.c:75
HookFlags type
Hook type.
Definition: hook.c:67
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:728
A list of user hooks.
Definition: hook.c:65
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:834
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:44
static void delete_hook(struct Hook *h)
Delete a Hook.
Definition: hook.c:288
+ 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 555 of file hook.c.

556 {
557  struct Hook *tmp = NULL;
558 
559  TAILQ_FOREACH(tmp, &Hooks, entries)
560  {
561  if (tmp->type & type)
562  {
563  if (mutt_regex_match(&tmp->regex, pat))
564  return tmp->command;
565  }
566  }
567  return NULL;
568 }
static struct HookList Hooks
Definition: hook.c:75
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
HookFlags type
Hook type.
Definition: hook.c:67
A list of user hooks.
Definition: hook.c:65
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
struct Regex regex
Regular expression.
Definition: hook.c:68
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:609
+ 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 507 of file hook.c.

508 {
509  if (!path && !desc)
510  return;
511 
512  struct Hook *hook = NULL;
513  struct Buffer *err = mutt_buffer_pool_get();
514 
516 
517  TAILQ_FOREACH(hook, &Hooks, entries)
518  {
519  if (!hook->command)
520  continue;
521 
522  if (!(hook->type & MUTT_FOLDER_HOOK))
523  continue;
524 
525  const char *match = NULL;
526  if (mutt_regex_match(&hook->regex, path))
527  match = path;
528  else if (mutt_regex_match(&hook->regex, desc))
529  match = desc;
530 
531  if (match)
532  {
533  mutt_debug(LL_DEBUG1, "folder-hook '%s' matches '%s'\n", hook->regex.pattern, match);
534  mutt_debug(LL_DEBUG5, " %s\n", hook->command);
535  if (mutt_parse_rc_line(hook->command, err) == MUTT_CMD_ERROR)
536  {
537  mutt_error("%s", mutt_b2s(err));
538  break;
539  }
540  }
541  }
543 
545 }
static struct HookList Hooks
Definition: hook.c:75
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
HookFlags type
Hook type.
Definition: hook.c:67
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
static HookFlags current_hook_type
Definition: hook.c:78
String manipulation buffer.
Definition: buffer.h:33
A list of user hooks.
Definition: hook.c:65
enum CommandResult mutt_parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: init.c:1038
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
struct Regex regex
Regular expression.
Definition: hook.c:68
#define mutt_b2s(buf)
Definition: buffer.h:41
Log at debug level 1.
Definition: logging.h:40
#define mutt_error(...)
Definition: logging.h:84
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:609
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:44
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
char * pattern
printable version
Definition: regex3.h:90
Log at debug level 5.
Definition: logging.h:44
#define MUTT_FOLDER_HOOK
folder-hook: when entering a mailbox
Definition: hook.h:45
+ 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 870 of file hook.c.

871 {
872  if (!IdxFmtHooks)
873  return NULL;
874 
875  struct HookList *hl = mutt_hash_find(IdxFmtHooks, name);
876  if (!hl)
877  return NULL;
878 
880 
881  struct PatternCache cache = { 0 };
882  const char *fmtstring = NULL;
883  struct Hook *hook = NULL;
884 
885  TAILQ_FOREACH(hook, hl, entries)
886  {
887  struct Pattern *pat = SLIST_FIRST(hook->pattern);
888  if ((mutt_pattern_exec(pat, 0, m, e, &cache) > 0) ^ hook->regex.pat_not)
889  {
890  fmtstring = hook->command;
891  break;
892  }
893  }
894 
896 
897  return fmtstring;
898 }
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
void * mutt_hash_find(const struct Hash *table, const char *strkey)
Find the HashElem data in a Hash table element using a key.
Definition: hash.c:378
static HookFlags current_hook_type
Definition: hook.c:78
bool pat_not
do not match
Definition: regex3.h:92
A list of user hooks.
Definition: hook.c:65
#define MUTT_IDXFMTHOOK
index-format-hook: customise the format of the index
Definition: hook.h:62
A simple (non-regex) pattern.
Definition: pattern.h:49
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
const char * name
Definition: pgpmicalg.c:46
struct Regex regex
Regular expression.
Definition: hook.c:68
int 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: pattern.c:2121
static struct Hash * IdxFmtHooks
Definition: hook.c:77
#define SLIST_FIRST(head)
Definition: queue.h:228
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:44
Cache commonly-used patterns.
Definition: pattern.h:86
struct PatternList * pattern
Used for fcc,save,send-hook.
Definition: hook.c:70
+ 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 Context
eEmail
typeHook type, see HookFlags

Definition at line 576 of file hook.c.

577 {
578  struct Hook *hook = NULL;
579  struct PatternCache cache = { 0 };
580  struct Buffer *err = mutt_buffer_pool_get();
581 
582  current_hook_type = type;
583 
584  TAILQ_FOREACH(hook, &Hooks, entries)
585  {
586  if (!hook->command)
587  continue;
588 
589  if (hook->type & type)
590  {
591  if ((mutt_pattern_exec(SLIST_FIRST(hook->pattern), 0, m, e, &cache) > 0) ^
592  hook->regex.pat_not)
593  {
594  if (mutt_parse_rc_line(hook->command, err) == MUTT_CMD_ERROR)
595  {
596  mutt_error("%s", mutt_b2s(err));
599 
600  return;
601  }
602  /* Executing arbitrary commands could affect the pattern results,
603  * so the cache has to be wiped */
604  memset(&cache, 0, sizeof(cache));
605  }
606  }
607  }
609 
611 }
static struct HookList Hooks
Definition: hook.c:75
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
HookFlags type
Hook type.
Definition: hook.c:67
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
static HookFlags current_hook_type
Definition: hook.c:78
String manipulation buffer.
Definition: buffer.h:33
bool pat_not
do not match
Definition: regex3.h:92
A list of user hooks.
Definition: hook.c:65
enum CommandResult mutt_parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: init.c:1038
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
struct Regex regex
Regular expression.
Definition: hook.c:68
#define mutt_b2s(buf)
Definition: buffer.h:41
int 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: pattern.c:2121
#define SLIST_FIRST(head)
Definition: queue.h:228
#define mutt_error(...)
Definition: logging.h:84
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:44
Cache commonly-used patterns.
Definition: pattern.h:86
struct PatternList * pattern
Used for fcc,save,send-hook.
Definition: hook.c:70
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_parse_idxfmt_hook()

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 at line 354 of file hook.c.

356 {
357  enum CommandResult rc = MUTT_CMD_ERROR;
358  bool pat_not = false;
359 
360  struct Buffer *name = mutt_buffer_pool_get();
361  struct Buffer *pattern = mutt_buffer_pool_get();
362  struct Buffer *fmtstring = mutt_buffer_pool_get();
363 
364  if (!IdxFmtHooks)
365  {
368  }
369 
370  if (!MoreArgs(s))
371  {
372  mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
373  goto out;
374  }
376  struct HookList *hl = mutt_hash_find(IdxFmtHooks, mutt_b2s(name));
377 
378  if (*s->dptr == '!')
379  {
380  s->dptr++;
381  SKIPWS(s->dptr);
382  pat_not = true;
383  }
385 
386  if (!MoreArgs(s))
387  {
388  mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
389  goto out;
390  }
392 
393  if (MoreArgs(s))
394  {
395  mutt_buffer_printf(err, _("%s: too many arguments"), buf->data);
396  goto out;
397  }
398 
399  if (C_DefaultHook)
401 
402  /* check to make sure that a matching hook doesn't already exist */
403  struct Hook *hook = NULL;
404  if (hl)
405  {
406  TAILQ_FOREACH(hook, hl, entries)
407  {
408  if ((hook->regex.pat_not == pat_not) &&
409  (mutt_str_strcmp(mutt_b2s(pattern), hook->regex.pattern) == 0))
410  {
411  mutt_str_replace(&hook->command, mutt_b2s(fmtstring));
412  rc = MUTT_CMD_SUCCESS;
413  goto out;
414  }
415  }
416  }
417 
418  /* MUTT_PC_PATTERN_DYNAMIC sets so that date ranges are regenerated during
419  * matching. This of course is slower, but index-format-hook is commonly
420  * used for date ranges, and they need to be evaluated relative to "now", not
421  * the hook compilation time. */
422  struct PatternList *pat = mutt_pattern_comp(
424  if (!pat)
425  goto out;
426 
427  hook = mutt_mem_calloc(1, sizeof(struct Hook));
428  hook->type = data;
429  hook->command = mutt_buffer_strdup(fmtstring);
430  hook->pattern = pat;
431  hook->regex.pattern = mutt_buffer_strdup(pattern);
432  hook->regex.regex = NULL;
433  hook->regex.pat_not = pat_not;
434 
435  if (!hl)
436  {
437  hl = mutt_mem_calloc(1, sizeof(*hl));
438  TAILQ_INIT(hl);
440  }
441 
442  TAILQ_INSERT_TAIL(hl, hook, entries);
443  rc = MUTT_CMD_SUCCESS;
444 
445 out:
447  mutt_buffer_pool_release(&pattern);
448  mutt_buffer_pool_release(&fmtstring);
449 
450  return rc;
451 }
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
CommandResult
Error codes for command_t parse functions.
Definition: mutt_commands.h:33
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
HookFlags type
Hook type.
Definition: hook.c:67
void mutt_check_simple(struct Buffer *buf, const char *simple)
Convert a simple search into a real request.
Definition: pattern.c:2422
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
regex_t * regex
compiled expression
Definition: regex3.h:91
void * mutt_hash_find(const struct Hash *table, const char *strkey)
Find the HashElem data in a Hash table element using a key.
Definition: hash.c:378
char * mutt_buffer_strdup(struct Buffer *buf)
Copy a Buffer&#39;s string.
Definition: buffer.c:432
String manipulation buffer.
Definition: buffer.h:33
bool pat_not
do not match
Definition: regex3.h:92
A list of user hooks.
Definition: hook.c:65
#define _(a)
Definition: message.h:28
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
#define MUTT_PC_PATTERN_DYNAMIC
Enable runtime date range evaluation.
Definition: pattern.h:43
#define MoreArgs(buf)
Definition: buffer.h:43
const char * name
Definition: pgpmicalg.c:46
#define SKIPWS(ch)
Definition: string2.h:47
#define TAILQ_INIT(head)
Definition: queue.h:758
struct Regex regex
Regular expression.
Definition: hook.c:68
static void delete_idxfmt_hooklist(int type, void *obj, intptr_t data)
Delete a index-format-hook from the Hash Table - Implements hashelem_free_t.
Definition: hook.c:328
#define mutt_b2s(buf)
Definition: buffer.h:41
struct PatternList * mutt_pattern_comp(const char *s, PatternCompFlags flags, struct Buffer *err)
Create a Pattern.
Definition: pattern.c:1435
static struct Hash * IdxFmtHooks
Definition: hook.c:77
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: init.c:414
char * dptr
Current read/write position.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:35
struct Hash * mutt_hash_new(size_t nelem, HashFlags flags)
Create a new Hash table (with string keys)
Definition: hash.c:275
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:802
void mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:455
Success: Command worked.
Definition: mutt_commands.h:37
#define MUTT_PC_FULL_MSG
Enable body and header matching.
Definition: pattern.h:42
void mutt_hash_set_destructor(struct Hash *table, hashelem_free_t fn, intptr_t fn_data)
Set the destructor for a Hash Table.
Definition: hash.c:317
char * C_DefaultHook
Config: Pattern to use for hooks that only have a simple regex.
Definition: hook.c:58
char * pattern
printable version
Definition: regex3.h:90
#define MUTT_HASH_STRDUP_KEYS
make a copy of the keys
Definition: hash.h:76
struct HashElem * mutt_hash_insert(struct Hash *table, const char *strkey, void *data)
Add a new element to the Hash table (with string keys)
Definition: hash.c:351
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:641
struct PatternList * pattern
Used for fcc,save,send-hook.
Definition: hook.c:70
#define MUTT_TOKEN_NO_FLAGS
No flags are set.
Definition: mutt.h:70
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_parse_hook()

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()

This is used by 'account-hook', 'append-hook' and many more.

Definition at line 85 of file hook.c.

87 {
88  struct Hook *hook = NULL;
89  int rc = MUTT_CMD_ERROR;
90  bool pat_not = false;
91  regex_t *rx = NULL;
92  struct PatternList *pat = NULL;
93 
94  struct Buffer *cmd = mutt_buffer_pool_get();
95  struct Buffer *pattern = mutt_buffer_pool_get();
96 
97  if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
98  {
99  if (*s->dptr == '!')
100  {
101  s->dptr++;
102  SKIPWS(s->dptr);
103  pat_not = true;
104  }
105 
107 
108  if (!MoreArgs(s))
109  {
110  mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
111  rc = MUTT_CMD_WARNING;
112  goto cleanup;
113  }
114  }
115 
116  mutt_extract_token(cmd, s,
121 
122  if (mutt_buffer_is_empty(cmd))
123  {
124  mutt_buffer_printf(err, _("%s: too few arguments"), buf->data);
125  rc = MUTT_CMD_WARNING;
126  goto cleanup;
127  }
128 
129  if (MoreArgs(s))
130  {
131  mutt_buffer_printf(err, _("%s: too many arguments"), buf->data);
132  rc = MUTT_CMD_WARNING;
133  goto cleanup;
134  }
135 
137  {
138  /* Accidentally using the ^ mailbox shortcut in the .neomuttrc is a
139  * common mistake */
140  if ((pattern->data[0] == '^') && !CurrentFolder)
141  {
142  mutt_buffer_strcpy(err, _("current mailbox shortcut '^' is unset"));
143  goto cleanup;
144  }
145 
146  struct Buffer *tmp = mutt_buffer_pool_get();
147  mutt_buffer_copy(tmp, pattern);
149 
150  /* Check for other mailbox shortcuts that expand to the empty string.
151  * This is likely a mistake too */
152  if (mutt_buffer_is_empty(tmp) && !mutt_buffer_is_empty(pattern))
153  {
154  mutt_buffer_strcpy(err, _("mailbox shortcut expanded to empty regex"));
156  goto cleanup;
157  }
158 
159  mutt_buffer_copy(pattern, tmp);
161  }
162 #ifdef USE_COMP_MBOX
164  {
165  if (mutt_comp_valid_command(mutt_b2s(cmd)) == 0)
166  {
167  mutt_buffer_strcpy(err, _("badly formatted command string"));
168  goto cleanup;
169  }
170  }
171 #endif
172  else if (C_DefaultHook && (~data & MUTT_GLOBAL_HOOK) &&
174  (!WithCrypto || !(data & MUTT_CRYPT_HOOK)))
175  {
176  /* At this stage remain only message-hooks, reply-hooks, send-hooks,
177  * send2-hooks, save-hooks, and fcc-hooks: All those allowing full
178  * patterns. If given a simple regex, we expand $default_hook. */
180  }
181 
183  {
185  }
186 
187  /* check to make sure that a matching hook doesn't already exist */
188  TAILQ_FOREACH(hook, &Hooks, entries)
189  {
190  if (data & MUTT_GLOBAL_HOOK)
191  {
192  /* Ignore duplicate global hooks */
193  if (mutt_str_strcmp(hook->command, mutt_b2s(cmd)) == 0)
194  {
195  rc = MUTT_CMD_SUCCESS;
196  goto cleanup;
197  }
198  }
199  else if ((hook->type == data) && (hook->regex.pat_not == pat_not) &&
200  (mutt_str_strcmp(mutt_b2s(pattern), hook->regex.pattern) == 0))
201  {
203  MUTT_ACCOUNT_HOOK | MUTT_REPLY_HOOK | MUTT_CRYPT_HOOK |
205  {
206  /* these hooks allow multiple commands with the same
207  * pattern, so if we've already seen this pattern/command pair, just
208  * ignore it instead of creating a duplicate */
209  if (mutt_str_strcmp(hook->command, mutt_b2s(cmd)) == 0)
210  {
211  rc = MUTT_CMD_SUCCESS;
212  goto cleanup;
213  }
214  }
215  else
216  {
217  /* other hooks only allow one command per pattern, so update the
218  * entry with the new command. this currently does not change the
219  * order of execution of the hooks, which i think is desirable since
220  * a common action to perform is to change the default (.) entry
221  * based upon some other information. */
222  FREE(&hook->command);
223  hook->command = mutt_buffer_strdup(cmd);
224  rc = MUTT_CMD_SUCCESS;
225  goto cleanup;
226  }
227  }
228  }
229 
231  {
232  /* These are managed separately by the charset code */
234  if (mutt_ch_lookup_add(type, mutt_b2s(pattern), mutt_b2s(cmd), err))
235  rc = MUTT_CMD_SUCCESS;
236  goto cleanup;
237  }
240  {
241  PatternCompFlags comp_flags;
242 
243  if (data & (MUTT_SEND2_HOOK))
244  comp_flags = MUTT_PC_SEND_MODE_SEARCH;
245  else if (data & (MUTT_SEND_HOOK | MUTT_FCC_HOOK))
246  comp_flags = MUTT_PC_NO_FLAGS;
247  else
248  comp_flags = MUTT_PC_FULL_MSG;
249 
250  pat = mutt_pattern_comp(mutt_b2s(pattern), comp_flags, err);
251  if (!pat)
252  goto cleanup;
253  }
254  else if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
255  {
256  /* Hooks not allowing full patterns: Check syntax of regex */
257  rx = mutt_mem_malloc(sizeof(regex_t));
258  int rc2 = REG_COMP(rx, NONULL(mutt_b2s(pattern)),
259  ((data & MUTT_CRYPT_HOOK) ? REG_ICASE : 0));
260  if (rc2 != 0)
261  {
262  regerror(rc2, rx, err->data, err->dsize);
263  FREE(&rx);
264  goto cleanup;
265  }
266  }
267 
268  hook = mutt_mem_calloc(1, sizeof(struct Hook));
269  hook->type = data;
270  hook->command = mutt_buffer_strdup(cmd);
271  hook->pattern = pat;
272  hook->regex.pattern = mutt_buffer_strdup(pattern);
273  hook->regex.regex = rx;
274  hook->regex.pat_not = pat_not;
275  TAILQ_INSERT_TAIL(&Hooks, hook, entries);
276  rc = MUTT_CMD_SUCCESS;
277 
278 cleanup:
280  mutt_buffer_pool_release(&pattern);
281  return rc;
282 }
#define MUTT_SEND_HOOK
send-hook: when composing a new email
Definition: hook.h:47
Character set conversion.
Definition: charset.h:78
static struct HookList Hooks
Definition: hook.c:75
#define NONULL(x)
Definition: string2.h:37
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
#define WithCrypto
Definition: lib.h:163
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define MUTT_SHUTDOWN_HOOK
shutdown-hook: run when leaving NeoMutt
Definition: hook.h:65
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
size_t mutt_buffer_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer&#39;s contents to another Buffer.
Definition: buffer.c:445
HookFlags type
Hook type.
Definition: hook.c:67
void mutt_check_simple(struct Buffer *buf, const char *simple)
Convert a simple search into a real request.
Definition: pattern.c:2422
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
regex_t * regex
compiled expression
Definition: regex3.h:91
char * mutt_buffer_strdup(struct Buffer *buf)
Copy a Buffer&#39;s string.
Definition: buffer.c:432
String manipulation buffer.
Definition: buffer.h:33
bool pat_not
do not match
Definition: regex3.h:92
A list of user hooks.
Definition: hook.c:65
#define _(a)
Definition: message.h:28
#define MUTT_CHARSET_HOOK
charset-hook: create a charset alias for malformed emails
Definition: hook.h:50
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:52
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:478
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
#define MUTT_CRYPT_HOOK
crypt-hook: automatically select a PGP/SMIME key
Definition: hook.h:53
void mutt_buffer_expand_path_regex(struct Buffer *buf, bool regex)
Create the canonical path (with regex char escaping)
Definition: muttlib.c:144
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
size_t dsize
Length of data.
Definition: buffer.h:37
#define MoreArgs(buf)
Definition: buffer.h:43
#define MUTT_ICONV_HOOK
iconv-hook: create a system charset alias
Definition: hook.h:51
LookupType
Types of character set lookups.
Definition: charset.h:75
#define REG_COMP(preg, regex, cflags)
Compile a regular expression.
Definition: regex3.h:53
#define SKIPWS(ch)
Definition: string2.h:47
WHERE char * CurrentFolder
Currently selected mailbox.
Definition: globals.h:54
struct Regex regex
Regular expression.
Definition: hook.c:68
#define MUTT_APPEND_HOOK
append-hook: append to a compressed mailbox
Definition: hook.h:59
#define MUTT_MBOX_HOOK
mbox-hook: move messages after reading them
Definition: hook.h:46
#define MUTT_GLOBAL_HOOK
Hooks which don&#39;t take a regex.
Definition: hook.h:66
#define mutt_b2s(buf)
Definition: buffer.h:41
struct PatternList * mutt_pattern_comp(const char *s, PatternCompFlags flags, struct Buffer *err)
Create a Pattern.
Definition: pattern.c:1435
#define MUTT_SAVE_HOOK
save-hook: set a default folder when saving an email
Definition: hook.h:49
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: init.c:414
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
#define MUTT_CLOSE_HOOK
close-hook: write to a compressed mailbox
Definition: hook.h:60
char * dptr
Current read/write position.
Definition: buffer.h:36
#define MUTT_TOKEN_SPACE
Don&#39;t treat whitespace as a term.
Definition: mutt.h:73
char * data
Pointer to data.
Definition: buffer.h:35
int mutt_comp_valid_command(const char *cmd)
Is this command string allowed?
Definition: compress.c:388
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:802
#define MUTT_OPEN_HOOK
open-hook: to read a compressed mailbox
Definition: hook.h:58
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:312
#define MUTT_TIMEOUT_HOOK
timeout-hook: run a command periodically
Definition: hook.h:63
Success: Command worked.
Definition: mutt_commands.h:37
void mutt_buffer_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:327
#define MUTT_PC_NO_FLAGS
No flags are set.
Definition: pattern.h:41
Warning: Help given to the user.
Definition: mutt_commands.h:36
#define MUTT_SEND2_HOOK
send2-hook: when changing fields in the compose menu
Definition: hook.h:56
#define MUTT_REPLY_HOOK
reply-hook: when replying to an email
Definition: hook.h:55
#define MUTT_PC_SEND_MODE_SEARCH
Allow send-mode body searching.
Definition: pattern.h:44
#define FREE(x)
Definition: memory.h:40
#define MUTT_PC_FULL_MSG
Enable body and header matching.
Definition: pattern.h:42
uint8_t PatternCompFlags
Flags for mutt_pattern_comp(), e.g. MUTT_PC_FULL_MSG.
Definition: pattern.h:40
char * C_DefaultHook
Config: Pattern to use for hooks that only have a simple regex.
Definition: hook.c:58
char * pattern
printable version
Definition: regex3.h:90
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
#define MUTT_STARTUP_HOOK
startup-hook: run when starting NeoMutt
Definition: hook.h:64
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:641
Alias for another character set.
Definition: charset.h:77
#define MUTT_FCC_HOOK
fcc-hook: to save outgoing email
Definition: hook.h:48
struct PatternList * pattern
Used for fcc,save,send-hook.
Definition: hook.c:70
#define MUTT_ACCOUNT_HOOK
account-hook: when changing between accounts
Definition: hook.h:54
#define MUTT_TOKEN_NO_FLAGS
No flags are set.
Definition: mutt.h:70
#define MUTT_FOLDER_HOOK
folder-hook: when entering a mailbox
Definition: hook.h:45
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_parse_unhook()

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 at line 456 of file hook.c.

458 {
459  while (MoreArgs(s))
460  {
462  if (mutt_str_strcmp("*", buf->data) == 0)
463  {
465  {
466  mutt_buffer_printf(err, "%s", _("unhook: Can't do unhook * from within a hook"));
467  return MUTT_CMD_WARNING;
468  }
472  }
473  else
474  {
475  HookFlags type = mutt_get_hook_type(buf->data);
476 
477  if (type == MUTT_HOOK_NO_FLAGS)
478  {
479  mutt_buffer_printf(err, _("unhook: unknown hook type: %s"), buf->data);
480  return MUTT_CMD_ERROR;
481  }
482  if (type & (MUTT_CHARSET_HOOK | MUTT_ICONV_HOOK))
483  {
485  return MUTT_CMD_SUCCESS;
486  }
487  if (current_hook_type == type)
488  {
489  mutt_buffer_printf(err, _("unhook: Can't delete a %s from within a %s"),
490  buf->data, buf->data);
491  return MUTT_CMD_WARNING;
492  }
493  if (type == MUTT_IDXFMTHOOK)
495  else
496  mutt_delete_hooks(type);
497  }
498  }
499  return MUTT_CMD_SUCCESS;
500 }
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
static void delete_idxfmt_hooks(void)
Delete all the index-format-hooks.
Definition: hook.c:346
HookFlags mutt_get_hook_type(const char *name)
Find a hook by name.
Definition: init.c:713
static HookFlags current_hook_type
Definition: hook.c:78
#define _(a)
Definition: message.h:28
void mutt_delete_hooks(HookFlags type)
Delete matching hooks.
Definition: hook.c:307
#define MUTT_CHARSET_HOOK
charset-hook: create a charset alias for malformed emails
Definition: hook.h:50
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
uint32_t HookFlags
Flags for mutt_parse_hook(), e.g. MUTT_FOLDER_HOOK.
Definition: hook.h:43
#define MUTT_IDXFMTHOOK
index-format-hook: customise the format of the index
Definition: hook.h:62
#define MoreArgs(buf)
Definition: buffer.h:43
#define MUTT_ICONV_HOOK
iconv-hook: create a system charset alias
Definition: hook.h:51
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: init.c:414
char * data
Pointer to data.
Definition: buffer.h:35
void mutt_ch_lookup_remove(void)
Remove all the character set lookups.
Definition: charset.c:510
Success: Command worked.
Definition: mutt_commands.h:37
Warning: Help given to the user.
Definition: mutt_commands.h:36
#define MUTT_HOOK_NO_FLAGS
No flags are set.
Definition: hook.h:44
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:641
#define MUTT_TOKEN_NO_FLAGS
No flags are set.
Definition: mutt.h:70
+ Here is the call 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 694 of file hook.c.

695 {
697 
698  if (addr_hook(path->data, path->dsize, MUTT_FCC_HOOK, NULL, e) != 0)
699  {
700  const struct Address *to = TAILQ_FIRST(&e->env->to);
701  const struct Address *cc = TAILQ_FIRST(&e->env->cc);
702  const struct Address *bcc = TAILQ_FIRST(&e->env->bcc);
703  if ((C_SaveName || C_ForceName) && (to || cc || bcc))
704  {
705  const struct Address *addr = to ? to : (cc ? cc : bcc);
706  struct Buffer *buf = mutt_buffer_pool_get();
707  mutt_safe_path(buf, addr);
710  if (!C_ForceName && (mx_access(mutt_b2s(path), W_OK) != 0))
712  }
713  else
715  }
716  else
717  mutt_buffer_fix_dptr(path);
718 
720 }
#define NONULL(x)
Definition: string2.h:37
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define TAILQ_FIRST(head)
Definition: queue.h:716
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
static int addr_hook(char *path, size_t pathlen, HookFlags type, struct Context *ctx, struct Email *e)
Perform an address hook (get a path)
Definition: hook.c:623
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
An email address.
Definition: address.h:34
WHERE char * C_Record
Config: Folder to save &#39;sent&#39; messages.
Definition: globals.h:132
void mutt_buffer_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using &#39;~&#39; or &#39;=&#39;.
Definition: muttlib.c:688
size_t dsize
Length of data.
Definition: buffer.h:37
struct Envelope * env
Envelope information.
Definition: email.h:89
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
bool C_ForceName
Config: Save outgoing mail in a folder of their name.
Definition: hook.c:59
void mutt_buffer_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:181
void mutt_safe_path(struct Buffer *dest, const struct Address *a)
Make a safe filename from an email address.
Definition: muttlib.c:843
#define mutt_b2s(buf)
Definition: buffer.h:41
WHERE char * C_Folder
Config: Base folder for a set of mailboxes.
Definition: globals.h:121
#define PATH_MAX
Definition: mutt.h:44
char * data
Pointer to data.
Definition: buffer.h:35
bool C_SaveName
Config: Save outgoing message to mailbox of recipient&#39;s name if it exists.
Definition: hook.c:60
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:312
size_t mutt_buffer_concat_path(struct Buffer *buf, const char *dir, const char *fname)
Join a directory name and a filename.
Definition: buffer.c:374
int mx_access(const char *path, int flags)
Wrapper for access, checks permissions on a given mailbox.
Definition: mx.c:171
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define MUTT_FCC_HOOK
fcc-hook: to save outgoing email
Definition: hook.h:48
void mutt_buffer_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:265
+ 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 840 of file hook.c.

841 {
842  struct Hook *hook = NULL;
843  struct Buffer err = mutt_buffer_make(0);
844  char buf[256];
845 
846  err.data = buf;
847  err.dsize = sizeof(buf);
848 
849  TAILQ_FOREACH(hook, &Hooks, entries)
850  {
851  if (!(hook->command && (hook->type & type)))
852  continue;
853 
854  if (mutt_parse_rc_line(hook->command, &err) == MUTT_CMD_ERROR)
855  {
856  mutt_error("%s", err.data);
857  mutt_buffer_reset(&err);
858  }
859  }
860 }
static struct HookList Hooks
Definition: hook.c:75
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:79
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
HookFlags type
Hook type.
Definition: hook.c:67
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
A list of user hooks.
Definition: hook.c:65
enum CommandResult mutt_parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: init.c:1038
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
size_t dsize
Length of data.
Definition: buffer.h:37
char * data
Pointer to data.
Definition: buffer.h:35
#define mutt_error(...)
Definition: logging.h:84
+ 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 804 of file hook.c.

805 {
806  struct Hook *hook = NULL;
807  struct Buffer err;
808  char buf[256];
809 
810  mutt_buffer_init(&err);
811  err.data = buf;
812  err.dsize = sizeof(buf);
813 
814  TAILQ_FOREACH(hook, &Hooks, entries)
815  {
816  if (!(hook->command && (hook->type & MUTT_TIMEOUT_HOOK)))
817  continue;
818 
819  if (mutt_parse_rc_line(hook->command, &err) == MUTT_CMD_ERROR)
820  {
821  mutt_error("%s", err.data);
822  mutt_buffer_reset(&err);
823 
824  /* The hooks should be independent of each other, so even though this on
825  * failed, we'll carry on with the others. */
826  }
827  }
828 
829  /* Delete temporary attachment files */
831 }
static struct HookList Hooks
Definition: hook.c:75
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:79
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
HookFlags type
Hook type.
Definition: hook.c:67
String manipulation buffer.
Definition: buffer.h:33
A list of user hooks.
Definition: hook.c:65
enum CommandResult mutt_parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: init.c:1038
void mutt_unlink_temp_attachments(void)
Delete all temporary attachments.
Definition: mutt_attach.c:1230
char * command
Filename, command or pattern to execute.
Definition: hook.c:69
#define MUTT_TIMEOUT_HOOK
timeout-hook: run a command periodically
Definition: hook.h:63
#define mutt_error(...)
Definition: logging.h:84
struct Buffer * mutt_buffer_init(struct Buffer *buf)
Initialise a new Buffer.
Definition: buffer.c:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ C_DefaultHook

char* C_DefaultHook

Config: Pattern to use for hooks that only have a simple regex.

Definition at line 58 of file hook.c.

◆ C_ForceName

bool C_ForceName

Config: Save outgoing mail in a folder of their name.

Definition at line 59 of file hook.c.

◆ C_SaveName

bool C_SaveName

Config: Save outgoing message to mailbox of recipient's name if it exists.

Definition at line 60 of file hook.c.