X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=35577a40ff641cf94c7929604dc9a5d139bb6ef6;hp=d566add3f711c81eb326487737707280879c96b8;hb=fa7f733a61a6fe3143198791ab470ddf4d08fdbe;hpb=047342c2a0526885217e03d06e9b7a715f55b92f diff --git a/init.c b/init.c index d566add..35577a4 100644 --- a/init.c +++ b/init.c @@ -1,25 +1,19 @@ /* + * Copyright notice from original mutt: * Copyright (C) 1996-2002 Michael R. Elkins - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. - */ + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ + +#if HAVE_CONFIG_H +# include "config.h" +#endif #include "mutt.h" #include "mapping.h" #include "mutt_curses.h" -#include "mutt_regex.h" #include "history.h" #include "keymap.h" #include "mbyte.h" @@ -27,29 +21,30 @@ #include "mutt_crypt.h" #include "mutt_idna.h" -#if defined(USE_SSL) || defined(USE_NSS) +#if defined(USE_SSL) || defined(USE_NSS) || defined(USE_GNUTLS) #include "mutt_ssl.h" #endif - - #include "mx.h" #include "init.h" #include "mailbox.h" +#include "lib/mem.h" +#include "lib/intl.h" +#include "lib/str.h" +#include "lib/rx.h" + #include #include #include #include #include #include -#include -#include #include void toggle_quadoption (int opt) { - int n = opt/4; + int n = opt / 4; int b = (opt % 4) * 2; QuadOptions[n] ^= (1 << b); @@ -57,7 +52,7 @@ void toggle_quadoption (int opt) void set_quadoption (int opt, int flag) { - int n = opt/4; + int n = opt / 4; int b = (opt % 4) * 2; QuadOptions[n] &= ~(0x3 << b); @@ -66,7 +61,7 @@ void set_quadoption (int opt, int flag) int quadoption (int opt) { - int n = opt/4; + int n = opt / 4; int b = (opt % 4) * 2; return (QuadOptions[n] >> b) & 0x3; @@ -76,16 +71,15 @@ int query_quadoption (int opt, const char *prompt) { int v = quadoption (opt); - switch (v) - { - case M_YES: - case M_NO: - return (v); + switch (v) { + case M_YES: + case M_NO: + return (v); - default: - v = mutt_yesorno (prompt, (v == M_ASKYES)); - CLEARLINE (LINES - 1); - return (v); + default: + v = mutt_yesorno (prompt, (v == M_ASKYES)); + CLEARLINE (LINES - 1); + return (v); } /* not reached */ @@ -99,126 +93,120 @@ int mutt_option_index (char *s) for (i = 0; MuttVars[i].option; i++) if (mutt_strcmp (s, MuttVars[i].option) == 0) - return (MuttVars[i].type == DT_SYN ? mutt_option_index ((char *) MuttVars[i].data) : i); + return (MuttVars[i].type == + DT_SYN ? mutt_option_index ((char *) MuttVars[i].data) : i); return (-1); } -int mutt_extract_token (BUFFER *dest, BUFFER *tok, int flags) +int mutt_extract_token (BUFFER * dest, BUFFER * tok, int flags) { - char ch; - char qc = 0; /* quote char */ - char *pc; + char ch; + char qc = 0; /* quote char */ + char *pc; /* reset the destination pointer to the beginning of the buffer */ dest->dptr = dest->data; SKIPWS (tok->dptr); - while ((ch = *tok->dptr)) - { - if (!qc) - { + while ((ch = *tok->dptr)) { + if (!qc) { if ((ISSPACE (ch) && !(flags & M_TOKEN_SPACE)) || - (ch == '#' && !(flags & M_TOKEN_COMMENT)) || - (ch == '=' && (flags & M_TOKEN_EQUAL)) || - (ch == ';' && !(flags & M_TOKEN_SEMICOLON)) || - ((flags & M_TOKEN_PATTERN) && strchr ("~!|", ch))) - break; + (ch == '#' && !(flags & M_TOKEN_COMMENT)) || + (ch == '=' && (flags & M_TOKEN_EQUAL)) || + (ch == ';' && !(flags & M_TOKEN_SEMICOLON)) || + ((flags & M_TOKEN_PATTERN) && strchr ("~!|", ch))) + break; } tok->dptr++; if (ch == qc) - qc = 0; /* end of quote */ + qc = 0; /* end of quote */ else if (!qc && (ch == '\'' || ch == '"') && !(flags & M_TOKEN_QUOTE)) qc = ch; - else if (ch == '\\' && qc != '\'') - { - if (!*tok->dptr) - return -1; /* premature end of token */ - switch (ch = *tok->dptr++) - { - case 'c': - case 'C': - if (!*tok->dptr) - return -1; /* premature end of token */ - mutt_buffer_addch (dest, (toupper ((unsigned char) *tok->dptr) - - '@') & 0x7f); - tok->dptr++; - break; - case 'r': - mutt_buffer_addch (dest, '\r'); - break; - case 'n': - mutt_buffer_addch (dest, '\n'); - break; - case 't': - mutt_buffer_addch (dest, '\t'); - break; - case 'f': - mutt_buffer_addch (dest, '\f'); - break; - case 'e': - mutt_buffer_addch (dest, '\033'); - break; - default: - if (isdigit ((unsigned char) ch) && - isdigit ((unsigned char) *tok->dptr) && - isdigit ((unsigned char) *(tok->dptr + 1))) - { - - mutt_buffer_addch (dest, (ch << 6) + (*tok->dptr << 3) + *(tok->dptr + 1) - 3504); - tok->dptr += 2; - } - else - mutt_buffer_addch (dest, ch); + else if (ch == '\\' && qc != '\'') { + if (!*tok->dptr) + return -1; /* premature end of token */ + switch (ch = *tok->dptr++) { + case 'c': + case 'C': + if (!*tok->dptr) + return -1; /* premature end of token */ + mutt_buffer_addch (dest, (toupper ((unsigned char) *tok->dptr) + - '@') & 0x7f); + tok->dptr++; + break; + case 'r': + mutt_buffer_addch (dest, '\r'); + break; + case 'n': + mutt_buffer_addch (dest, '\n'); + break; + case 't': + mutt_buffer_addch (dest, '\t'); + break; + case 'f': + mutt_buffer_addch (dest, '\f'); + break; + case 'e': + mutt_buffer_addch (dest, '\033'); + break; + default: + if (isdigit ((unsigned char) ch) && + isdigit ((unsigned char) *tok->dptr) && + isdigit ((unsigned char) *(tok->dptr + 1))) { + + mutt_buffer_addch (dest, + (ch << 6) + (*tok->dptr << 3) + *(tok->dptr + + 1) - 3504); + tok->dptr += 2; + } + else + mutt_buffer_addch (dest, ch); } } - else if (ch == '^' && (flags & M_TOKEN_CONDENSE)) - { - if (!*tok->dptr) - return -1; /* premature end of token */ + else if (ch == '^' && (flags & M_TOKEN_CONDENSE)) { + if (!*tok->dptr) + return -1; /* premature end of token */ ch = *tok->dptr++; if (ch == '^') - mutt_buffer_addch (dest, ch); + mutt_buffer_addch (dest, ch); else if (ch == '[') - mutt_buffer_addch (dest, '\033'); + mutt_buffer_addch (dest, '\033'); else if (isalpha ((unsigned char) ch)) - mutt_buffer_addch (dest, toupper ((unsigned char) ch) - '@'); - else - { - mutt_buffer_addch (dest, '^'); - mutt_buffer_addch (dest, ch); + mutt_buffer_addch (dest, toupper ((unsigned char) ch) - '@'); + else { + mutt_buffer_addch (dest, '^'); + mutt_buffer_addch (dest, ch); } } - else if (ch == '`' && (!qc || qc == '"')) - { - FILE *fp; - pid_t pid; - char *cmd, *ptr; - size_t expnlen; - BUFFER expn; - int line = 0; + else if (ch == '`' && (!qc || qc == '"')) { + FILE *fp; + pid_t pid; + char *cmd, *ptr; + size_t expnlen; + BUFFER expn; + int line = 0; pc = tok->dptr; do { - if ((pc = strpbrk (pc, "\\`"))) - { - /* skip any quoted chars */ - if (*pc == '\\') - pc += 2; - } + if ((pc = strpbrk (pc, "\\`"))) { + /* skip any quoted chars */ + if (*pc == '\\') + pc += 2; + } } while (pc && *pc != '`'); - if (!pc) - { - dprint (1, (debugfile, "mutt_get_token: mismatched backtics\n")); - return (-1); + if (!pc) { + dprint (1, (debugfile, "mutt_get_token: mismatched backtics\n")); + return (-1); } cmd = mutt_substrdup (tok->dptr, pc); - if ((pid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0) - { - dprint (1, (debugfile, "mutt_get_token: unable to fork command: %s", cmd)); - FREE (&cmd); - return (-1); + if ((pid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0) { + dprint (1, + (debugfile, "mutt_get_token: unable to fork command: %s", + cmd)); + FREE (&cmd); + return (-1); } FREE (&cmd); @@ -231,63 +219,58 @@ int mutt_extract_token (BUFFER *dest, BUFFER *tok, int flags) mutt_wait_filter (pid); /* if we got output, make a new string consiting of the shell ouptput - plus whatever else was left on the original line */ + plus whatever else was left on the original line */ /* BUT: If this is inside a quoted string, directly add output to * the token */ - if (expn.data && qc) - { - mutt_buffer_addstr (dest, expn.data); - FREE (&expn.data); + if (expn.data && qc) { + mutt_buffer_addstr (dest, expn.data); + FREE (&expn.data); } - else if (expn.data) - { - expnlen = mutt_strlen (expn.data); - tok->dsize = expnlen + mutt_strlen (tok->dptr) + 1; - ptr = safe_malloc (tok->dsize); - memcpy (ptr, expn.data, expnlen); - strcpy (ptr + expnlen, tok->dptr); /* __STRCPY_CHECKED__ */ - if (tok->destroy) - FREE (&tok->data); - tok->data = ptr; - tok->dptr = ptr; - tok->destroy = 1; /* mark that the caller should destroy this data */ - ptr = NULL; - FREE (&expn.data); + else if (expn.data) { + expnlen = mutt_strlen (expn.data); + tok->dsize = expnlen + mutt_strlen (tok->dptr) + 1; + ptr = safe_malloc (tok->dsize); + memcpy (ptr, expn.data, expnlen); + strcpy (ptr + expnlen, tok->dptr); /* __STRCPY_CHECKED__ */ + if (tok->destroy) + FREE (&tok->data); + tok->data = ptr; + tok->dptr = ptr; + tok->destroy = 1; /* mark that the caller should destroy this data */ + ptr = NULL; + FREE (&expn.data); } } - else if (ch == '$' && (!qc || qc == '"') && (*tok->dptr == '{' || isalpha ((unsigned char) *tok->dptr))) - { + else if (ch == '$' && (!qc || qc == '"') + && (*tok->dptr == '{' || isalpha ((unsigned char) *tok->dptr))) { char *env = NULL, *var = NULL; - if (*tok->dptr == '{') - { - tok->dptr++; - if ((pc = strchr (tok->dptr, '}'))) - { - var = mutt_substrdup (tok->dptr, pc); - tok->dptr = pc + 1; - } + if (*tok->dptr == '{') { + tok->dptr++; + if ((pc = strchr (tok->dptr, '}'))) { + var = mutt_substrdup (tok->dptr, pc); + tok->dptr = pc + 1; + } } - else - { - for (pc = tok->dptr; isalpha ((unsigned char) *pc) || *pc == '_'; pc++) - ; - var = mutt_substrdup (tok->dptr, pc); - tok->dptr = pc; + else { + for (pc = tok->dptr; isalpha ((unsigned char) *pc) || *pc == '_'; + pc++); + var = mutt_substrdup (tok->dptr, pc); + tok->dptr = pc; } if (var && (env = getenv (var))) - mutt_buffer_addstr (dest, env); + mutt_buffer_addstr (dest, env); FREE (&var); } else mutt_buffer_addch (dest, ch); } - mutt_buffer_addch (dest, 0); /* terminate the string */ + mutt_buffer_addch (dest, 0); /* terminate the string */ SKIPWS (tok->dptr); return 0; } -static void add_to_list (LIST **list, const char *str) +static void add_to_list (LIST ** list, const char *str) { LIST *t, *last = NULL; @@ -296,10 +279,8 @@ static void add_to_list (LIST **list, const char *str) return; /* check to make sure the item is not already on this list */ - for (last = *list; last; last = last->next) - { - if (ascii_strcasecmp (str, last->data) == 0) - { + for (last = *list; last; last = last->next) { + if (ascii_strcasecmp (str, last->data) == 0) { /* already on the list, so just ignore it */ last = NULL; break; @@ -308,12 +289,10 @@ static void add_to_list (LIST **list, const char *str) break; } - if (!*list || last) - { + if (!*list || last) { t = (LIST *) safe_calloc (1, sizeof (LIST)); t->data = safe_strdup (str); - if (last) - { + if (last) { last->next = t; last = last->next; } @@ -322,120 +301,245 @@ static void add_to_list (LIST **list, const char *str) } } -static int add_to_rx_list (RX_LIST **list, const char *s, int flags, BUFFER *err) +static int add_to_rx_list (rx_t ** list, const char *s, int flags, + BUFFER * err) { - RX_LIST *t, *last = NULL; - REGEXP *rx; + rx_t* rx; + int i = 0; if (!s || !*s) return 0; - if (!(rx = mutt_compile_regexp (s, flags))) - { + if (!(rx = rx_compile (s, flags))) { snprintf (err->data, err->dsize, "Bad regexp: %s\n", s); return -1; } + i = rx_lookup ((*list), rx->pattern); + if (i >= 0) + rx_free (&rx); + else + list_push_back (list, rx); + return 0; +} + +static int add_to_spam_list (SPAM_LIST ** list, const char *pat, + const char *templ, BUFFER * err) +{ + SPAM_LIST *t = NULL, *last = NULL; + rx_t* rx; + int n; + const char *p; + + if (!pat || !*pat || !templ) + return 0; + + if (!(rx = rx_compile (pat, REG_ICASE))) { + snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat); + return -1; + } + /* check to make sure the item is not already on this list */ - for (last = *list; last; last = last->next) - { - if (ascii_strcasecmp (rx->pattern, last->rx->pattern) == 0) - { - /* already on the list, so just ignore it */ - last = NULL; + for (last = *list; last; last = last->next) { + if (ascii_strcasecmp (rx->pattern, last->rx->pattern) == 0) { + /* Already on the list. Formerly we just skipped this case, but + * now we're supporting removals, which means we're supporting + * re-adds conceptually. So we probably want this to imply a + * removal, then do an add. We can achieve the removal by freeing + * the template, and leaving t pointed at the current item. + */ + t = last; + FREE(t->template); break; } if (!last->next) break; } - if (!*list || last) - { - t = mutt_new_rx_list(); + /* If t is set, it's pointing into an extant SPAM_LIST* that we want to + * update. Otherwise we want to make a new one to link at the list's end. + */ + if (!t) { + t = mutt_new_spam_list (); t->rx = rx; if (last) - { last->next = t; - last = last->next; + else + *list = t; + } + + /* Now t is the SPAM_LIST* that we want to modify. It is prepared. */ + t->template = safe_strdup (templ); + + /* Find highest match number in template string */ + t->nmatch = 0; + for (p = templ; *p;) { + if (*p == '%') { + n = atoi (++p); + if (n > t->nmatch) + t->nmatch = n; + while (*p && isdigit ((int) *p)) + ++p; } else - *list = last = t; + ++p; } - else /* duplicate */ - mutt_free_regexp (&rx); + t->nmatch++; /* match 0 is always the whole expr */ return 0; } +static int remove_from_spam_list (SPAM_LIST ** list, const char *pat) +{ + SPAM_LIST *spam, *prev; + int nremoved = 0; + + /* Being first is a special case. */ + spam = *list; + if (spam->rx && !mutt_strcmp (spam->rx->pattern, pat)) { + *list = spam->next; + rx_free (&spam->rx); + FREE(&spam->template); + FREE(&spam); + return 1; + } + + prev = spam; + for (spam = prev->next; spam;) { + if (!mutt_strcmp (spam->rx->pattern, pat)) { + prev->next = spam->next; + rx_free (&spam->rx); + FREE(spam->template); + FREE(spam); + spam = prev->next; + ++nremoved; + } + else + spam = spam->next; + } + + return nremoved; +} + -static void remove_from_list (LIST **l, const char *str) +static void remove_from_list (LIST ** l, const char *str) { LIST *p, *last = NULL; if (mutt_strcmp ("*", str) == 0) - mutt_free_list (l); /* ``unCMD *'' means delete all current entries */ - else - { + mutt_free_list (l); /* ``unCMD *'' means delete all current entries */ + else { p = *l; last = NULL; - while (p) - { - if (ascii_strcasecmp (str, p->data) == 0) - { - FREE (&p->data); - if (last) - last->next = p->next; - else - (*l) = p->next; - FREE (&p); + while (p) { + if (ascii_strcasecmp (str, p->data) == 0) { + FREE (&p->data); + if (last) + last->next = p->next; + else + (*l) = p->next; + FREE (&p); } - else - { - last = p; - p = p->next; + else { + last = p; + p = p->next; } } } } -static void remove_from_rx_list (RX_LIST **l, const char *str) +static int remove_from_rx_list (list2_t** l, const char *str) { - RX_LIST *p, *last = NULL; + int i = 0; + + if (mutt_strcmp ("*", str) == 0) { + list_del (l, rx_free); + return (0); + } + else { + i = rx_lookup ((*l), str); + if (i >= 0) { + rx_t* r = list_pop_idx ((*l), i); + rx_free (&r); + return (0); + } + } + return (-1); +} - if (mutt_strcmp ("*", str) == 0) - mutt_free_rx_list (l); /* ``unCMD *'' means delete all current entries */ - else - { - p = *l; - last = NULL; - while (p) - { - if (ascii_strcasecmp (str, p->rx->pattern) == 0) - { - mutt_free_regexp (&p->rx); - if (last) - last->next = p->next; - else - (*l) = p->next; - FREE (&p); - } - else - { - last = p; - p = p->next; +static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data, + BUFFER * err) +{ + int i, j, res = 0; + BUFFER token; + + memset (&token, 0, sizeof (token)); + mutt_extract_token (tmp, s, 0); + + /* is the item defined as a variable or a function? */ + if (!(res = (mutt_option_index (tmp->data) != -1))) + for (i = 0; !res && i < MENU_MAX; i++) { + struct binding_t *b = km_get_table (Menus[i].value); + + if (!b) + continue; + + for (j = 0; b[j].name; j++) + if (!ascii_strncasecmp (tmp->data, b[j].name, mutt_strlen (tmp->data)) + && (mutt_strlen (b[j].name) == mutt_strlen (tmp->data))) { + res = 1; + break; + } + } + /* check for feature_* */ + if (!res) { + char *p = NULL; + + i = 0; + j = mutt_strlen (tmp->data); + /* need at least input of 'feature_X' */ + if (j >= 7) { + p = tmp->data + 7; + j -= 7; + while (Features[i].name) { + if (mutt_strlen (Features[i].name) == j && + ascii_strncasecmp (Features[i].name, p, j)) { + res = 1; + break; + } + i++; } } } + + if (!MoreArgs (s)) { + if (data) + snprintf (err->data, err->dsize, _("ifdef: too few arguments")); + else + snprintf (err->data, err->dsize, _("ifndef: too few arguments")); + return (-1); + } + mutt_extract_token (tmp, s, M_TOKEN_SPACE); + + if ((data && res) || (!data && !res)) { + if (mutt_parse_rc_line (tmp->data, &token, err) == -1) { + mutt_error ("Error: %s", err->data); + FREE (&token.data); + return (-1); + } + FREE (&token.data); + } + return 0; } -static int parse_unignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unignore (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); /* don't add "*" to the unignore list */ - if (strcmp (buf->data, "*")) + if (strcmp (buf->data, "*")) add_to_list (&UnIgnore, buf->data); remove_from_list (&Ignore, buf->data); @@ -445,10 +549,10 @@ static int parse_unignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *e return 0; } -static int parse_ignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_ignore (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_list (&UnIgnore, buf->data); add_to_list (&Ignore, buf->data); @@ -458,10 +562,10 @@ static int parse_ignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err return 0; } -static int parse_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_list (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); add_to_list ((LIST **) data, buf->data); } @@ -470,52 +574,127 @@ static int parse_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -static int _parse_rx_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err, int flags) +static void _alternates_clean (void) { - do - { + int i; + + if (Context && Context->msgcount) { + for (i = 0; i < Context->msgcount; i++) + Context->hdrs[i]->recip_valid = 0; + } +} + +static int parse_alternates (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) +{ + _alternates_clean (); + do { mutt_extract_token (buf, s, 0); - if (add_to_rx_list ((RX_LIST **) data, buf->data, flags, err) != 0) + remove_from_rx_list (&UnAlternates, buf->data); + + if (add_to_rx_list (&Alternates, buf->data, REG_ICASE, err) != 0) return -1; - } while (MoreArgs (s)); - + return 0; } -static int parse_rx_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unalternates (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - return _parse_rx_list (buf, s, data, err, REG_ICASE); + _alternates_clean (); + do { + mutt_extract_token (buf, s, 0); + remove_from_rx_list (&Alternates, buf->data); + + if (mutt_strcmp (buf->data, "*") && + add_to_rx_list (&UnAlternates, buf->data, REG_ICASE, err) != 0) + return -1; + + } + while (MoreArgs (s)); + + return 0; } -static int parse_rx_unlist (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { - mutt_extract_token (buf, s, 0); - if (mutt_strcmp (buf->data, "*") == 0) - { - mutt_free_rx_list ((RX_LIST **) data); - break; + BUFFER templ; + + memset (&templ, 0, sizeof (templ)); + + /* Insist on at least one parameter */ + if (!MoreArgs (s)) { + if (data == M_SPAM) + strfcpy (err->data, _("spam: no matching pattern"), err->dsize); + else + strfcpy (err->data, _("nospam: no matching pattern"), err->dsize); + return -1; + } + + /* Extract the first token, a regexp */ + mutt_extract_token (buf, s, 0); + + /* data should be either M_SPAM or M_NOSPAM. M_SPAM is for spam commands. */ + if (data == M_SPAM) { + /* If there's a second parameter, it's a template for the spam tag. */ + if (MoreArgs (s)) { + mutt_extract_token (&templ, s, 0); + + /* Add to the spam list. */ + if (add_to_spam_list (&SpamList, buf->data, templ.data, err) != 0) { + FREE (&templ.data); + return -1; + } + FREE (&templ.data); } - remove_from_rx_list ((RX_LIST **) data, buf->data); + + /* If not, try to remove from the nospam list. */ + else { + remove_from_rx_list (&NoSpamList, buf->data); + } + + return 0; } - while (MoreArgs (s)); - - return 0; + + /* M_NOSPAM is for nospam commands. */ + else if (data == M_NOSPAM) { + /* nospam only ever has one parameter. */ + + /* "*" is a special case. */ + if (!mutt_strcmp (buf->data, "*")) { + mutt_free_spam_list (&SpamList); + list_del (&NoSpamList, rx_free); + return 0; + } + + /* If it's on the spam list, just remove it. */ + if (remove_from_spam_list (&SpamList, buf->data) != 0) + return 0; + + /* Otherwise, add it to the nospam list. */ + if (add_to_rx_list (&NoSpamList, buf->data, REG_ICASE, err) != 0) + return -1; + + return 0; + } + + /* This should not happen. */ + strfcpy (err->data, "This is no good at all.", err->dsize); + return -1; } -static int parse_unlist (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); /* * Check for deletion of entire list */ - if (mutt_strcmp (buf->data, "*") == 0) - { + if (mutt_strcmp (buf->data, "*") == 0) { mutt_free_list ((LIST **) data); break; } @@ -526,25 +705,46 @@ static int parse_unlist (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err return 0; } +static int parse_lists (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) +{ + do { + mutt_extract_token (buf, s, 0); + remove_from_rx_list (&UnMailLists, buf->data); + + if (add_to_rx_list (&MailLists, buf->data, REG_ICASE, err) != 0) + return -1; + } + while (MoreArgs (s)); + + return 0; +} -static int parse_unlists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); - remove_from_rx_list (&MailLists, buf->data); remove_from_rx_list (&SubscribedLists, buf->data); + remove_from_rx_list (&MailLists, buf->data); + + if (mutt_strcmp (buf->data, "*") && + add_to_rx_list (&UnMailLists, buf->data, REG_ICASE, err) != 0) + return -1; } while (MoreArgs (s)); return 0; } -static int parse_subscribe (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); + remove_from_rx_list (&UnMailLists, buf->data); + remove_from_rx_list (&UnSubscribedLists, buf->data); + if (add_to_rx_list (&MailLists, buf->data, REG_ICASE, err) != 0) return -1; if (add_to_rx_list (&SubscribedLists, buf->data, REG_ICASE, err) != 0) @@ -554,78 +754,89 @@ static int parse_subscribe (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER * return 0; } - -static int parse_unalias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) + +static int parse_unsubscribe (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) +{ + do { + mutt_extract_token (buf, s, 0); + remove_from_rx_list (&SubscribedLists, buf->data); + + if (mutt_strcmp (buf->data, "*") && + add_to_rx_list (&UnSubscribedLists, buf->data, REG_ICASE, err) != 0) + return -1; + } + while (MoreArgs (s)); + + return 0; +} + +static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { ALIAS *tmp, *last = NULL; - do - { + do { mutt_extract_token (buf, s, 0); - if (mutt_strcmp ("*", buf->data) == 0) - { - if (CurrentMenu == MENU_ALIAS) - { - for (tmp = Aliases; tmp ; tmp = tmp->next) - tmp->del = 1; - set_option (OPTFORCEREDRAWINDEX); + if (mutt_strcmp ("*", buf->data) == 0) { + if (CurrentMenu == MENU_ALIAS) { + for (tmp = Aliases; tmp; tmp = tmp->next) + tmp->del = 1; + set_option (OPTFORCEREDRAWINDEX); } else - mutt_free_alias (&Aliases); + mutt_free_alias (&Aliases); break; } else - for (tmp = Aliases; tmp; tmp = tmp->next) - { - if (mutt_strcasecmp (buf->data, tmp->name) == 0) - { - if (CurrentMenu == MENU_ALIAS) - { - tmp->del = 1; - set_option (OPTFORCEREDRAWINDEX); - break; - } - - if (last) - last->next = tmp->next; - else - Aliases = tmp->next; - tmp->next = NULL; - mutt_free_alias (&tmp); - break; - } - last = tmp; + for (tmp = Aliases; tmp; tmp = tmp->next) { + if (mutt_strcasecmp (buf->data, tmp->name) == 0) { + if (CurrentMenu == MENU_ALIAS) { + tmp->del = 1; + set_option (OPTFORCEREDRAWINDEX); + break; + } + + if (last) + last->next = tmp->next; + else + Aliases = tmp->next; + tmp->next = NULL; + mutt_free_alias (&tmp); + break; + } + last = tmp; } } while (MoreArgs (s)); return 0; } -static int parse_alias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { ALIAS *tmp = Aliases; ALIAS *last = NULL; char *estr = NULL; - - if (!MoreArgs (s)) - { + + if (!MoreArgs (s)) { strfcpy (err->data, _("alias: no address"), err->dsize); return (-1); } mutt_extract_token (buf, s, 0); + dprint (2, (debugfile, "parse_alias: First token is '%s'.\n", buf->data)); + /* check to see if an alias with this name already exists */ - for (; tmp; tmp = tmp->next) - { + for (; tmp; tmp = tmp->next) { if (!mutt_strcasecmp (tmp->name, buf->data)) break; last = tmp; } - if (!tmp) - { + if (!tmp) { /* create a new alias */ tmp = (ALIAS *) safe_calloc (1, sizeof (ALIAS)); tmp->self = tmp; @@ -634,69 +845,77 @@ static int parse_alias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) if (CurrentMenu == MENU_ALIAS) set_option (OPTMENUCALLER); } - else - { + else { /* override the previous value */ rfc822_free_address (&tmp->addr); if (CurrentMenu == MENU_ALIAS) set_option (OPTFORCEREDRAWINDEX); } - mutt_extract_token (buf, s, M_TOKEN_QUOTE | M_TOKEN_SPACE | M_TOKEN_SEMICOLON); + mutt_extract_token (buf, s, + M_TOKEN_QUOTE | M_TOKEN_SPACE | M_TOKEN_SEMICOLON); + dprint (2, (debugfile, "parse_alias: Second token is '%s'.\n", buf->data)); tmp->addr = mutt_parse_adrlist (tmp->addr, buf->data); if (last) last->next = tmp; else Aliases = tmp; - if (mutt_addrlist_to_idna (tmp->addr, &estr)) - { - snprintf (err->data, err->dsize, _("Warning: Bad IDN '%s' in alias '%s'.\n"), - estr, tmp->name); + if (mutt_addrlist_to_idna (tmp->addr, &estr)) { + snprintf (err->data, err->dsize, + _("Warning: Bad IDN '%s' in alias '%s'.\n"), estr, tmp->name); return -1; } +#ifdef DEBUG + if (debuglevel >= 2) { + ADDRESS *a; + + for (a = tmp->addr; a; a = a->next) { + if (!a->group) + dprint (2, (debugfile, "parse_alias: %s\n", a->mailbox)); + else + dprint (2, (debugfile, "parse_alias: Group %s\n", a->mailbox)); + } + } +#endif return 0; } static int -parse_unmy_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +parse_unmy_hdr (BUFFER * buf, BUFFER * s, unsigned long data, BUFFER * err) { LIST *last = NULL; LIST *tmp = UserHeader; LIST *ptr; size_t l; - do - { + do { mutt_extract_token (buf, s, 0); if (mutt_strcmp ("*", buf->data) == 0) mutt_free_list (&UserHeader); - else - { + else { tmp = UserHeader; last = NULL; l = mutt_strlen (buf->data); if (buf->data[l - 1] == ':') - l--; - - while (tmp) - { - if (ascii_strncasecmp (buf->data, tmp->data, l) == 0 && tmp->data[l] == ':') - { - ptr = tmp; - if (last) - last->next = tmp->next; - else - UserHeader = tmp->next; - tmp = tmp->next; - ptr->next = NULL; - mutt_free_list (&ptr); - } - else - { - last = tmp; - tmp = tmp->next; - } + l--; + + while (tmp) { + if (ascii_strncasecmp (buf->data, tmp->data, l) == 0 + && tmp->data[l] == ':') { + ptr = tmp; + if (last) + last->next = tmp->next; + else + UserHeader = tmp->next; + tmp = tmp->next; + ptr->next = NULL; + mutt_free_list (&ptr); + } + else { + last = tmp; + tmp = tmp->next; + } } } } @@ -704,41 +923,37 @@ parse_unmy_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -static int parse_my_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { LIST *tmp; size_t keylen; char *p; mutt_extract_token (buf, s, M_TOKEN_SPACE | M_TOKEN_QUOTE); - if ((p = strpbrk (buf->data, ": \t")) == NULL || *p != ':') - { + if ((p = strpbrk (buf->data, ": \t")) == NULL || *p != ':') { strfcpy (err->data, _("invalid header field"), err->dsize); return (-1); } keylen = p - buf->data + 1; - if (UserHeader) - { - for (tmp = UserHeader; ; tmp = tmp->next) - { + if (UserHeader) { + for (tmp = UserHeader;; tmp = tmp->next) { /* see if there is already a field by this name */ - if (ascii_strncasecmp (buf->data, tmp->data, keylen) == 0) - { - /* replace the old value */ - FREE (&tmp->data); - tmp->data = buf->data; - memset (buf, 0, sizeof (BUFFER)); - return 0; + if (ascii_strncasecmp (buf->data, tmp->data, keylen) == 0) { + /* replace the old value */ + FREE (&tmp->data); + tmp->data = buf->data; + memset (buf, 0, sizeof (BUFFER)); + return 0; } if (!tmp->next) - break; + break; } tmp->next = mutt_new_list (); tmp = tmp->next; } - else - { + else { tmp = mutt_new_list (); UserHeader = tmp; } @@ -748,24 +963,22 @@ static int parse_my_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err } static int -parse_sort (short *val, const char *s, const struct mapping_t *map, BUFFER *err) +parse_sort (short *val, const char *s, const struct mapping_t *map, + BUFFER * err) { int i, flags = 0; - if (mutt_strncmp ("reverse-", s, 8) == 0) - { + if (mutt_strncmp ("reverse-", s, 8) == 0) { s += 8; flags = SORT_REVERSE; } - - if (mutt_strncmp ("last-", s, 5) == 0) - { + + if (mutt_strncmp ("last-", s, 5) == 0) { s += 5; flags |= SORT_LAST; } - if ((i = mutt_getvaluebyname (s, map)) == -1) - { + if ((i = mutt_getvaluebyname (s, map)) == -1) { snprintf (err->data, err->dsize, _("%s: unknown sorting method"), s); return (-1); } @@ -777,34 +990,34 @@ parse_sort (short *val, const char *s, const struct mapping_t *map, BUFFER *err) static void mutt_set_default (struct option_t *p) { - switch (p->type & DT_MASK) - { - case DT_STR: - if (!p->init && *((char **) p->data)) - p->init = (unsigned long) safe_strdup (* ((char **) p->data)); - break; - case DT_PATH: - if (!p->init && *((char **) p->data)) - { - char *cp = safe_strdup (*((char **) p->data)); - /* mutt_pretty_mailbox (cp); */ - p->init = (unsigned long) cp; - } - break; - case DT_ADDR: - if (!p->init && *((ADDRESS **) p->data)) - { - char tmp[HUGE_STRING]; - *tmp = '\0'; - rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) p->data), 0); - p->init = (unsigned long) safe_strdup (tmp); - } - break; - case DT_RX: + switch (p->type & DT_MASK) { + case DT_STR: + if (!p->init && *((char **) p->data)) + p->init = (unsigned long) safe_strdup (*((char **) p->data)); + break; + case DT_PATH: + if (!p->init && *((char **) p->data)) { + char *cp = safe_strdup (*((char **) p->data)); + + /* mutt_pretty_mailbox (cp); */ + p->init = (unsigned long) cp; + } + break; + case DT_ADDR: + if (!p->init && *((ADDRESS **) p->data)) { + char tmp[HUGE_STRING]; + + *tmp = '\0'; + rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) p->data), 0); + p->init = (unsigned long) safe_strdup (tmp); + } + break; + case DT_RX: { - REGEXP *pp = (REGEXP *) p->data; + rx_t* pp = (rx_t*) p->data; + if (!p->init && pp->pattern) - p->init = (unsigned long) safe_strdup (pp->pattern); + p->init = (unsigned long) safe_strdup (pp->pattern); break; } } @@ -812,81 +1025,74 @@ static void mutt_set_default (struct option_t *p) static void mutt_restore_default (struct option_t *p) { - switch (p->type & DT_MASK) - { - case DT_STR: - if (p->init) - mutt_str_replace ((char **) p->data, (char *) p->init); - break; - case DT_PATH: - if (p->init) - { - char path[_POSIX_PATH_MAX]; - - strfcpy (path, (char *) p->init, sizeof (path)); - mutt_expand_path (path, sizeof (path)); - mutt_str_replace ((char **) p->data, path); - } - break; - case DT_ADDR: - if (p->init) - { - rfc822_free_address ((ADDRESS **) p->data); - *((ADDRESS **) p->data) = rfc822_parse_adrlist (NULL, (char *) p->init); + switch (p->type & DT_MASK) { + case DT_STR: + if (p->init) + mutt_str_replace ((char **) p->data, (char *) p->init); + break; + case DT_PATH: + if (p->init) { + char path[_POSIX_PATH_MAX]; + + strfcpy (path, (char *) p->init, sizeof (path)); + mutt_expand_path (path, sizeof (path)); + mutt_str_replace ((char **) p->data, path); + } + break; + case DT_ADDR: + if (p->init) { + rfc822_free_address ((ADDRESS **) p->data); + *((ADDRESS **) p->data) = rfc822_parse_adrlist (NULL, (char *) p->init); + } + break; + case DT_BOOL: + if (p->init) + set_option (p->data); + else + unset_option (p->data); + break; + case DT_QUAD: + set_quadoption (p->data, p->init); + break; + case DT_NUM: + case DT_SORT: + case DT_MAGIC: + *((short *) p->data) = p->init; + break; + case DT_RX: + { + rx_t *pp = (rx_t *) p->data; + int flags = 0; + + FREE (&pp->pattern); + if (pp->rx) { + regfree (pp->rx); + FREE (&pp->rx); } - break; - case DT_BOOL: - if (p->init) - set_option (p->data); - else - unset_option (p->data); - break; - case DT_QUAD: - set_quadoption (p->data, p->init); - break; - case DT_NUM: - case DT_SORT: - case DT_MAGIC: - *((short *) p->data) = p->init; - break; - case DT_RX: - { - REGEXP *pp = (REGEXP *) p->data; - int flags = 0; - - FREE (&pp->pattern); - if (pp->rx) - { - regfree (pp->rx); - FREE (&pp->rx); - } - - if (p->init) - { - char *s = (char *) p->init; - - pp->rx = safe_calloc (1, sizeof (regex_t)); - pp->pattern = safe_strdup ((char *) p->init); - if (mutt_strcmp (p->option, "alternates") == 0) - flags |= REG_ICASE; - else if (mutt_strcmp (p->option, "mask") != 0) - flags |= mutt_which_case ((const char *) p->init); - if (mutt_strcmp (p->option, "mask") == 0 && *s == '!') - { - s++; - pp->not = 1; - } - if (REGCOMP (pp->rx, s, flags) != 0) - { - fprintf (stderr, _("mutt_restore_default(%s): error in regexp: %s\n"), - p->option, pp->pattern); - FREE (&pp->pattern); - regfree (pp->rx); - FREE (&pp->rx); - } - } + + if (p->init) { + char *s = (char *) p->init; + + pp->rx = safe_calloc (1, sizeof (regex_t)); + if (mutt_strcmp (p->option, "mask") != 0) + flags |= mutt_which_case ((const char *) p->init); + if (mutt_strcmp (p->option, "mask") == 0 && *s == '!') { + s++; + pp->not = 1; + } + if (REGCOMP (pp->rx, s, flags) != 0) { + fprintf (stderr, + _("mutt_restore_default(%s): error in regexp: %s\n"), + p->option, pp->pattern); + FREE (&pp->pattern); + regfree (pp->rx); + FREE (&pp->rx); + } + else + mutt_str_replace (&pp->pattern, (char *) p->init); } - break; + } + break; } if (p->flags & R_INDEX) @@ -903,36 +1109,32 @@ static void mutt_restore_default (struct option_t *p) set_option (OPTREDRAWTREE); } -static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data, + BUFFER * err) { int idx, query, unset, inv, reset, r = 0; char *p, scratch[_POSIX_PATH_MAX]; - while (MoreArgs (s)) - { + while (MoreArgs (s)) { /* reset state variables */ query = 0; unset = data & M_SET_UNSET; inv = data & M_SET_INV; reset = data & M_SET_RESET; - if (*s->dptr == '?') - { + if (*s->dptr == '?') { query = 1; s->dptr++; } - else if (mutt_strncmp ("no", s->dptr, 2) == 0) - { + else if (mutt_strncmp ("no", s->dptr, 2) == 0) { s->dptr += 2; unset = !unset; } - else if (mutt_strncmp ("inv", s->dptr, 3) == 0) - { + else if (mutt_strncmp ("inv", s->dptr, 3) == 0) { s->dptr += 3; inv = !inv; } - else if (*s->dptr == '&') - { + else if (*s->dptr == '&') { reset = 1; s->dptr++; } @@ -941,281 +1143,238 @@ static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) mutt_extract_token (tmp, s, M_TOKEN_EQUAL); if ((idx = mutt_option_index (tmp->data)) == -1 && - !(reset && !mutt_strcmp ("all", tmp->data))) - { + !(reset && !mutt_strcmp ("all", tmp->data))) { snprintf (err->data, err->dsize, _("%s: unknown variable"), tmp->data); return (-1); } SKIPWS (s->dptr); - if (reset) - { - if (query || unset || inv) - { - snprintf (err->data, err->dsize, _("prefix is illegal with reset")); - return (-1); + if (reset) { + if (query || unset || inv) { + snprintf (err->data, err->dsize, _("prefix is illegal with reset")); + return (-1); } - if (s && *s->dptr == '=') - { - snprintf (err->data, err->dsize, _("value is illegal with reset")); - return (-1); + if (s && *s->dptr == '=') { + snprintf (err->data, err->dsize, _("value is illegal with reset")); + return (-1); } - - if (!mutt_strcmp ("all", tmp->data)) - { - for (idx = 0; MuttVars[idx].option; idx++) - mutt_restore_default (&MuttVars[idx]); - return 0; + + if (!mutt_strcmp ("all", tmp->data)) { + for (idx = 0; MuttVars[idx].option; idx++) + mutt_restore_default (&MuttVars[idx]); + return 0; } else - mutt_restore_default (&MuttVars[idx]); - } - else if (DTYPE (MuttVars[idx].type) == DT_BOOL) - { - if (s && *s->dptr == '=') - { - if (unset || inv || query) - { - snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); - return (-1); - } - - s->dptr++; - mutt_extract_token (tmp, s, 0); - if (ascii_strcasecmp ("yes", tmp->data) == 0) - unset = inv = 0; - else if (ascii_strcasecmp ("no", tmp->data) == 0) - unset = 1; - else - { - snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); - return (-1); - } + mutt_restore_default (&MuttVars[idx]); + } + else if (DTYPE (MuttVars[idx].type) == DT_BOOL) { + if (s && *s->dptr == '=') { + if (unset || inv || query) { + snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); + return (-1); + } + + s->dptr++; + mutt_extract_token (tmp, s, 0); + if (ascii_strcasecmp ("yes", tmp->data) == 0) + unset = inv = 0; + else if (ascii_strcasecmp ("no", tmp->data) == 0) + unset = 1; + else { + snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); + return (-1); + } } - if (query) - { - snprintf (err->data, err->dsize, option (MuttVars[idx].data) - ? _("%s is set") : _("%s is unset"), tmp->data); - return 0; + if (query) { + snprintf (err->data, err->dsize, option (MuttVars[idx].data) + ? _("%s is set") : _("%s is unset"), tmp->data); + return 0; } if (unset) - unset_option (MuttVars[idx].data); + unset_option (MuttVars[idx].data); else if (inv) - toggle_option (MuttVars[idx].data); + toggle_option (MuttVars[idx].data); else - set_option (MuttVars[idx].data); + set_option (MuttVars[idx].data); } else if (DTYPE (MuttVars[idx].type) == DT_STR || - DTYPE (MuttVars[idx].type) == DT_PATH || - DTYPE (MuttVars[idx].type) == DT_ADDR) - { - if (unset) - { - if (DTYPE (MuttVars[idx].type) == DT_ADDR) - rfc822_free_address ((ADDRESS **) MuttVars[idx].data); - else - FREE (MuttVars[idx].data); + DTYPE (MuttVars[idx].type) == DT_PATH || + DTYPE (MuttVars[idx].type) == DT_ADDR) { + if (unset) { + if (DTYPE (MuttVars[idx].type) == DT_ADDR) + rfc822_free_address ((ADDRESS **) MuttVars[idx].data); + else + FREE ((void *) MuttVars[idx].data); } - else if (query || *s->dptr != '=') - { - char _tmp[STRING]; - char *val = NULL; - - if (DTYPE (MuttVars[idx].type) == DT_ADDR) - { - _tmp[0] = '\0'; - rfc822_write_address (_tmp, sizeof (_tmp), *((ADDRESS **) MuttVars[idx].data), 0); - val = _tmp; - } - else - val = *((char **) MuttVars[idx].data); - - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, - NONULL (val)); - break; + else if (query || *s->dptr != '=') { + char _tmp[STRING]; + char *val = NULL; + + if (DTYPE (MuttVars[idx].type) == DT_ADDR) { + _tmp[0] = '\0'; + rfc822_write_address (_tmp, sizeof (_tmp), + *((ADDRESS **) MuttVars[idx].data), 0); + val = _tmp; + } + else + val = *((char **) MuttVars[idx].data); + + /* user requested the value of this variable */ + snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, + NONULL (val)); + break; } - else - { + else { s->dptr++; /* copy the value of the string */ if (DTYPE (MuttVars[idx].type) == DT_ADDR) - rfc822_free_address ((ADDRESS **) MuttVars[idx].data); + rfc822_free_address ((ADDRESS **) MuttVars[idx].data); else - FREE (MuttVars[idx].data); + FREE ((void *) MuttVars[idx].data); mutt_extract_token (tmp, s, 0); - if (DTYPE (MuttVars[idx].type) == DT_PATH) - { - strfcpy (scratch, tmp->data, sizeof (scratch)); - mutt_expand_path (scratch, sizeof (scratch)); - *((char **) MuttVars[idx].data) = safe_strdup (scratch); + if (DTYPE (MuttVars[idx].type) == DT_PATH) { + strfcpy (scratch, tmp->data, sizeof (scratch)); + mutt_expand_path (scratch, sizeof (scratch)); + *((char **) MuttVars[idx].data) = safe_strdup (scratch); } - else if (DTYPE (MuttVars[idx].type) == DT_STR) - { - *((char **) MuttVars[idx].data) = safe_strdup (tmp->data); - if (mutt_strcmp (MuttVars[idx].option, "charset") == 0) - mutt_set_charset (Charset); + else if (DTYPE (MuttVars[idx].type) == DT_STR) { + *((char **) MuttVars[idx].data) = safe_strdup (tmp->data); + if (mutt_strcmp (MuttVars[idx].option, "charset") == 0) + mutt_set_charset (Charset); } - else - { - *((ADDRESS **) MuttVars[idx].data) = rfc822_parse_adrlist (NULL, tmp->data); + else { + *((ADDRESS **) MuttVars[idx].data) = + rfc822_parse_adrlist (NULL, tmp->data); } } } - else if (DTYPE(MuttVars[idx].type) == DT_RX) - { - REGEXP *ptr = (REGEXP *) MuttVars[idx].data; + else if (DTYPE (MuttVars[idx].type) == DT_RX) { + rx_t *ptr = (rx_t *) MuttVars[idx].data; regex_t *rx; int e, flags = 0; - if (query || *s->dptr != '=') - { - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, - NONULL (ptr->pattern)); - break; + if (query || *s->dptr != '=') { + /* user requested the value of this variable */ + snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, + NONULL (ptr->pattern)); + break; } - if (option(OPTATTACHMSG) && (!mutt_strcmp(MuttVars[idx].option, "alternates") - || !mutt_strcmp(MuttVars[idx].option, "reply_regexp"))) - { - snprintf (err->data, err->dsize, "Operation not permitted when in attach-message mode."); - r = -1; - break; + if (option (OPTATTACHMSG) + && !mutt_strcmp (MuttVars[idx].option, "reply_regexp")) { + snprintf (err->data, err->dsize, + "Operation not permitted when in attach-message mode."); + r = -1; + break; } - + s->dptr++; /* copy the value of the string */ mutt_extract_token (tmp, s, 0); - if (!ptr->pattern || mutt_strcmp (ptr->pattern, tmp->data) != 0) - { - int not = 0; - - /* $alternates is case-insensitive, - $mask is case-sensitive */ - if (mutt_strcmp (MuttVars[idx].option, "alternates") == 0) - flags |= REG_ICASE; - else if (mutt_strcmp (MuttVars[idx].option, "mask") != 0) - flags |= mutt_which_case (tmp->data); - - p = tmp->data; - if (mutt_strcmp (MuttVars[idx].option, "mask") == 0) - { - if (*p == '!') - { - not = 1; - p++; - } - } - - rx = (regex_t *) safe_malloc (sizeof (regex_t)); - if ((e = REGCOMP (rx, p, flags)) != 0) - { - regerror (e, rx, err->data, err->dsize); - regfree (rx); - FREE (&rx); - break; - } - - /* get here only if everything went smootly */ - if (ptr->pattern) - { - FREE (&ptr->pattern); - regfree ((regex_t *) ptr->rx); - FREE (&ptr->rx); - } - - ptr->pattern = safe_strdup (tmp->data); - ptr->rx = rx; - ptr->not = not; - - /* $reply_regexp and $alterantes require special treatment */ - - if (Context && Context->msgcount && - mutt_strcmp (MuttVars[idx].option, "reply_regexp") == 0) - { - regmatch_t pmatch[1]; - int i; - + if (!ptr->pattern || mutt_strcmp (ptr->pattern, tmp->data) != 0) { + int not = 0; + + /* $mask is case-sensitive */ + if (mutt_strcmp (MuttVars[idx].option, "mask") != 0) + flags |= mutt_which_case (tmp->data); + + p = tmp->data; + if (mutt_strcmp (MuttVars[idx].option, "mask") == 0) { + if (*p == '!') { + not = 1; + p++; + } + } + + rx = (regex_t *) safe_malloc (sizeof (regex_t)); + if ((e = REGCOMP (rx, p, flags)) != 0) { + regerror (e, rx, err->data, err->dsize); + regfree (rx); + FREE (&rx); + break; + } + + /* get here only if everything went smootly */ + if (ptr->pattern) { + FREE (&ptr->pattern); + regfree ((regex_t *) ptr->rx); + FREE (&ptr->rx); + } + + ptr->pattern = safe_strdup (tmp->data); + ptr->rx = rx; + ptr->not = not; + + /* $reply_regexp and $alterantes require special treatment */ + + if (Context && Context->msgcount && + mutt_strcmp (MuttVars[idx].option, "reply_regexp") == 0) { + regmatch_t pmatch[1]; + int i; + #define CUR_ENV Context->hdrs[i]->env - for (i = 0; i < Context->msgcount; i++) - { - if (CUR_ENV && CUR_ENV->subject) - { - CUR_ENV->real_subj = (regexec (ReplyRegexp.rx, - CUR_ENV->subject, 1, pmatch, 0)) ? - CUR_ENV->subject : - CUR_ENV->subject + pmatch[0].rm_eo; - } - } + for (i = 0; i < Context->msgcount; i++) { + if (CUR_ENV && CUR_ENV->subject) { + CUR_ENV->real_subj = (regexec (ReplyRegexp.rx, + CUR_ENV->subject, 1, pmatch, + 0)) ? CUR_ENV-> + subject : CUR_ENV->subject + pmatch[0].rm_eo; + } + } #undef CUR_ENV - } - - if(Context && Context->msgcount && - mutt_strcmp(MuttVars[idx].option, "alternates") == 0) - { - int i; - - for(i = 0; i < Context->msgcount; i++) - Context->hdrs[i]->recip_valid = 0; - } + } } } - else if (DTYPE(MuttVars[idx].type) == DT_MAGIC) - { - if (query || *s->dptr != '=') - { - switch (DefaultMagic) - { - case M_MBOX: - p = "mbox"; - break; - case M_MMDF: - p = "MMDF"; - break; - case M_MH: - p = "MH"; - break; - case M_MAILDIR: - p = "Maildir"; - break; - default: - p = "unknown"; - break; - } - snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, p); - break; + else if (DTYPE (MuttVars[idx].type) == DT_MAGIC) { + if (query || *s->dptr != '=') { + switch (DefaultMagic) { + case M_MBOX: + p = "mbox"; + break; + case M_MMDF: + p = "MMDF"; + break; + case M_MH: + p = "MH"; + break; + case M_MAILDIR: + p = "Maildir"; + break; + default: + p = "unknown"; + break; + } + snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, p); + break; } s->dptr++; /* copy the value of the string */ mutt_extract_token (tmp, s, 0); - if (mx_set_magic (tmp->data)) - { - snprintf (err->data, err->dsize, _("%s: invalid mailbox type"), tmp->data); - r = -1; - break; + if (mx_set_magic (tmp->data)) { + snprintf (err->data, err->dsize, _("%s: invalid mailbox type"), + tmp->data); + r = -1; + break; } } - else if (DTYPE(MuttVars[idx].type) == DT_NUM) - { + else if (DTYPE (MuttVars[idx].type) == DT_NUM) { short *ptr = (short *) MuttVars[idx].data; int val; char *t; - if (query || *s->dptr != '=') - { - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=%d", MuttVars[idx].option, *ptr); - break; + if (query || *s->dptr != '=') { + /* user requested the value of this variable */ + snprintf (err->data, err->dsize, "%s=%d", MuttVars[idx].option, *ptr); + break; } s->dptr++; @@ -1223,121 +1382,113 @@ static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) mutt_extract_token (tmp, s, 0); val = strtol (tmp->data, &t, 0); - if (!*tmp->data || *t || (short) val != val) - { - snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); - r = -1; - break; + if (!*tmp->data || *t || (short) val != val) { + snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); + r = -1; + break; } else - *ptr = (short) val; + *ptr = (short) val; /* these ones need a sanity check */ - if (mutt_strcmp (MuttVars[idx].option, "history") == 0) - { - if (*ptr < 0) - *ptr = 0; - mutt_init_history (); + if (mutt_strcmp (MuttVars[idx].option, "history") == 0) { + if (*ptr < 0) + *ptr = 0; + mutt_init_history (); } - else if (mutt_strcmp (MuttVars[idx].option, "pager_index_lines") == 0) - { - if (*ptr < 0) - *ptr = 0; + else if (mutt_strcmp (MuttVars[idx].option, "pager_index_lines") == 0) { + if (*ptr < 0) + *ptr = 0; } } - else if (DTYPE (MuttVars[idx].type) == DT_QUAD) - { - if (query) - { - char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; + else if (DTYPE (MuttVars[idx].type) == DT_QUAD) { + if (query) { + char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; - snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, - vals [ quadoption (MuttVars[idx].data) ]); - break; + snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, + vals[quadoption (MuttVars[idx].data)]); + break; } - if (*s->dptr == '=') - { - s->dptr++; - mutt_extract_token (tmp, s, 0); - if (ascii_strcasecmp ("yes", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_YES); - else if (ascii_strcasecmp ("no", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_NO); - else if (ascii_strcasecmp ("ask-yes", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_ASKYES); - else if (ascii_strcasecmp ("ask-no", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_ASKNO); - else - { - snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); - r = -1; - break; - } + if (*s->dptr == '=') { + s->dptr++; + mutt_extract_token (tmp, s, 0); + if (ascii_strcasecmp ("yes", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_YES); + else if (ascii_strcasecmp ("no", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_NO); + else if (ascii_strcasecmp ("ask-yes", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_ASKYES); + else if (ascii_strcasecmp ("ask-no", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_ASKNO); + else { + snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); + r = -1; + break; + } } - else - { - if (inv) - toggle_quadoption (MuttVars[idx].data); - else if (unset) - set_quadoption (MuttVars[idx].data, M_NO); - else - set_quadoption (MuttVars[idx].data, M_YES); + else { + if (inv) + toggle_quadoption (MuttVars[idx].data); + else if (unset) + set_quadoption (MuttVars[idx].data, M_NO); + else + set_quadoption (MuttVars[idx].data, M_YES); } } - else if (DTYPE (MuttVars[idx].type) == DT_SORT) - { + else if (DTYPE (MuttVars[idx].type) == DT_SORT) { const struct mapping_t *map = NULL; - switch (MuttVars[idx].type & DT_SUBTYPE_MASK) - { - case DT_SORT_ALIAS: - map = SortAliasMethods; - break; - case DT_SORT_BROWSER: - map = SortBrowserMethods; - break; - case DT_SORT_KEYS: - if ((WithCrypto & APPLICATION_PGP)) - map = SortKeyMethods; - break; - case DT_SORT_AUX: - map = SortAuxMethods; - break; - default: - map = SortMethods; - break; + switch (MuttVars[idx].type & DT_SUBTYPE_MASK) { + case DT_SORT_ALIAS: + map = SortAliasMethods; + break; + case DT_SORT_BROWSER: + map = SortBrowserMethods; + break; + case DT_SORT_KEYS: + if ((WithCrypto & APPLICATION_PGP)) + map = SortKeyMethods; + break; + case DT_SORT_AUX: + map = SortAuxMethods; + break; + default: + map = SortMethods; + break; } - if (!map) - { - snprintf (err->data, err->dsize, _("%s: Unknown type."), MuttVars[idx].option); - r = -1; - break; + if (!map) { + snprintf (err->data, err->dsize, _("%s: Unknown type."), + MuttVars[idx].option); + r = -1; + break; } - - if (query || *s->dptr != '=') - { - p = mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, map); - - snprintf (err->data, err->dsize, "%s=%s%s%s", MuttVars[idx].option, - (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? "reverse-" : "", - (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : "", - p); - return 0; + + if (query || *s->dptr != '=') { + p = + mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, + map); + + snprintf (err->data, err->dsize, "%s=%s%s%s", MuttVars[idx].option, + (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? + "reverse-" : "", + (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : + "", p); + return 0; } s->dptr++; - mutt_extract_token (tmp, s , 0); + mutt_extract_token (tmp, s, 0); - if (parse_sort ((short *) MuttVars[idx].data, tmp->data, map, err) == -1) - { - r = -1; - break; + if (parse_sort ((short *) MuttVars[idx].data, tmp->data, map, err) == + -1) { + r = -1; + break; } } - else - { - snprintf (err->data, err->dsize, _("%s: unknown type"), MuttVars[idx].option); + else { + snprintf (err->data, err->dsize, _("%s: unknown type"), + MuttVars[idx].option); r = -1; break; } @@ -1362,56 +1513,61 @@ static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) /* reads the specified initialization file. returns -1 if errors were found so that we can pause to let the user know... */ -static int source_rc (const char *rcfile, BUFFER *err) +static int source_rc (const char *rcfile, BUFFER * err) { FILE *f; - int line = 0, rc = 0; + int line = 0, rc = 0, conv = 0; BUFFER token; char *linebuf = NULL; + char *currentline = NULL; size_t buflen; pid_t pid; - struct stat s; - if (stat (rcfile, &s) < 0) - { - snprintf (err->data, err->dsize, _("%s: stat: %s"), rcfile, strerror (errno)); - return (-1); - } - if (!S_ISREG (s.st_mode)) - { - snprintf (err->data, err->dsize, _("%s: not a regular file"), rcfile); - return (-1); - } + dprint (2, (debugfile, "Reading configuration file '%s'.\n", rcfile)); - if ((f = mutt_open_read (rcfile, &pid)) == NULL) - { + if ((f = mutt_open_read (rcfile, &pid)) == NULL) { snprintf (err->data, err->dsize, "%s: %s", rcfile, strerror (errno)); return (-1); } memset (&token, 0, sizeof (token)); - while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) - { - if (mutt_parse_rc_line (linebuf, &token, err) == -1) - { + while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) { + conv = ConfigCharset && (*ConfigCharset) && Charset; + if (conv) { + currentline = safe_strdup (linebuf); + if (!currentline) + continue; + mutt_convert_string (¤tline, ConfigCharset, Charset, 0); + } + else + currentline = linebuf; + + if (mutt_parse_rc_line (currentline, &token, err) == -1) { mutt_error (_("Error in %s, line %d: %s"), rcfile, line, err->data); - if (--rc < -MAXERRS) + if (--rc < -MAXERRS) { + if (conv) + FREE (¤tline); break; + } } - else + else { if (rc < 0) rc = -1; + } + if (conv) + FREE (¤tline); } FREE (&token.data); FREE (&linebuf); fclose (f); if (pid != -1) mutt_wait_filter (pid); - if (rc) - { + if (rc) { /* the muttrc source keyword */ - snprintf (err->data, err->dsize, rc >= -MAXERRS ? _("source: errors in %s") - : _("source: reading aborted due too many errors in %s"), rcfile); + snprintf (err->data, err->dsize, + rc >= -MAXERRS ? _("source: errors in %s") + : _("source: reading aborted due too many errors in %s"), + rcfile); rc = -1; } return (rc); @@ -1419,15 +1575,14 @@ static int source_rc (const char *rcfile, BUFFER *err) #undef MAXERRS -static int parse_source (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_source (BUFFER * tmp, BUFFER * s, unsigned long data, + BUFFER * err) { char path[_POSIX_PATH_MAX]; int rc = 0; - do - { - if (mutt_extract_token (tmp, s, 0) != 0) - { + do { + if (mutt_extract_token (tmp, s, 0) != 0) { snprintf (err->data, err->dsize, _("source: error at %s"), s->dptr); return (-1); } @@ -1452,7 +1607,7 @@ static int parse_source (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err every call to this function. err where to write error messages */ -int mutt_parse_rc_line (/* const */ char *line, BUFFER *token, BUFFER *err) +int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err) { int i, r = -1; BUFFER expn; @@ -1464,28 +1619,24 @@ int mutt_parse_rc_line (/* const */ char *line, BUFFER *token, BUFFER *err) *err->data = 0; SKIPWS (expn.dptr); - while (*expn.dptr) - { + while (*expn.dptr) { if (*expn.dptr == '#') - break; /* rest of line is a comment */ - if (*expn.dptr == ';') - { + break; /* rest of line is a comment */ + if (*expn.dptr == ';') { expn.dptr++; continue; } mutt_extract_token (token, &expn, 0); - for (i = 0; Commands[i].name; i++) - { - if (!mutt_strcmp (token->data, Commands[i].name)) - { - if (Commands[i].func (token, &expn, Commands[i].data, err) != 0) - goto finish; + for (i = 0; Commands[i].name; i++) { + if (!mutt_strcmp (token->data, Commands[i].name)) { + if (Commands[i].func (token, &expn, Commands[i].data, err) != 0) + goto finish; break; } } - if (!Commands[i].name) - { - snprintf (err->data, err->dsize, _("%s: unknown command"), NONULL (token->data)); + if (!Commands[i].name) { + snprintf (err->data, err->dsize, _("%s: unknown command"), + NONULL (token->data)); goto finish; } } @@ -1501,11 +1652,11 @@ finish: #define NUMCOMMANDS (sizeof (Commands)/sizeof (Commands[0])) /* initial string that starts completion. No telling how much crap * the user has typed so far. Allocate LONG_STRING just to be sure! */ -char User_typed [LONG_STRING] = {0}; +char User_typed[LONG_STRING] = { 0 }; -int Num_matched = 0; /* Number of matches for completion */ -char Completed [STRING] = {0}; /* completed string (command or variable) */ -char *Matches[MAX(NUMVARS,NUMCOMMANDS) + 1]; /* all the matches + User_typed */ +int Num_matched = 0; /* Number of matches for completion */ +char Completed[STRING] = { 0 }; /* completed string (command or variable) */ +char *Matches[MAX (NUMVARS, NUMCOMMANDS) + 1]; /* all the matches + User_typed */ /* helper function for completion. Changes the dest buffer if necessary/possible to aid completion. @@ -1518,13 +1669,11 @@ static void candidate (char *dest, char *try, char *src, int len) { int l; - if (strstr (src, try) == src) - { + if (strstr (src, try) == src) { Matches[Num_matched++] = src; if (dest[0] == 0) strfcpy (dest, src, len); - else - { + else { for (l = 0; src[l] && src[l] == dest[l]; l++); dest[l] = 0; } @@ -1535,7 +1684,7 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) { char *pt = buffer; int num; - int spaces; /* keep track of the number of leading spaces on the line */ + int spaces; /* keep track of the number of leading spaces on the line */ SKIPWS (buffer); spaces = buffer - pt; @@ -1544,76 +1693,71 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) while ((pt > buffer) && !isspace ((unsigned char) *pt)) pt--; - if (pt == buffer) /* complete cmd */ - { + if (pt == buffer) { /* complete cmd */ /* first TAB. Collect all the matches */ - if (numtabs == 1) - { + if (numtabs == 1) { Num_matched = 0; strfcpy (User_typed, pt, sizeof (User_typed)); memset (Matches, 0, sizeof (Matches)); memset (Completed, 0, sizeof (Completed)); for (num = 0; Commands[num].name; num++) - candidate (Completed, User_typed, Commands[num].name, sizeof (Completed)); + candidate (Completed, User_typed, Commands[num].name, + sizeof (Completed)); Matches[Num_matched++] = User_typed; /* All matches are stored. Longest non-ambiguous string is "" * i.e. dont change 'buffer'. Fake successful return this time */ if (User_typed[0] == 0) - return 1; + return 1; } if (Completed[0] == 0 && User_typed[0]) return 0; - /* Num_matched will _always_ be atleast 1 since the initial - * user-typed string is always stored */ + /* Num_matched will _always_ be atleast 1 since the initial + * user-typed string is always stored */ if (numtabs == 1 && Num_matched == 2) - snprintf(Completed, sizeof(Completed),"%s", Matches[0]); + snprintf (Completed, sizeof (Completed), "%s", Matches[0]); else if (numtabs > 1 && Num_matched > 2) /* cycle thru all the matches */ - snprintf(Completed, sizeof(Completed), "%s", - Matches[(numtabs - 2) % Num_matched]); + snprintf (Completed, sizeof (Completed), "%s", + Matches[(numtabs - 2) % Num_matched]); /* return the completed command */ strncpy (buffer, Completed, len - spaces); } else if (!mutt_strncmp (buffer, "set", 3) - || !mutt_strncmp (buffer, "unset", 5) - || !mutt_strncmp (buffer, "reset", 5) - || !mutt_strncmp (buffer, "toggle", 6)) - { /* complete variables */ + || !mutt_strncmp (buffer, "unset", 5) + || !mutt_strncmp (buffer, "reset", 5) + || !mutt_strncmp (buffer, "toggle", 6)) { /* complete variables */ char *prefixes[] = { "no", "inv", "?", "&", 0 }; - + pt++; /* loop through all the possible prefixes (no, inv, ...) */ - if (!mutt_strncmp (buffer, "set", 3)) - { - for (num = 0; prefixes[num]; num++) - { - if (!mutt_strncmp (pt, prefixes[num], mutt_strlen (prefixes[num]))) - { - pt += mutt_strlen (prefixes[num]); - break; - } + if (!mutt_strncmp (buffer, "set", 3)) { + for (num = 0; prefixes[num]; num++) { + if (!mutt_strncmp (pt, prefixes[num], mutt_strlen (prefixes[num]))) { + pt += mutt_strlen (prefixes[num]); + break; + } } } - + /* first TAB. Collect all the matches */ - if (numtabs == 1) - { + if (numtabs == 1) { Num_matched = 0; strfcpy (User_typed, pt, sizeof (User_typed)); memset (Matches, 0, sizeof (Matches)); memset (Completed, 0, sizeof (Completed)); for (num = 0; MuttVars[num].option; num++) - candidate (Completed, User_typed, MuttVars[num].option, sizeof (Completed)); + candidate (Completed, User_typed, MuttVars[num].option, + sizeof (Completed)); Matches[Num_matched++] = User_typed; /* All matches are stored. Longest non-ambiguous string is "" * i.e. dont change 'buffer'. Fake successful return this time */ if (User_typed[0] == 0) - return 1; + return 1; } if (Completed[0] == 0 && User_typed[0]) @@ -1622,44 +1766,42 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) /* Num_matched will _always_ be atleast 1 since the initial * user-typed string is always stored */ if (numtabs == 1 && Num_matched == 2) - snprintf(Completed, sizeof(Completed),"%s", Matches[0]); + snprintf (Completed, sizeof (Completed), "%s", Matches[0]); else if (numtabs > 1 && Num_matched > 2) - /* cycle thru all the matches */ - snprintf(Completed, sizeof(Completed), "%s", - Matches[(numtabs - 2) % Num_matched]); + /* cycle thru all the matches */ + snprintf (Completed, sizeof (Completed), "%s", + Matches[(numtabs - 2) % Num_matched]); strncpy (pt, Completed, buffer + len - pt - spaces); } - else if (!mutt_strncmp (buffer, "exec", 4)) - { + else if (!mutt_strncmp (buffer, "exec", 4)) { struct binding_t *menu = km_get_table (CurrentMenu); if (!menu && CurrentMenu != MENU_PAGER) menu = OpGeneric; - + pt++; /* first TAB. Collect all the matches */ - if (numtabs == 1) - { + if (numtabs == 1) { Num_matched = 0; strfcpy (User_typed, pt, sizeof (User_typed)); memset (Matches, 0, sizeof (Matches)); memset (Completed, 0, sizeof (Completed)); for (num = 0; menu[num].name; num++) - candidate (Completed, User_typed, menu[num].name, sizeof (Completed)); + candidate (Completed, User_typed, menu[num].name, sizeof (Completed)); /* try the generic menu */ - if (Completed[0] == 0 && CurrentMenu != MENU_PAGER) - { - menu = OpGeneric; - for (num = 0; menu[num].name; num++) - candidate (Completed, User_typed, menu[num].name, sizeof (Completed)); + if (Completed[0] == 0 && CurrentMenu != MENU_PAGER) { + menu = OpGeneric; + for (num = 0; menu[num].name; num++) + candidate (Completed, User_typed, menu[num].name, + sizeof (Completed)); } Matches[Num_matched++] = User_typed; /* All matches are stored. Longest non-ambiguous string is "" * i.e. dont change 'buffer'. Fake successful return this time */ if (User_typed[0] == 0) - return 1; + return 1; } if (Completed[0] == 0 && User_typed[0]) @@ -1668,11 +1810,11 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) /* Num_matched will _always_ be atleast 1 since the initial * user-typed string is always stored */ if (numtabs == 1 && Num_matched == 2) - snprintf(Completed, sizeof(Completed),"%s", Matches[0]); + snprintf (Completed, sizeof (Completed), "%s", Matches[0]); else if (numtabs > 1 && Num_matched > 2) - /* cycle thru all the matches */ - snprintf(Completed, sizeof(Completed), "%s", - Matches[(numtabs - 2) % Num_matched]); + /* cycle thru all the matches */ + snprintf (Completed, sizeof (Completed), "%s", + Matches[(numtabs - 2) % Num_matched]); strncpy (pt, Completed, buffer + len - pt - spaces); } @@ -1686,7 +1828,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) { char var[STRING], *pt = buffer; int spaces; - + if (buffer[0] == 0) return 0; @@ -1696,88 +1838,87 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) pt = buffer + pos - spaces; while ((pt > buffer) && !isspace ((unsigned char) *pt)) pt--; - pt++; /* move past the space */ - if (*pt == '=') /* abort if no var before the '=' */ + pt++; /* move past the space */ + if (*pt == '=') /* abort if no var before the '=' */ return 0; - if (mutt_strncmp (buffer, "set", 3) == 0) - { + if (mutt_strncmp (buffer, "set", 3) == 0) { int idx; + strfcpy (var, pt, sizeof (var)); /* ignore the trailing '=' when comparing */ var[mutt_strlen (var) - 1] = 0; - if ((idx = mutt_option_index (var)) == -1) - return 0; /* no such variable. */ - else - { - char tmp [LONG_STRING], tmp2[LONG_STRING]; + if ((idx = mutt_option_index (var)) == -1) + return 0; /* no such variable. */ + else { + char tmp[LONG_STRING], tmp2[LONG_STRING]; char *s, *d; size_t dlen = buffer + len - pt - spaces; char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; tmp[0] = '\0'; - if ((DTYPE(MuttVars[idx].type) == DT_STR) || - (DTYPE(MuttVars[idx].type) == DT_PATH) || - (DTYPE(MuttVars[idx].type) == DT_RX)) - { - strfcpy (tmp, NONULL (*((char **) MuttVars[idx].data)), sizeof (tmp)); - if (DTYPE (MuttVars[idx].type) == DT_PATH) - mutt_pretty_mailbox (tmp); + if ((DTYPE (MuttVars[idx].type) == DT_STR) || + (DTYPE (MuttVars[idx].type) == DT_PATH) || + (DTYPE (MuttVars[idx].type) == DT_RX)) { + strfcpy (tmp, NONULL (*((char **) MuttVars[idx].data)), sizeof (tmp)); + if (DTYPE (MuttVars[idx].type) == DT_PATH) + mutt_pretty_mailbox (tmp); } - else if (DTYPE (MuttVars[idx].type) == DT_ADDR) - { - rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) MuttVars[idx].data), 0); + else if (DTYPE (MuttVars[idx].type) == DT_ADDR) { + rfc822_write_address (tmp, sizeof (tmp), + *((ADDRESS **) MuttVars[idx].data), 0); } else if (DTYPE (MuttVars[idx].type) == DT_QUAD) - strfcpy (tmp, vals[quadoption (MuttVars[idx].data)], sizeof (tmp)); + strfcpy (tmp, vals[quadoption (MuttVars[idx].data)], sizeof (tmp)); else if (DTYPE (MuttVars[idx].type) == DT_NUM) - snprintf (tmp, sizeof (tmp), "%d", (*((short *) MuttVars[idx].data))); - else if (DTYPE (MuttVars[idx].type) == DT_SORT) - { - const struct mapping_t *map; - char *p; - - switch (MuttVars[idx].type & DT_SUBTYPE_MASK) - { - case DT_SORT_ALIAS: - map = SortAliasMethods; - break; - case DT_SORT_BROWSER: - map = SortBrowserMethods; - break; - case DT_SORT_KEYS: - if ((WithCrypto & APPLICATION_PGP)) - map = SortKeyMethods; - else - map = SortMethods; - break; - default: - map = SortMethods; - break; - } - p = mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, map); - snprintf (tmp, sizeof (tmp), "%s%s%s", - (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? "reverse-" : "", - (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : "", - p); + snprintf (tmp, sizeof (tmp), "%d", (*((short *) MuttVars[idx].data))); + else if (DTYPE (MuttVars[idx].type) == DT_SORT) { + const struct mapping_t *map; + char *p; + + switch (MuttVars[idx].type & DT_SUBTYPE_MASK) { + case DT_SORT_ALIAS: + map = SortAliasMethods; + break; + case DT_SORT_BROWSER: + map = SortBrowserMethods; + break; + case DT_SORT_KEYS: + if ((WithCrypto & APPLICATION_PGP)) + map = SortKeyMethods; + else + map = SortMethods; + break; + default: + map = SortMethods; + break; + } + p = + mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, + map); + snprintf (tmp, sizeof (tmp), "%s%s%s", + (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? + "reverse-" : "", + (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : + "", p); } else if (DTYPE (MuttVars[idx].type) == DT_BOOL) - strfcpy (tmp, option (MuttVars[idx].data) ? "yes" : "no", sizeof (tmp)); + strfcpy (tmp, option (MuttVars[idx].data) ? "yes" : "no", + sizeof (tmp)); else - return 0; - - for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof (tmp2) - 2;) - { - if (*s == '\\' || *s == '"') - *d++ = '\\'; - *d++ = *s++; + return 0; + + for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof (tmp2) - 2;) { + if (*s == '\\' || *s == '"') + *d++ = '\\'; + *d++ = *s++; } *d = '\0'; - + strfcpy (tmp, pt, sizeof (tmp)); snprintf (pt, dlen, "%s\"%s\"", tmp, tmp2); - + return 1; } } @@ -1785,33 +1926,31 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) } /* Implement the -Q command line flag */ -int mutt_query_variables (LIST *queries) +int mutt_query_variables (LIST * queries) { LIST *p; - + char errbuff[STRING]; char command[STRING]; - + BUFFER err, token; - + memset (&err, 0, sizeof (err)); memset (&token, 0, sizeof (token)); - + err.data = errbuff; err.dsize = sizeof (errbuff); - - for (p = queries; p; p = p->next) - { + + for (p = queries; p; p = p->next) { snprintf (command, sizeof (command), "set ?%s\n", p->data); - if (mutt_parse_rc_line (command, &token, &err) == -1) - { + if (mutt_parse_rc_line (command, &token, &err) == -1) { fprintf (stderr, "%s\n", err.data); FREE (&token.data); return 1; } printf ("%s\n", err.data); } - + FREE (&token.data); return 0; } @@ -1820,7 +1959,7 @@ char *mutt_getnamebyvalue (int val, const struct mapping_t *map) { int i; - for (i=0; map[i].name; i++) + for (i = 0; map[i].name; i++) if (map[i].value == val) return (map[i].name); return NULL; @@ -1845,23 +1984,23 @@ static void start_debug (void) char buf2[_POSIX_PATH_MAX]; /* rotate the old debug logs */ - for (i=3; i>=0; i--) - { - snprintf (buf, sizeof(buf), "%s/.muttdebug%d", NONULL(Homedir), i); - snprintf (buf2, sizeof(buf2), "%s/.muttdebug%d", NONULL(Homedir), i+1); + for (i = 3; i >= 0; i--) { + snprintf (buf, sizeof (buf), "%s/.muttdebug%d", NONULL (Homedir), i); + snprintf (buf2, sizeof (buf2), "%s/.muttdebug%d", NONULL (Homedir), + i + 1); rename (buf, buf2); } - if ((debugfile = safe_fopen(buf, "w")) != NULL) - { + if ((debugfile = safe_fopen (buf, "w")) != NULL) { t = time (0); - setbuf (debugfile, NULL); /* don't buffer the debugging output! */ - fprintf (debugfile, "Mutt %s started at %s.\nDebugging at level %d.\n\n", - MUTT_VERSION, asctime (localtime (&t)), debuglevel); + setbuf (debugfile, NULL); /* don't buffer the debugging output! */ + fprintf (debugfile, + "Mutt-ng %s started at %s.\nDebugging at level %d.\n\n", + MUTT_VERSION, asctime (localtime (&t)), debuglevel); } } #endif -static int mutt_execute_commands (LIST *p) +static int mutt_execute_commands (LIST * p) { BUFFER err, token; char errstr[SHORT_STRING]; @@ -1870,10 +2009,8 @@ static int mutt_execute_commands (LIST *p) err.data = errstr; err.dsize = sizeof (errstr); memset (&token, 0, sizeof (token)); - for (; p; p = p->next) - { - if (mutt_parse_rc_line (p->data, &token, &err) != 0) - { + for (; p; p = p->next) { + if (mutt_parse_rc_line (p->data, &token, &err) != 0) { fprintf (stderr, _("Error in command line: %s\n"), err.data); FREE (&token.data); return (-1); @@ -1883,7 +2020,7 @@ static int mutt_execute_commands (LIST *p) return 0; } -void mutt_init (int skip_sys_rc, LIST *commands) +void mutt_init (int skip_sys_rc, LIST * commands) { struct passwd *pw; struct utsname utsname; @@ -1899,16 +2036,15 @@ void mutt_init (int skip_sys_rc, LIST *commands) * XXX - use something even more difficult to predict? */ snprintf (AttachmentMarker, sizeof (AttachmentMarker), - "\033]9;%ld\a", (long) time (NULL)); - + "\033]9;%ld\a", (long) time (NULL)); + /* on one of the systems I use, getcwd() does not return the same prefix as is listed in the passwd file */ if ((p = getenv ("HOME"))) Homedir = safe_strdup (p); /* Get some information about the user */ - if ((pw = getpwuid (getuid ()))) - { + if ((pw = getpwuid (getuid ()))) { char rnbuf[STRING]; Username = safe_strdup (pw->pw_name); @@ -1918,18 +2054,15 @@ void mutt_init (int skip_sys_rc, LIST *commands) Realname = safe_strdup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw)); Shell = safe_strdup (pw->pw_shell); } - else - { - if (!Homedir) - { + else { + if (!Homedir) { mutt_endwin (NULL); fputs (_("unable to determine home directory"), stderr); exit (1); } if ((p = getenv ("USER"))) Username = safe_strdup (p); - else - { + else { mutt_endwin (NULL); fputs (_("unable to determine username"), stderr); exit (1); @@ -1946,11 +2079,10 @@ void mutt_init (int skip_sys_rc, LIST *commands) /* And about the host... */ uname (&utsname); /* some systems report the FQDN instead of just the hostname */ - if ((p = strchr (utsname.nodename, '.'))) - { + if ((p = strchr (utsname.nodename, '.'))) { Hostname = mutt_substrdup (utsname.nodename, p); p++; - strfcpy (buffer, p, sizeof (buffer)); /* save the domain for below */ + strfcpy (buffer, p, sizeof (buffer)); /* save the domain for below */ } else Hostname = safe_strdup (utsname.nodename); @@ -1961,27 +2093,27 @@ void mutt_init (int skip_sys_rc, LIST *commands) Fqdn = safe_strdup ("@"); else #endif /* DOMAIN */ - if (*DOMAIN != '@') - { + if (*DOMAIN != '@') { Fqdn = safe_malloc (mutt_strlen (DOMAIN) + mutt_strlen (Hostname) + 2); - sprintf (Fqdn, "%s.%s", NONULL(Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */ + sprintf (Fqdn, "%s.%s", NONULL (Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */ } else - Fqdn = safe_strdup(NONULL(Hostname)); + Fqdn = safe_strdup (NONULL (Hostname)); #ifdef USE_NNTP { FILE *f; char *i; - if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) - { + if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) { buffer[0] = '\0'; fgets (buffer, sizeof (buffer), f); - p = &buffer; + p = (char*) &buffer; SKIPWS (p); i = p; - while (*i && (*i != ' ') && (*i != '\t') && (*i != '\r') && (*i != '\n')) i++; + while (*i && (*i != ' ') && (*i != '\t') && (*i != '\r') + && (*i != '\n')) + i++; *i = '\0'; NewsServer = safe_strdup (p); fclose (f); @@ -1995,29 +2127,28 @@ void mutt_init (int skip_sys_rc, LIST *commands) Spoolfile = safe_strdup (p); else if ((p = getenv ("MAILDIR"))) Spoolfile = safe_strdup (p); - else - { + else { #ifdef HOMESPOOL mutt_concat_path (buffer, NONULL (Homedir), MAILPATH, sizeof (buffer)); #else - mutt_concat_path (buffer, MAILPATH, NONULL(Username), sizeof (buffer)); + mutt_concat_path (buffer, MAILPATH, NONULL (Username), sizeof (buffer)); #endif Spoolfile = safe_strdup (buffer); } if ((p = getenv ("MAILCAPS"))) MailcapPath = safe_strdup (p); - else - { + else { /* Default search path from RFC1524 */ - MailcapPath = safe_strdup ("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"); + MailcapPath = + safe_strdup ("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR + "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"); } Tempdir = safe_strdup ((p = getenv ("TMPDIR")) ? p : "/tmp"); p = getenv ("VISUAL"); - if (!p) - { + if (!p) { p = getenv ("EDITOR"); if (!p) p = "vi"; @@ -2025,8 +2156,7 @@ void mutt_init (int skip_sys_rc, LIST *commands) Editor = safe_strdup (p); Visual = safe_strdup (p); - if ((p = getenv ("REPLYTO")) != NULL) - { + if ((p = getenv ("REPLYTO")) != NULL) { BUFFER buf, token; snprintf (buffer, sizeof (buffer), "Reply-To: %s", p); @@ -2042,14 +2172,13 @@ void mutt_init (int skip_sys_rc, LIST *commands) if ((p = getenv ("EMAIL")) != NULL) From = rfc822_parse_adrlist (NULL, p); - + mutt_set_langinfo_charset (); mutt_set_charset (Charset); - - + + /* Set standard defaults */ - for (i = 0; MuttVars[i].option; i++) - { + for (i = 0; MuttVars[i].option; i++) { mutt_set_default (&MuttVars[i]); mutt_restore_default (&MuttVars[i]); } @@ -2067,87 +2196,84 @@ void mutt_init (int skip_sys_rc, LIST *commands) #ifdef HAVE_GETSID /* Unset suspend by default if we're the session leader */ - if (getsid(0) == getpid()) + if (getsid (0) == getpid ()) unset_option (OPTSUSPEND); #endif mutt_init_history (); - - - + + + /* * - * BIG FAT WARNING + * BIG FAT WARNING * * When changing the code which looks for a configuration file, * please also change the corresponding code in muttbug.sh.in. * * */ - - - - - if (!Muttrc) - { - snprintf (buffer, sizeof(buffer), "%s/.muttngrc-%s", NONULL(Homedir), MUTT_VERSION); - if (access(buffer, F_OK) == -1) - snprintf (buffer, sizeof(buffer), "%s/.muttngrc", NONULL(Homedir)); - if (access(buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc-%s", NONULL(Homedir), MUTT_VERSION); - if (access(buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc", NONULL(Homedir)); - + + + + + if (!Muttrc) { + snprintf (buffer, sizeof (buffer), "%s/.muttngrc-%s", NONULL (Homedir), + MUTT_VERSION); + if (access (buffer, F_OK) == -1) + snprintf (buffer, sizeof (buffer), "%s/.muttngrc", NONULL (Homedir)); + if (access (buffer, F_OK) == -1) + snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc-%s", + NONULL (Homedir), MUTT_VERSION); + if (access (buffer, F_OK) == -1) + snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc", + NONULL (Homedir)); + default_rc = 1; Muttrc = safe_strdup (buffer); } - else - { + else { strfcpy (buffer, Muttrc, sizeof (buffer)); FREE (&Muttrc); mutt_expand_path (buffer, sizeof (buffer)); Muttrc = safe_strdup (buffer); } FREE (&AliasFile); - AliasFile = safe_strdup (NONULL(Muttrc)); + AliasFile = safe_strdup (NONULL (Muttrc)); /* Process the global rc file if it exists and the user hasn't explicity requested not to via "-n". */ - if (!skip_sys_rc) - { - snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", SYSCONFDIR, MUTT_VERSION); + if (!skip_sys_rc) { + snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", SYSCONFDIR, + MUTT_VERSION); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof(buffer), "%s/Muttngrc", SYSCONFDIR); + snprintf (buffer, sizeof (buffer), "%s/Muttngrc", SYSCONFDIR); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", PKGDATADIR, MUTT_VERSION); + snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", PKGDATADIR, + MUTT_VERSION); if (access (buffer, F_OK) == -1) snprintf (buffer, sizeof (buffer), "%s/Muttngrc", PKGDATADIR); - if (access (buffer, F_OK) != -1) - { - if (source_rc (buffer, &err) != 0) - { - fputs (err.data, stderr); - fputc ('\n', stderr); - need_pause = 1; + if (access (buffer, F_OK) != -1) { + if (source_rc (buffer, &err) != 0) { + fputs (err.data, stderr); + fputc ('\n', stderr); + need_pause = 1; } } } /* Read the user's initialization file. */ - if (access (Muttrc, F_OK) != -1) - { + if (access (Muttrc, F_OK) != -1) { if (!option (OPTNOCURSES)) endwin (); - if (source_rc (Muttrc, &err) != 0) - { + if (source_rc (Muttrc, &err) != 0) { fputs (err.data, stderr); fputc ('\n', stderr); need_pause = 1; } } - else if (!default_rc) - { + else if (!default_rc) { /* file specified by -F does not exist */ snprintf (buffer, sizeof (buffer), "%s: %s", Muttrc, strerror (errno)); mutt_endwin (buffer); @@ -2157,14 +2283,13 @@ void mutt_init (int skip_sys_rc, LIST *commands) if (mutt_execute_commands (commands) != 0) need_pause = 1; - if (need_pause && !option (OPTNOCURSES)) - { + if (need_pause && !option (OPTNOCURSES)) { if (mutt_any_key_to_continue (NULL) == -1) - mutt_exit(1); + mutt_exit (1); } #if 0 - set_option (OPTWEED); /* turn weeding on by default */ + set_option (OPTWEED); /* turn weeding on by default */ #endif } @@ -2172,136 +2297,8 @@ int mutt_get_hook_type (const char *name) { struct command_t *c; - for (c = Commands ; c->name ; c++) + for (c = Commands; c->name; c++) if (c->func == mutt_parse_hook && ascii_strcasecmp (c->name, name) == 0) return c->data; return 0; } - -void mutt_start_slrnface(void) -{ - char *fifo; - int pathlen, status; - pid_t pid, pidst; - struct utsname u; - - if (!option(OPTXFACE)) - return; - - /* - * If we don't have display, there's no point. The user probably knows, - * so fail silently. - */ - if (!getenv("DISPLAY")) - return; - /* If there is no WINDOWID, complain. */ - if (!getenv ("WINDOWID")) - { - mutt_error (_("Cannot run slrnface: WINDOWID not found in environment.")); - return; - } - - uname (&u); - pathlen = strlen (Homedir) + sizeof("/.slrnfaces/") - + strlen (u.nodename) + 30; - fifo = safe_malloc (pathlen); - sprintf (fifo, "%s/.slrnfaces", Homedir); - if (mkdir (fifo, 0700)) - { - if (errno != EEXIST) - { - mutt_error (_("Cannot run slrnface: failed to create %s: %s."), - fifo, strerror(errno)); - return; - } - } - else - { - FILE *fp; - - /* We'll abuse fifo filename memory here. It's long enough. */ - sprintf (fifo, "%s/.slrnfaces/README", Homedir); - if ((fp = fopen (fifo, "w")) != NULL) - { - fputs (_( -"This directory is used to create named pipes for communication between\n" -"slrnface and its parent process. It should normally be empty because\n" -"the pipe is deleted right after it has been opened by both processes.\n\n" -"File names generated by slrnface have the form \"hostname.pid\". It is\n" -"probably an error if they linger here longer than a fraction of a second.\n\n" -"However, if the directory is mounted from an NFS server, you might see\n" -"special files created by your NFS server while slrnface is running.\n" -"Do not try to remove them.\n"), fp); - fclose (fp); - } - } - - status = snprintf (fifo, pathlen, "%s/.slrnfaces/%s.%ld", Homedir, - u.nodename, (long)getpid()); - if (status < 0) - goto clean_face; - - unlink (fifo); - if (mkfifo (fifo, 0600) < 0) - { - mutt_error (_("Cannot run slrnface, failed to create %s: %s."), fifo, - strerror(errno)); - goto clean_face; - } - - pid = fork(); - switch (pid) - { - case -1: break; - case 0: execlp ("slrnface", "slrnface", fifo, (char *)0); - /* This is child, exit on error. */ - _exit (10); - default: do { - pidst = waitpid (pid, &status, 0); - } while (pidst == -1 && errno == EINTR); - - if (!WIFEXITED (status)) - mutt_error (_("Slrnface abnormaly exited, code %d."), status); - else - { - char *message; - - switch (WEXITSTATUS (status)) - { - case 0: /* All fine, open the pipe */ - slrnface_fd = open (fifo, O_WRONLY, 0600); - write (slrnface_fd, "start\n", sizeof "start"); - goto clean_face; - case 1: message = "couldn't connect to display"; - break; - case 2: message = "WINDOWID not found in environment"; - break; - case 3: message = "couldn't find controlling terminal"; - break; - case 4: message = "terminal doesn't export width and height"; - break; - case 5: message = "cannot open FIFO"; - break; - case 6: message = "fork() failed"; - break; - case 10: message = "executable not found"; - break; - default: message = "unknown error"; - } - mutt_error (_("Slrnface failed: %s."), message); - } - } - -clean_face: - unlink (fifo); - free (fifo); -} - -void mutt_stop_slrnface(void) -{ - if (slrnface_fd >= 0) - close(slrnface_fd); - slrnface_fd = -1; - - /* FIFO has been unlinked in the startup function. */ -}