#endif
#include "mutt.h"
+#include "buffer.h"
#include "mx.h"
#include "mutt_crypt.h"
#include <ctype.h>
#include <unistd.h>
+#define ERROR_STOP 0
+
typedef struct hook {
int type; /* hook type */
rx_t rx; /* regular expression */
if (data & (M_FOLDERHOOK | M_MBOXHOOK)) {
strfcpy (path, pattern.data, sizeof (path));
_mutt_expand_path (path, sizeof (path), 1);
- FREE (&pattern.data);
+ mem_free (&pattern.data);
memset (&pattern, 0, sizeof (pattern));
pattern.data = str_dup (path);
}
strfcpy (tmp, pattern.data, sizeof (tmp));
mutt_check_simple (tmp, sizeof (tmp), DefaultHook);
- FREE (&pattern.data);
+ mem_free (&pattern.data);
memset (&pattern, 0, sizeof (pattern));
pattern.data = str_dup (tmp);
}
if (data & (M_MBOXHOOK | M_SAVEHOOK | M_FCCHOOK)) {
strfcpy (path, command.data, sizeof (path));
mutt_expand_path (path, sizeof (path));
- FREE (&command.data);
+ mem_free (&command.data);
memset (&command, 0, sizeof (command));
command.data = str_dup (path);
}
* pattern, so if we've already seen this pattern/command pair, just
* ignore it instead of creating a duplicate */
if (!str_cmp (ptr->command, command.data)) {
- FREE (&command.data);
- FREE (&pattern.data);
+ mem_free (&command.data);
+ mem_free (&pattern.data);
return 0;
}
}
* order of execution of the hooks, which i think is desirable since
* a common action to perform is to change the default (.) entry
* based upon some other information. */
- FREE (&ptr->command);
+ mem_free (&ptr->command);
ptr->command = command.data;
- FREE (&pattern.data);
+ mem_free (&pattern.data);
return 0;
}
}
goto error;
}
else {
- rx = safe_malloc (sizeof (regex_t));
+ rx = mem_malloc (sizeof (regex_t));
#ifdef M_CRYPTHOOK
if ((rc =
REGCOMP (rx, NONULL (pattern.data),
{
regerror (rc, rx, err->data, err->dsize);
regfree (rx);
- FREE (&rx);
+ mem_free (&rx);
goto error;
}
}
if (ptr) {
- ptr->next = safe_calloc (1, sizeof (HOOK));
+ ptr->next = mem_calloc (1, sizeof (HOOK));
ptr = ptr->next;
}
else
- Hooks = ptr = safe_calloc (1, sizeof (HOOK));
+ Hooks = ptr = mem_calloc (1, sizeof (HOOK));
ptr->type = data;
ptr->command = command.data;
ptr->pattern = pat;
return 0;
error:
- FREE (&pattern.data);
- FREE (&command.data);
+ mem_free (&pattern.data);
+ mem_free (&command.data);
return (-1);
}
static void delete_hook (HOOK * h)
{
- FREE (&h->command);
- FREE (&h->rx.pattern);
+ mem_free (&h->command);
+ mem_free (&h->rx.pattern);
if (h->rx.rx) {
regfree (h->rx.rx);
}
mutt_pattern_free (&h->pattern);
- FREE (&h);
+ mem_free (&h);
}
/* Deletes all hooks of type ``type'', or all defined hooks if ``type'' is 0 */
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;
+ if (ERROR_STOP) {
+ mem_free (&token.data);
+ current_hook_type = 0;
+ return;
+ }
}
}
}
}
- FREE (&token.data);
+ mem_free (&token.data);
current_hook_type = 0;
}
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;
+ if (ERROR_STOP) {
+ mem_free (&token.data);
+ current_hook_type = 0;
+ return;
+ }
}
}
- FREE (&token.data);
+ mem_free (&token.data);
current_hook_type = 0;
}
if ((regexec (hook->rx.rx, url, 0, NULL, 0) == 0) ^ hook->rx.not) {
if (mutt_parse_rc_line (hook->command, &token, &err) == -1) {
- FREE (&token.data);
mutt_error ("%s", err.data);
mutt_sleep (1);
-
- return;
+ if (ERROR_STOP) {
+ mem_free (&token.data);
+ current_hook_type = 0;
+ return;
+ }
}
}
}
- FREE (&token.data);
+ mem_free (&token.data);
}
#endif