void mutt_message_hook (CONTEXT *ctx, HEADER *hdr, int type)
{
BUFFER err, token;
HOOK *hook;
current_hook_type = type;
mutt_buffer_init (&err);
err.dsize = STRING;
err.data = safe_malloc (err.dsize);
mutt_buffer_init (&token);
for (hook = Hooks; hook; hook = hook->next)
{
if(!hook->command)
continue;
if (hook->type & type)
if ((mutt_pattern_exec (hook->pattern, 0, ctx, hdr) > 0) ^ hook->rx.not)
if (mutt_parse_rc_line (hook->command, &token, &err) != 0)
{
FREE (&token.data);
mutt_error ("%s", err.data);
mutt_sleep (1);
current_hook_type = 0;
FREE (&err.data);
return;
}
}
FREE (&token.data);
FREE (&err.data);
current_hook_type = 0;
}
void mutt_message_hook (CONTEXT *ctx, HEADER *hdr, int type)
{
BUFFER err, token;
HOOK *hook;
char buf[STRING];
current_hook_type = type;
err.data = buf;
err.dsize = sizeof (buf);
memset (&token, 0, sizeof (token));
for (hook = Hooks; hook; hook = hook->next)
{
if(!hook->command)
continue;
if (hook->type & type)
if ((mutt_pattern_exec (hook->pattern, 0, ctx, hdr) > 0) ^ hook->rx.not)
if (mutt_parse_rc_line (hook->command, &token, &err) != 0)
{
FREE (&token.data);
mutt_error ("%s", err.data);
mutt_sleep (1);
current_hook_type = 0;
return;
}
}
FREE (&token.data);
current_hook_type = 0;
}
void mutt_folder_hook (char *path)
{
HOOK *tmp = Hooks;
BUFFER err, token;
char buf[STRING];
current_hook_type = M_FOLDERHOOK;
err.data = buf;
err.dsize = sizeof (buf);
memset (&token, 0, sizeof (token));
for (; tmp; tmp = tmp->next)
{
if(!tmp->command)
continue;
if (tmp->type & M_FOLDERHOOK)
{
if ((regexec (tmp->rx.rx, path, 0, NULL, 0) == 0) ^ tmp->rx.not)
{
if (mutt_parse_rc_line (tmp->command, &token, &err) == -1)
{
mutt_error ("%s", err.data);
FREE (&token.data);
mutt_sleep (1); /* pause a moment to let the user see the error */
current_hook_type = 0;
return;
}
}
}
}
FREE (&token.data);
current_hook_type = 0;
}
/* enter a mutt command */
void mutt_enter_command (void)
{
BUFFER err, token;
char buffer[LONG_STRING];
int r;
buffer[0] = 0;
if (mutt_get_field (":", buffer, sizeof (buffer), M_COMMAND) != 0 || !buffer[0])
return;
mutt_buffer_init (&err);
err.dsize = STRING;
err.data = safe_malloc(err.dsize);
mutt_buffer_init (&token);
r = mutt_parse_rc_line (buffer, &token, &err);
FREE (&token.data);
if (err.data[0])
{
/* since errbuf could potentially contain printf() sequences in it,
we must call mutt_error() in this fashion so that vsprintf()
doesn't expect more arguments that we passed */
if (r == 0)
mutt_message ("%s", err.data);
else
mutt_error ("%s", err.data);
}
FREE (&err.data);
}
void mutt_account_hook (const char* url)
{
/* parsing commands with URLs in an account hook can cause a recursive
* call. We just skip processing if this occurs. Typically such commands
* belong in a folder-hook -- perhaps we should warn the user. */
static int inhook = 0;
HOOK* hook;
BUFFER token;
BUFFER err;
if (inhook)
return;
mutt_buffer_init (&err);
err.dsize = STRING;
err.data = safe_malloc (err.dsize);
mutt_buffer_init (&token);
for (hook = Hooks; hook; hook = hook->next)
{
if (! (hook->command && (hook->type & M_ACCOUNTHOOK)))
continue;
if ((regexec (hook->rx.rx, url, 0, NULL, 0) == 0) ^ hook->rx.not)
{
inhook = 1;
if (mutt_parse_rc_line (hook->command, &token, &err) == -1)
{
FREE (&token.data);
mutt_error ("%s", err.data);
FREE (&err.data);
mutt_sleep (1);
inhook = 0;
return;
}
inhook = 0;
}
}
FREE (&token.data);
FREE (&err.data);
}
void mutt_folder_hook (char *path)
{
HOOK *tmp = Hooks;
BUFFER err, token;
current_hook_type = MUTT_FOLDERHOOK;
mutt_buffer_init (&err);
err.dsize = STRING;
err.data = safe_malloc (err.dsize);
mutt_buffer_init (&token);
for (; tmp; tmp = tmp->next)
{
if(!tmp->command)
continue;
if (tmp->type & MUTT_FOLDERHOOK)
{
if ((regexec (tmp->rx.rx, path, 0, NULL, 0) == 0) ^ tmp->rx.not)
{
if (mutt_parse_rc_line (tmp->command, &token, &err) == -1)
{
mutt_error ("%s", err.data);
FREE (&token.data);
mutt_sleep (1); /* pause a moment to let the user see the error */
current_hook_type = 0;
FREE (&err.data);
return;
}
}
}
}
FREE (&token.data);
FREE (&err.data);
current_hook_type = 0;
}
