X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=1c3227054a23ab53f5da45b3bfbba24d608562b1;hp=0728ffee6468d582525db911a850e49b8d8f4dc0;hb=766fd6928123218aca635827248299ceeeb1d170;hpb=c7ceecd31e97891dd5cf48536d4bddf2c1d7d9dd diff --git a/init.c b/init.c index 0728ffe..1c32270 100644 --- a/init.c +++ b/init.c @@ -1,45 +1,51 @@ /* + * 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. - */ + * + * Parts were written/modified by: + * Rocco Rutte + * + * 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 +#include +#include +#include +#include +#include +#include + #include "mutt.h" -#include "mapping.h" #include "mutt_curses.h" -#include "mutt_regex.h" #include "history.h" #include "keymap.h" #include "mbyte.h" #include "charset.h" +#include "thread.h" #include "mutt_crypt.h" #include "mutt_idna.h" -#if defined(USE_SSL) || defined(USE_NSS) || defined(USE_GNUTLS) +#if defined(USE_SSL) || defined(USE_GNUTLS) #include "mutt_ssl.h" #endif - +#if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS)) +#include "mutt_libesmtp.h" +#endif #include "mx.h" #include "init.h" -#include "mailbox.h" + +#include "lib/rx.h" +#include "lib/list.h" +#include "lib/debug.h" #include #include @@ -49,9 +55,534 @@ #include #include +/* + * prototypes + */ +static const struct mapping_t* get_sortmap (struct option_t* option); +static int parse_sort (struct option_t* dst, const char *s, + const struct mapping_t *map, + char* errbuf, size_t errlen); + +static HASH *ConfigOptions = NULL; + +/* for synonym warning reports: synonym found during parsing */ +typedef struct { + char* f; /* file */ + int l; /* line */ + struct option_t* n; /* new */ + struct option_t* o; /* old */ +} syn_t; + +/* for synonym warning reports: list of synonyms found */ +static list2_t* Synonyms; +/* for synonym warning reports: current rc file */ +static const char* CurRCFile = NULL; +/* for synonym warning reports: current rc line */ +static int CurRCLine = 0; + +/* prototypes for checking for special vars */ +static int check_dsn_return (const char* option, unsigned long val, + char* errbuf, size_t errlen); +static int check_dsn_notify (const char* option, unsigned long val, + char* errbuf, size_t errlen); +static int check_history (const char* option, unsigned long val, + char* errbuf, size_t errlen); +/* this checks that numbers are >= 0 */ +static int check_num (const char* option, unsigned long val, + char* errbuf, size_t errlen); +#ifdef DEBUG +static int check_debug (const char* option, unsigned long val, + char* errbuf, size_t errlen); +#endif + +/* use this to check only */ +static int check_special (const char* option, unsigned long val, + char* errbuf, size_t errlen); + +/* variable <-> sanity check function mappings + * when changing these, make sure the proper _from_string handler + * does this checking! + */ +static struct { + const char* name; + int (*check) (const char* option, unsigned long val, + char* errbuf, size_t errlen); +} SpecialVars[] = { + { "dsn_notify", check_dsn_notify }, + { "dsn_return", check_dsn_return }, +#if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS)) + { "smtp_use_tls", mutt_libesmtp_check_usetls }, +#endif + { "history", check_history }, + { "pager_index_lines", check_num }, +#ifdef DEBUG + { "debug_level", check_debug }, +#endif + /* last */ + { NULL, NULL } +}; + +/* protos for config type handles: convert value to string */ +static void bool_to_string (char* dst, size_t dstlen, struct option_t* option); +static void num_to_string (char* dst, size_t dstlen, struct option_t* option); +static void str_to_string (char* dst, size_t dstlen, struct option_t* option); +static void quad_to_string (char* dst, size_t dstlen, struct option_t* option); +static void sort_to_string (char* dst, size_t dstlen, struct option_t* option); +static void rx_to_string (char* dst, size_t dstlen, struct option_t* option); +static void magic_to_string (char* dst, size_t dstlen, struct option_t* option); +static void addr_to_string (char* dst, size_t dstlen, struct option_t* option); +static void user_to_string (char* dst, size_t dstlen, struct option_t* option); +static void sys_to_string (char* dst, size_t dstlen, struct option_t* option); + +/* protos for config type handles: convert to value from string */ +static int bool_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int num_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int str_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int path_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int quad_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int sort_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int rx_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int magic_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int addr_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +static int user_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); + +static struct { + unsigned short type; + void (*opt_to_string) (char* dst, size_t dstlen, struct option_t* option); + int (*opt_from_string) (struct option_t* dst, const char* val, + char* errbuf, size_t errlen); +} FuncTable[] = { + { 0, NULL, NULL }, /* there's no DT_ type with 0 */ + { DT_BOOL, bool_to_string, bool_from_string }, + { DT_NUM, num_to_string, num_from_string }, + { DT_STR, str_to_string, str_from_string }, + { DT_PATH, str_to_string, path_from_string }, + { DT_QUAD, quad_to_string, quad_from_string }, + { DT_SORT, sort_to_string, sort_from_string }, + { DT_RX, rx_to_string, rx_from_string }, + { DT_MAGIC, magic_to_string, magic_from_string }, + /* synonyms should be resolved already so we don't need this + * but must define it as DT_ is used for indexing */ + { DT_SYN, NULL, NULL }, + { DT_ADDR, addr_to_string, addr_from_string }, + { DT_USER, user_to_string, user_from_string }, + { DT_SYS, sys_to_string, NULL }, +}; + +static void bool_to_string (char* dst, size_t dstlen, + struct option_t* option) { + snprintf (dst, dstlen, "%s=%s", option->option, + option (option->data) ? "yes" : "no"); +} + +static int bool_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), + size_t errlen __attribute__ ((unused))) { + int flag = -1; + + if (!dst) + return (0); + if (ascii_strncasecmp (val, "yes", 3) == 0) + flag = 1; + else if (ascii_strncasecmp (val, "no", 2) == 0) + flag = 0; + + if (flag < 0) + return (0); + if (flag) + set_option (dst->data); + else + unset_option (dst->data); + return (1); +} + +static void num_to_string (char* dst, size_t dstlen, + struct option_t* option) { + /* XXX puke */ + const char* fmt = (m_strcmp(option->option, "umask") == 0) ? + "%s=%04o" : "%s=%d"; + snprintf (dst, dstlen, fmt, option->option, + *((short*) option->data)); +} + +static int num_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen) { + int num = 0, old = 0; + char* t = NULL; + + if (!dst) + return (0); + + num = strtol (val, &t, 0); + + if (!*val || *t || (short) num != num) { + if (errbuf) { + snprintf (errbuf, errlen, _("'%s' is invalid for $%s"), + val, dst->option); + } + return (0); + } + + /* just temporarily accept new val so that check_special for + * $history already has it when doing history's init() */ + old = *((short*) dst->data); + *((short*) dst->data) = (short) num; + + if (!check_special (dst->option, (unsigned long) num, errbuf, errlen)) { + *((short*) dst->data) = old; + return (0); + } + + return (1); +} + +static void str_to_string (char* dst, size_t dstlen, + struct option_t* option) { + snprintf (dst, dstlen, "%s=\"%s\"", option->option, + NONULL (*((char**) option->data))); +} + +static void user_to_string (char* dst, size_t dstlen, + struct option_t* option) { + snprintf (dst, dstlen, "%s=\"%s\"", option->option, + NONULL (((char*) option->data))); +} + +static void sys_to_string (char* dst, size_t dstlen, + struct option_t* option) { + char *val = NULL, *t = NULL; + int clean = 0; + + /* get some $muttng_ values dynamically */ + if (ascii_strcmp ("muttng_pwd", option->option) == 0) { + val = p_new(char, _POSIX_PATH_MAX); + val = getcwd (val, _POSIX_PATH_MAX-1); + clean = 1; + } else if (ascii_strcmp ("muttng_folder_path", option->option) == 0 && + CurrentFolder && *CurrentFolder) { + val = CurrentFolder; + } else if (ascii_strcmp ("muttng_folder_name", option->option) == 0 && + CurrentFolder && *CurrentFolder) { + + ssize_t Maildirlength = m_strlen(Maildir); + + /* + * if name starts with $folder, just strip it to keep hierarchy + * $folder=imap://host, path=imap://host/inbox/b -> inbox/b + */ + if (Maildirlength > 0 && m_strncmp(CurrentFolder, Maildir, + Maildirlength) == 0 && + m_strlen(CurrentFolder) > Maildirlength) { + val = CurrentFolder + Maildirlength; + if (Maildir[strlen(Maildir)-1]!='/') + val += 1; + /* if not $folder, just use everything after last / */ + } else if ((t = strrchr (CurrentFolder, '/')) != NULL) + val = t+1; + /* default: use as-is */ + else + val = (char *) CurrentFolder; + + } else + val = (char *) option->init; + + snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (val)); + if (clean) + p_delete(&val); +} + +static int path_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) { + char path[_POSIX_PATH_MAX]; + + if (!dst) + return (0); + + if (!val || !*val) { + p_delete((char**) dst->data); + return (1); + } + + path[0] = '\0'; + m_strcpy(path, sizeof(path), val); + mutt_expand_path (path, sizeof(path)); + m_strreplace((char **) dst->data, path); + return (1); +} + +static int str_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen) { + if (!dst) + return (0); + + if (!check_special (dst->option, (unsigned long) val, errbuf, errlen)) + return (0); + + m_strreplace((char**) dst->data, val); + return (1); +} + +static int user_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) { + /* if dst == NULL, we may get here in case the user did unset it, + * see parse_set() where item is free()'d before coming here; so + * just silently ignore it */ + if (!dst) + return (1); + if (m_strlen((char*) dst->data) == 0) + dst->data = (unsigned long) m_strdup(val); + else { + char* s = (char*) dst->data; + m_strreplace(&s, val); + } + if (m_strlen(dst->init) == 0) + dst->init = m_strdup((char*) dst->data); + return (1); +} + +static void quad_to_string (char* dst, size_t dstlen, + struct option_t* option) { + const char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; + snprintf (dst, dstlen, "%s=%s", option->option, + vals[quadoption (option->data)]); +} + +static int quad_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) { + int flag = -1; + + if (!dst) + return (0); + if (ascii_strncasecmp (val, "yes", 3) == 0) + flag = M_YES; + else if (ascii_strncasecmp (val, "no", 2) == 0) + flag = M_NO; + else if (ascii_strncasecmp (val, "ask-yes", 7) == 0) + flag = M_ASKYES; + else if (ascii_strncasecmp (val, "ask-no", 6) == 0) + flag = M_ASKNO; + + if (flag < 0) + return (0); + + set_quadoption (dst->data, flag); + return (1); +} + +static void sort_to_string (char* dst, size_t dstlen, + struct option_t* option) { + const struct mapping_t *map = get_sortmap (option); + const char *p = NULL; + + if (!map) { + snprintf (dst, sizeof(dst), "%s=unknown", option->option); + return; + } + + p = mutt_getnamebyvalue(*((short *)option->data) & SORT_MASK, map); + + snprintf (dst, dstlen, "%s=%s%s%s", option->option, + (*((short *) option->data) & SORT_REVERSE) ? + "reverse-" : "", + (*((short *) option->data) & SORT_LAST) ? "last-" : + "", NONULL (p)); +} + +static int sort_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen) { + const struct mapping_t *map = NULL; + if (!(map = get_sortmap (dst))) { + if (errbuf) + snprintf (errbuf, errlen, _("%s: Unknown type."), + dst->option); + return (0); + } + if (parse_sort (dst, val, map, errbuf, errlen) == -1) + return (0); + return (1); +} + +static void rx_to_string (char* dst, size_t dstlen, + struct option_t* option) { + rx_t* p = (rx_t*) option->data; + snprintf (dst, dstlen, "%s=\"%s\"", option->option, + NONULL (p->pattern)); +} + +static int rx_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen) { + rx_t* p = NULL; + regex_t* rx = NULL; + int flags = 0, e = 0, not = 0; + char* s = NULL; + + if (!dst) + return (0); + + if (option (OPTATTACHMSG) && !m_strcmp(dst->option, "reply_regexp")) { + if (errbuf) + snprintf (errbuf, errlen, + "Operation not permitted when in attach-message mode."); + return (0); + } + + if (!((rx_t*) dst->data)) + *((rx_t**) dst->data) = p_new(rx_t, 1); + + p = (rx_t*) dst->data; + + /* something to do? */ + if (!val || !*val || (p->pattern && m_strcmp(p->pattern, val) == 0)) + return (1); + + if (m_strcmp(dst->option, "mask") != 0) + flags |= mutt_which_case (val); + + s = (char*) val; + if (m_strcmp(dst->option, "mask") == 0 && *s == '!') { + not = 1; + s++; + } + + rx = p_new(regex_t, 1); + + if ((e = REGCOMP (rx, s, flags)) != 0) { + regerror (e, rx, errbuf, errlen); + regfree (rx); + p_delete(&rx); + return (0); + } + + if (p->rx) { + regfree (p->rx); + p_delete(&p->rx); + } + + m_strreplace(&p->pattern, val); + p->rx = rx; + p->not = not; + + if (m_strcmp(dst->option, "reply_regexp") == 0) + mutt_adjust_all_subjects (); + + return (1); +} + +static void magic_to_string (char* dst, size_t dstlen, + struct option_t* option) { + const char* s = NULL; + switch (option->data) { + case M_MBOX: s = "mbox"; break; + case M_MMDF: s = "MMDF"; break; + case M_MH: s = "MH"; break; + case M_MAILDIR: s = "Maildir"; break; + default: s = "unknown"; break; + } + snprintf (dst, dstlen, "%s=%s", option->option, s); +} + +static int magic_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) { + int flag = -1; + + if (!dst || !val || !*val) + return (0); + if (ascii_strncasecmp (val, "mbox", 4) == 0) + flag = M_MBOX; + else if (ascii_strncasecmp (val, "mmdf", 4) == 0) + flag = M_MMDF; + else if (ascii_strncasecmp (val, "mh", 2) == 0) + flag = M_MH; + else if (ascii_strncasecmp (val, "maildir", 7) == 0) + flag = M_MAILDIR; + + if (flag < 0) + return (0); + + *((short*) dst->data) = flag; + return (1); + +} + +static void addr_to_string (char* dst, size_t dstlen, + struct option_t* option) { + char s[HUGE_STRING]; + s[0] = '\0'; + rfc822_write_address (s, sizeof(s), *((address_t**) option->data), 0); + snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s)); +} + +static int addr_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) { + if (!dst) + return (0); + address_delete ((address_t**) dst->data); + if (val && *val) + *((address_t**) dst->data) = rfc822_parse_adrlist (NULL, val); + return (1); +} + +int mutt_option_value (const char* val, char* dst, size_t dstlen) { + struct option_t* option = NULL; + char* tmp = NULL, *t = NULL; + size_t l = 0; + + if (!(option = hash_find (ConfigOptions, val))) { + debug_print (1, ("var '%s' not found\n", val)); + *dst = '\0'; + return (0); + } + tmp = p_new(char, dstlen+1); + FuncTable[DTYPE (option->type)].opt_to_string (tmp, dstlen, option); + + /* as we get things of type $var=value and don't want to bloat the + * above "just" for expansion, we do the stripping here */ + debug_print (1, ("orig == '%s'\n", tmp)); + t = strchr (tmp, '='); + t++; + l = m_strlen(t); + if (l >= 2) { + if (t[l-1] == '"' && *t == '"') { + t[l-1] = '\0'; + t++; + } + } + memcpy (dst, t, l+1); + p_delete(&tmp); + debug_print (1, ("stripped == '%s'\n", dst)); + + return (1); +} + +/* for synonym warning reports: adds synonym to end of list */ +static void syn_add (struct option_t* n, struct option_t* o) { + syn_t* tmp = p_new(syn_t, 1); + tmp->f = m_strdup(CurRCFile); + tmp->l = CurRCLine; + tmp->n = n; + tmp->o = o; + list_push_back (&Synonyms, tmp); +} + +/* for synonym warning reports: free single item (for list_del()) */ +static void syn_del (void** p) { + p_delete(&(*(syn_t**) p)->f); + p_delete(p); +} + void toggle_quadoption (int opt) { - int n = opt/4; + int n = opt / 4; int b = (opt % 4) * 2; QuadOptions[n] ^= (1 << b); @@ -59,7 +590,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); @@ -68,7 +599,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; @@ -78,218 +609,21 @@ 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 */ } -/* given the variable ``s'', return the index into the rc_vars array which - matches, or -1 if the variable is not found. */ -int mutt_option_index (char *s) -{ - int i; - - 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 (-1); -} - -int mutt_extract_token (BUFFER *dest, BUFFER *tok, int flags) -{ - 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) - { - 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; - } - - tok->dptr++; - - if (ch == qc) - 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 == '^' && (flags & M_TOKEN_CONDENSE)) - { - if (!*tok->dptr) - return -1; /* premature end of token */ - ch = *tok->dptr++; - if (ch == '^') - mutt_buffer_addch (dest, ch); - else if (ch == '[') - 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); - } - } - 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; - } - } while (pc && *pc != '`'); - 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); - } - FREE (&cmd); - - tok->dptr = pc + 1; - - /* read line */ - memset (&expn, 0, sizeof (expn)); - expn.data = mutt_read_line (NULL, &expn.dsize, fp, &line); - fclose (fp); - 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 */ - /* 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); - } - 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))) - { - 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; - } - } - 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); - FREE (&var); - } - else - mutt_buffer_addch (dest, ch); - } - 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; @@ -298,10 +632,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; @@ -310,12 +642,10 @@ static void add_to_list (LIST **list, const char *str) break; } - if (!*list || last) - { - t = (LIST *) safe_calloc (1, sizeof (LIST)); - t->data = safe_strdup (str); - if (last) - { + if (!*list || last) { + t = p_new(LIST, 1); + t->data = m_strdup(str); + if (last) { last->next = t; last = last->next; } @@ -324,72 +654,47 @@ 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 (list2_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; } - /* 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; - break; - } - if (!last->next) - break; - } - - if (!*list || last) - { - t = mutt_new_rx_list(); - t->rx = rx; - if (last) - { - last->next = t; - last = last->next; - } - else - *list = last = t; - } - else /* duplicate */ - mutt_free_regexp (&rx); - + 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) +static int add_to_spam_list (SPAM_LIST ** list, const char *pat, + const char *templ, BUFFER * err) { SPAM_LIST *t = NULL, *last = NULL; - REGEXP *rx; + rx_t* rx; int n; const char *p; if (!pat || !*pat || !templ) return 0; - if (!(rx = mutt_compile_regexp (pat, REG_ICASE))) - { + 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) - { + 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 @@ -397,7 +702,7 @@ static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *temp * the template, and leaving t pointed at the current item. */ t = last; - safe_free(&t->template); + p_delete(&t->template); break; } if (!last->next) @@ -407,9 +712,8 @@ static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *temp /* 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(); + if (!t) { + t = mutt_new_spam_list (); t->rx = rx; if (last) last->next = t; @@ -418,53 +722,50 @@ static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *temp } /* Now t is the SPAM_LIST* that we want to modify. It is prepared. */ - t->template = safe_strdup(templ); + t->template = m_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; + for (p = templ; *p;) { + if (*p == '%') { + n = atoi (++p); + if (n > t->nmatch) + t->nmatch = n; + while (*p && isdigit ((int) *p)) + ++p; } else - ++p; + ++p; } - t->nmatch++; /* match 0 is always the whole expr */ + t->nmatch++; /* match 0 is always the whole expr */ return 0; } -static int remove_from_spam_list (SPAM_LIST **list, const char *pat) +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)) - { + if (!spam) + return 0; + if (spam->rx && !m_strcmp(spam->rx->pattern, pat)) { *list = spam->next; - mutt_free_regexp(&spam->rx); - safe_free(&spam->template); - safe_free(&spam); + rx_free (&spam->rx); + p_delete(&spam->template); + p_delete(&spam); return 1; } prev = spam; - for (spam = prev->next; spam;) - { - if (!mutt_strcmp(spam->rx->pattern, pat)) - { + for (spam = prev->next; spam;) { + if (!m_strcmp(spam->rx->pattern, pat)) { prev->next = spam->next; - mutt_free_regexp(&spam->rx); - safe_free(&spam->template); - safe_free(&spam); + rx_free (&spam->rx); + p_delete(&spam->template); + p_delete(&spam); spam = prev->next; ++nremoved; } @@ -476,148 +777,124 @@ static int remove_from_spam_list (SPAM_LIST **list, const char *pat) } -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 - { + if (m_strcmp("*", str) == 0) + 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) { + p_delete(&p->data); + if (last) + last->next = p->next; + else + (*l) = p->next; + p_delete(&p); } - else - { - last = p; - p = p->next; + else { + last = p; + p = p->next; } } } } -static int 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 rv = -1; - - if (mutt_strcmp ("*", str) == 0) - { - mutt_free_rx_list (l); /* ``unCMD *'' means delete all current entries */ - rv = 0; - } - 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); - rv = 0; - } - else - { - last = p; - p = p->next; - } + int i = 0; + + if (m_strcmp("*", str) == 0) { + list_del (l, (list_del_t*) 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 (rv); + return (-1); } -static int parse_ifdef (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data, + BUFFER * err) { - int i, j, res = 0; + int i, j; + unsigned long res = 0; BUFFER token; + struct option_t* option = NULL; - memset (&token, 0, sizeof (token)); + p_clear(&token, 1); 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++) - { + if ((option = hash_find (ConfigOptions, tmp->data)) != NULL) + res = 1; + else { + for (i = 0; !res && i < MENU_MAX; i++) { struct binding_t *b = km_get_table (Menus[i].value); if (!b) - continue; + 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)) { + if (!ascii_strncasecmp (tmp->data, b[j].name, m_strlen(tmp->data)) + && (m_strlen(b[j].name) == m_strlen(tmp->data))) { res = 1; break; } - i++; + } + } + /* check for feature_* */ + if (!res && ascii_strncasecmp (tmp->data, "feature_", 8) == 0 && + (j = m_strlen(tmp->data)) > 8) { + i = 0; + while (Features[i]) { + if (m_strlen(Features[i]) == j-8 && + ascii_strncasecmp (Features[i], tmp->data+8, j-8) == 0) { + res = 1; + break; } + i++; } } - if (!MoreArgs (s)) - { + 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) - { + if (data == res) { + if (mutt_parse_rc_line (tmp->data, &token, err) == -1) { mutt_error ("Error: %s", err->data); - FREE (&token.data); + p_delete(&token.data); return (-1); } - FREE (&token.data); + p_delete(&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 __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - 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); @@ -627,10 +904,11 @@ 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 __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_list (&UnIgnore, buf->data); add_to_list (&Ignore, buf->data); @@ -640,10 +918,11 @@ 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 __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - do - { + do { mutt_extract_token (buf, s, 0); add_to_list ((LIST **) data, buf->data); } @@ -652,59 +931,22 @@ static int parse_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -#if 0 -static int _parse_rx_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err, int flags) -{ - do - { - mutt_extract_token (buf, s, 0); - if (add_to_rx_list ((RX_LIST **) data, buf->data, flags, err) != 0) - return -1; - - } - while (MoreArgs (s)); - - return 0; -} - -static int parse_rx_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) -{ - return _parse_rx_list (buf, s, data, err, REG_ICASE); -} - -static int parse_rx_unlist (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; - } - remove_from_rx_list ((RX_LIST **) data, buf->data); - } - while (MoreArgs (s)); - - return 0; -} -#endif - static void _alternates_clean (void) { int i; - if (Context && Context->msgcount) - { + + 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) +static int parse_alternates (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - _alternates_clean(); - do - { + _alternates_clean (); + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&UnAlternates, buf->data); @@ -716,16 +958,17 @@ static int parse_alternates (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER return 0; } -static int parse_unalternates (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unalternates (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - _alternates_clean(); - do - { + _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) + if (m_strcmp(buf->data, "*") && + add_to_rx_list (&UnAlternates, buf->data, REG_ICASE, err) != 0) return -1; } @@ -734,19 +977,19 @@ static int parse_unalternates (BUFFER *buf, BUFFER *s, unsigned long data, BUFFE return 0; } -static int parse_spam_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { BUFFER templ; - memset(&templ, 0, sizeof(templ)); + p_clear(&templ, 1); /* Insist on at least one parameter */ - if (!MoreArgs(s)) - { + if (!MoreArgs (s)) { if (data == M_SPAM) - strfcpy(err->data, _("spam: no matching pattern"), err->dsize); + m_strcpy(err->data, err->dsize, _("spam: no matching pattern")); else - strfcpy(err->data, _("nospam: no matching pattern"), err->dsize); + m_strcpy(err->data, err->dsize, _("nospam: no matching pattern")); return -1; } @@ -754,45 +997,40 @@ static int parse_spam_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER * 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 (data == M_SPAM) { /* If there's a second parameter, it's a template for the spam tag. */ - if (MoreArgs(s)) - { + 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; + p_delete(&templ.data); + return -1; } - FREE(&templ.data); + p_delete(&templ.data); } /* If not, try to remove from the nospam list. */ - else - { - remove_from_rx_list(&NoSpamList, buf->data); + else { + remove_from_rx_list (&NoSpamList, buf->data); } return 0; } /* M_NOSPAM is for nospam commands. */ - else if (data == M_NOSPAM) - { + else if (data == M_NOSPAM) { /* nospam only ever has one parameter. */ /* "*" is a special case. */ - if (!mutt_strcmp(buf->data, "*")) - { + if (!m_strcmp(buf->data, "*")) { mutt_free_spam_list (&SpamList); - mutt_free_rx_list (&NoSpamList); + list_del (&NoSpamList, (list_del_t*) rx_free); return 0; } /* If it's on the spam list, just remove it. */ - if (remove_from_spam_list(&SpamList, buf->data) != 0) + if (remove_from_spam_list (&SpamList, buf->data) != 0) return 0; /* Otherwise, add it to the nospam list. */ @@ -803,20 +1041,19 @@ static int parse_spam_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER * } /* This should not happen. */ - strfcpy(err->data, "This is no good at all.", err->dsize); + m_strcpy(err->data, err->dsize, "This is no good at all."); 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 __attribute__ ((unused))) { - do - { + do { mutt_extract_token (buf, s, 0); /* * Check for deletion of entire list */ - if (mutt_strcmp (buf->data, "*") == 0) - { + if (m_strcmp(buf->data, "*") == 0) { mutt_free_list ((LIST **) data); break; } @@ -827,13 +1064,14 @@ 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) +static int parse_lists (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err) { - do - { + 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; } @@ -842,16 +1080,261 @@ static int parse_lists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -static int parse_unlists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +/* always wise to do what someone else did before */ +static void _attachments_clean (void) { + int i; + if (Context && Context->msgcount) { + for (i = 0; i < Context->msgcount; i++) + Context->hdrs[i]->attach_valid = 0; + } +} + +static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata, + BUFFER *err __attribute__ ((unused))) { + ATTACH_MATCH *a; + LIST *listp, *lastp; + char *p; + char *tmpminor; + int len; + + /* Find the last item in the list that data points to. */ + lastp = NULL; + debug_print (5, ("parse_attach_list: ldata = %p, *ldata = %p\n", + ldata, *ldata)); + for (listp = *ldata; listp; listp = listp->next) { + a = (ATTACH_MATCH *)listp->data; + debug_print (5, ("parse_attach_list: skipping %s/%s\n", a->major, a->minor)); + lastp = listp; + } + + do { + mutt_extract_token (buf, s, 0); + + if (!buf->data || *buf->data == '\0') + continue; + + a = p_new(ATTACH_MATCH, 1); + + /* some cheap hacks that I expect to remove */ + if (!m_strcasecmp(buf->data, "any")) + a->major = m_strdup("*/.*"); + else if (!m_strcasecmp(buf->data, "none")) + a->major = m_strdup("cheap_hack/this_should_never_match"); + else + a->major = m_strdup(buf->data); + + if ((p = strchr(a->major, '/'))) { + *p = '\0'; + ++p; + a->minor = p; + } else { + a->minor = "unknown"; + } + + len = m_strlen(a->minor); + tmpminor = p_new(char, len + 3); + strcpy(&tmpminor[1], a->minor); /* __STRCPY_CHECKED__ */ + tmpminor[0] = '^'; + tmpminor[len+1] = '$'; + tmpminor[len+2] = '\0'; + + a->major_int = mutt_check_mime_type(a->major); + regcomp(&a->minor_rx, tmpminor, REG_ICASE|REG_EXTENDED); + + p_delete(&tmpminor); + + debug_print (5, ("parse_attach_list: added %s/%s [%d]\n", + a->major, a->minor, a->major_int)); + + listp = p_new(LIST, 1); + listp->data = (char *)a; + listp->next = NULL; + if (lastp) { + lastp->next = listp; + } else { + *ldata = listp; + } + lastp = listp; + } + while (MoreArgs (s)); + + _attachments_clean(); + return 0; +} + +static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata, + BUFFER *err __attribute__ ((unused))) { + ATTACH_MATCH *a; + LIST *lp, *lastp, *newlp; + char *tmp; + int major; + char *minor; + + do { + mutt_extract_token (buf, s, 0); + + if (!m_strcasecmp(buf->data, "any")) + tmp = m_strdup("*/.*"); + else if (!m_strcasecmp(buf->data, "none")) + tmp = m_strdup("cheap_hack/this_should_never_match"); + else + tmp = m_strdup(buf->data); + + if ((minor = strchr(tmp, '/'))) { + *minor = '\0'; + ++minor; + } else { + minor = m_strdup("unknown"); + } + major = mutt_check_mime_type(tmp); + + /* We must do our own walk here because remove_from_list() will only + * remove the LIST->data, not anything pointed to by the LIST->data. */ + lastp = NULL; + for(lp = *ldata; lp; ) { + a = (ATTACH_MATCH *)lp->data; + debug_print(5, ("parse_unattach_list: check %s/%s [%d] : %s/%s [%d]\n", + a->major, a->minor, a->major_int, tmp, minor, major)); + if (a->major_int == major && !m_strcasecmp(minor, a->minor)) { + debug_print(5, ("parse_unattach_list: removed %s/%s [%d]\n", + a->major, a->minor, a->major_int)); + regfree(&a->minor_rx); + p_delete(&a->major); + + /* Relink backward */ + if (lastp) + lastp->next = lp->next; + else + *ldata = lp->next; + + newlp = lp->next; + p_delete(&lp->data); /* same as a */ + p_delete(&lp); + lp = newlp; + continue; + } + + lastp = lp; + lp = lp->next; + } + } + while (MoreArgs (s)); + + p_delete(&tmp); + _attachments_clean(); + return 0; +} + +static int print_attach_list (LIST *lp, char op, const char *name) { + while (lp) { + printf("attachments %c%s %s/%s\n", op, name, + ((ATTACH_MATCH *)lp->data)->major, + ((ATTACH_MATCH *)lp->data)->minor); + lp = lp->next; + } + + return 0; +} + +static int parse_attachments (BUFFER *buf, BUFFER *s, + unsigned long data __attribute__ ((unused)), + BUFFER *err) { + char op, *category; + LIST **listp; + + mutt_extract_token(buf, s, 0); + if (!buf->data || *buf->data == '\0') { + m_strcpy(err->data, err->dsize, _("attachments: no disposition")); + return -1; + } + + category = buf->data; + op = *category++; + + if (op == '?') { + mutt_endwin (NULL); + fflush (stdout); + printf("\nCurrent attachments settings:\n\n"); + print_attach_list(AttachAllow, '+', "A"); + print_attach_list(AttachExclude, '-', "A"); + print_attach_list(InlineAllow, '+', "I"); + print_attach_list(InlineExclude, '-', "I"); + set_option (OPTFORCEREDRAWINDEX); + set_option (OPTFORCEREDRAWPAGER); + mutt_any_key_to_continue (NULL); + return 0; + } + + if (op != '+' && op != '-') { + op = '+'; + category--; + } + if (!m_strncasecmp(category, "attachment", strlen(category))) { + if (op == '+') + listp = &AttachAllow; + else + listp = &AttachExclude; + } + else if (!m_strncasecmp(category, "inline", strlen(category))) { + if (op == '+') + listp = &InlineAllow; + else + listp = &InlineExclude; + } else { + m_strcpy(err->data, err->dsize, _("attachments: invalid disposition")); + return -1; + } + + return parse_attach_list(buf, s, listp, err); +} + +static int parse_unattachments (BUFFER *buf, BUFFER *s, unsigned long data __attribute__ ((unused)), BUFFER *err) { + char op, *p; + LIST **listp; + + mutt_extract_token(buf, s, 0); + if (!buf->data || *buf->data == '\0') { + m_strcpy(err->data, err->dsize, _("unattachments: no disposition")); + return -1; + } + + p = buf->data; + op = *p++; + if (op != '+' && op != '-') { + op = '+'; + p--; + } + if (!m_strncasecmp(p, "attachment", strlen(p))) { + if (op == '+') + listp = &AttachAllow; + else + listp = &AttachExclude; + } + else if (!m_strncasecmp(p, "inline", strlen(p))) { + if (op == '+') + listp = &InlineAllow; + else + listp = &InlineExclude; + } + else { + m_strcpy(err->data, err->dsize, _("unattachments: invalid disposition")); + return -1; + } + + return parse_unattach_list(buf, s, listp, err); +} + +static int parse_unlists (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - do - { + do { mutt_extract_token (buf, s, 0); 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) + + if (m_strcmp(buf->data, "*") && + add_to_rx_list (&UnMailLists, buf->data, REG_ICASE, err) != 0) return -1; } while (MoreArgs (s)); @@ -859,10 +1342,10 @@ static int parse_unlists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *er 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 __attribute__ ((unused)), + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&UnMailLists, buf->data); remove_from_rx_list (&UnSubscribedLists, buf->data); @@ -877,138 +1360,129 @@ static int parse_subscribe (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER * return 0; } -static int parse_unsubscribe (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unsubscribe (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - do - { + 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) + + if (m_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) + +static int parse_unalias (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { 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 (m_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 (m_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 __attribute__ ((unused)), + BUFFER * err) { ALIAS *tmp = Aliases; ALIAS *last = NULL; char *estr = NULL; - - if (!MoreArgs (s)) - { - strfcpy (err->data, _("alias: no address"), err->dsize); + + if (!MoreArgs (s)) { + m_strcpy(err->data, err->dsize, _("alias: no address")); return (-1); } mutt_extract_token (buf, s, 0); - dprint (2, (debugfile, "parse_alias: First token is '%s'.\n", - buf->data)); + debug_print (2, ("first token is '%s'.\n", buf->data)); /* check to see if an alias with this name already exists */ - for (; tmp; tmp = tmp->next) - { - if (!mutt_strcasecmp (tmp->name, buf->data)) + for (; tmp; tmp = tmp->next) { + if (!m_strcasecmp(tmp->name, buf->data)) break; last = tmp; } - if (!tmp) - { + if (!tmp) { /* create a new alias */ - tmp = (ALIAS *) safe_calloc (1, sizeof (ALIAS)); + tmp = p_new(ALIAS, 1); tmp->self = tmp; - tmp->name = safe_strdup (buf->data); + tmp->name = m_strdup(buf->data); /* give the main addressbook code a chance */ if (CurrentMenu == MENU_ALIAS) set_option (OPTMENUCALLER); } - else - { + else { /* override the previous value */ - rfc822_free_address (&tmp->addr); + address_delete (&tmp->addr); if (CurrentMenu == MENU_ALIAS) set_option (OPTFORCEREDRAWINDEX); } - 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)); + mutt_extract_token (buf, s, + M_TOKEN_QUOTE | M_TOKEN_SPACE | M_TOKEN_SEMICOLON); + debug_print (2, ("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 (DebugLevel >= 2) { + address_t *a; + + /* A group is terminated with an empty address, so check a->mailbox */ + for (a = tmp->addr; a && a->mailbox; a = a->next) { if (!a->group) - dprint (2, (debugfile, "parse_alias: %s\n", - a->mailbox)); + debug_print (2, ("%s\n", a->mailbox)); else - dprint (2, (debugfile, "parse_alias: Group %s\n", - a->mailbox)); + debug_print (2, ("group %s\n", a->mailbox)); } } #endif @@ -1016,45 +1490,43 @@ static int parse_alias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) } static int -parse_unmy_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +parse_unmy_hdr (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { 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) + if (m_strcmp("*", buf->data) == 0) mutt_free_list (&UserHeader); - else - { + else { tmp = UserHeader; last = NULL; - l = mutt_strlen (buf->data); + l = m_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; + } } } } @@ -1062,232 +1534,337 @@ 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 __attribute__ ((unused)), + 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 != ':') - { - strfcpy (err->data, _("invalid header field"), err->dsize); + if ((p = strpbrk (buf->data, ": \t")) == NULL || *p != ':') { + m_strcpy(err->data, err->dsize, _("invalid header field")); 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 */ + p_delete(&tmp->data); + tmp->data = buf->data; + p_clear(buf, 1); + return 0; } if (!tmp->next) - break; + break; } tmp->next = mutt_new_list (); tmp = tmp->next; } - else - { + else { tmp = mutt_new_list (); UserHeader = tmp; } tmp->data = buf->data; - memset (buf, 0, sizeof (BUFFER)); + p_clear(buf, 1); return 0; } static int -parse_sort (short *val, const char *s, const struct mapping_t *map, BUFFER *err) -{ +parse_sort (struct option_t* dst, const char *s, const struct mapping_t *map, + char* errbuf, size_t errlen) { int i, flags = 0; - if (mutt_strncmp ("reverse-", s, 8) == 0) - { + if (m_strncmp("reverse-", s, 8) == 0) { s += 8; flags = SORT_REVERSE; } - - if (mutt_strncmp ("last-", s, 5) == 0) - { + + if (m_strncmp("last-", s, 5) == 0) { s += 5; flags |= SORT_LAST; } - if ((i = mutt_getvaluebyname (s, map)) == -1) - { - snprintf (err->data, err->dsize, _("%s: unknown sorting method"), s); + if ((i = mutt_getvaluebyname (s, map)) == -1) { + if (errbuf) + snprintf (errbuf, errlen, _("'%s' is invalid for $%s"), s, dst->option); return (-1); } - *val = i | flags; + *((short*) dst->data) = i | flags; + return 0; +} + +/* if additional data more == 1, we want to resolve synonyms */ +static void mutt_set_default(const char *name __attribute__ ((unused)), void* p, unsigned long more) +{ + char buf[LONG_STRING]; + struct option_t *ptr = p; + + if (DTYPE(ptr->type) == DT_SYN) { + if (!more) + return; + ptr = hash_find(ConfigOptions, (const char *)ptr->data); + } + if (!ptr || *ptr->init || !FuncTable[DTYPE (ptr->type)].opt_from_string) + return; + + mutt_option_value(ptr->option, buf, sizeof(buf)); + if (m_strlen(ptr->init) == 0 && buf && *buf) + ptr->init = m_strdup(buf); +} + +static struct option_t* add_option (const char* name, const char* init, + short type, short dodup) { + struct option_t* option = p_new(struct option_t, 1); + + debug_print (1, ("adding $%s\n", name)); + + option->option = m_strdup(name); + option->type = type; + if (init) + option->init = dodup ? m_strdup(init) : (char*) init; + return (option); +} + +/* creates new option_t* of type DT_USER for $user_ var */ +static struct option_t* add_user_option (const char* name) { + return (add_option (name, NULL, DT_USER, 1)); +} + +/* free()'s option_t* */ +static void del_option (void* p) { + struct option_t *ptr = (struct option_t*) p; + char* s = (char*) ptr->data; + debug_print (1, ("removing option '%s' from table\n", NONULL (ptr->option))); + p_delete(&ptr->option); + p_delete(&s); + p_delete(&ptr->init); + p_delete(&ptr); +} + +static int init_expand (char** dst, struct option_t* src) { + BUFFER token, in; + size_t len = 0; + + p_delete(dst); + + if (DTYPE(src->type) == DT_STR || + DTYPE(src->type) == DT_PATH) { + /* only expand for string as it's the only place where + * we want to expand vars right now */ + if (src->init && *src->init) { + p_clear(&token, 1); + p_clear(&in, 1); + len = m_strlen(src->init) + 2; + in.data = p_new(char, len + 1); + snprintf (in.data, len, "\"%s\"", src->init); + in.dptr = in.data; + in.dsize = len; + mutt_extract_token (&token, &in, 0); + if (token.data && *token.data) + *dst = m_strdup(token.data); + else + *dst = m_strdup(""); + p_delete(&in.data); + p_delete(&token.data); + } else + *dst = m_strdup(""); + } else + /* for non-string: take value as is */ + *dst = m_strdup(src->init); + return (1); +} + +/* if additional data more == 1, we want to resolve synonyms */ +static void mutt_restore_default (const char* name __attribute__ ((unused)), + void* p, unsigned long more) { + char errbuf[STRING]; + struct option_t* ptr = (struct option_t*) p; + char* init = NULL; + + if (DTYPE (ptr->type) == DT_SYN) { + if (!more) + return; + ptr = hash_find (ConfigOptions, (char*) ptr->data); + } + if (!ptr) + return; + if (FuncTable[DTYPE (ptr->type)].opt_from_string) { + init_expand (&init, ptr); + if (!FuncTable[DTYPE (ptr->type)].opt_from_string (ptr, init, errbuf, + sizeof(errbuf))) { + if (!option (OPTNOCURSES)) + mutt_endwin (NULL); + fprintf (stderr, _("Invalid default setting for $%s found: \"%s\".\n" + "Please report this error: \"%s\"\n"), + ptr->option, NONULL (init), errbuf); + exit (1); + } + p_delete(&init); + } + + if (ptr->flags & R_INDEX) + set_option (OPTFORCEREDRAWINDEX); + if (ptr->flags & R_PAGER) + set_option (OPTFORCEREDRAWPAGER); + if (ptr->flags & R_RESORT_SUB) + set_option (OPTSORTSUBTHREADS); + if (ptr->flags & R_RESORT) + set_option (OPTNEEDRESORT); + if (ptr->flags & R_RESORT_INIT) + set_option (OPTRESORTINIT); + if (ptr->flags & R_TREE) + set_option (OPTREDRAWTREE); +} - return 0; +/* check whether value for $dsn_return would be valid */ +static int check_dsn_return (const char* option __attribute__ ((unused)), unsigned long p, + char* errbuf, size_t errlen) { + char* val = (char*) p; + if (val && *val && m_strncmp(val, "hdrs", 4) != 0 && + m_strncmp(val, "full", 4) != 0) { + if (errbuf) + snprintf (errbuf, errlen, _("'%s' is invalid for $%s"), val, "dsn_return"); + return (0); + } + return (1); } -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: - { - REGEXP *pp = (REGEXP *) p->data; - if (!p->init && pp->pattern) - p->init = (unsigned long) safe_strdup (pp->pattern); +/* check whether value for $dsn_notify would be valid */ +static int check_dsn_notify (const char* option, unsigned long p, + char* errbuf, size_t errlen) { + list2_t* list = NULL; + size_t i = 0; + int rc = 1; + char* val = (char*) p; + + if (!val || !*val) + return (1); + list = list_from_str (val, ","); + if (list_empty (list)) + return (1); + + for (i = 0; i < list->length; i++) + if (m_strncmp(list->data[i], "never", 5) != 0 && + m_strncmp(list->data[i], "failure", 7) != 0 && + m_strncmp(list->data[i], "delay", 5) != 0 && + m_strncmp(list->data[i], "success", 7) != 0) { + if (errbuf) + snprintf (errbuf, errlen, _("'%s' is invalid for $%s"), + (char*) list->data[i], "dsn_notify"); + rc = 0; break; } + list_del (&list, (list_del_t*)xmemfree); + return (rc); +} + +static int check_num (const char* option, unsigned long p, + char* errbuf, size_t errlen) { + if ((int) p < 0) { + if (errbuf) + snprintf (errbuf, errlen, _("'%d' is invalid for $%s"), (int) p, option); + return (0); } + return (1); } -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); - } - 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)); - 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); - } - } - } - break; +#ifdef DEBUG +static int check_debug (const char* option, unsigned long p, + char* errbuf, size_t errlen) { + if ((int) p <= DEBUG_MAX_LEVEL && + (int) p >= DEBUG_MIN_LEVEL) + return (1); + + if (errbuf) + snprintf (errbuf, errlen, _("'%d' is invalid for $%s"), (int) p, option); + return (0); +} +#endif + +static int check_history (const char* option __attribute__ ((unused)), unsigned long p, + char* errbuf, size_t errlen) { + if (!check_num ("history", p, errbuf, errlen)) + return (0); + mutt_init_history (); + return (1); +} + +static int check_special (const char* name, unsigned long val, + char* errbuf, size_t errlen) { + int i = 0; + + for (i = 0; SpecialVars[i].name; i++) { + if (m_strcmp(SpecialVars[i].name, name) == 0) { + return (SpecialVars[i].check (SpecialVars[i].name, + val, errbuf, errlen)); + } } + return (1); +} - if (p->flags & R_INDEX) - set_option (OPTFORCEREDRAWINDEX); - if (p->flags & R_PAGER) - set_option (OPTFORCEREDRAWPAGER); - if (p->flags & R_RESORT_SUB) - set_option (OPTSORTSUBTHREADS); - if (p->flags & R_RESORT) - set_option (OPTNEEDRESORT); - if (p->flags & R_RESORT_INIT) - set_option (OPTRESORTINIT); - if (p->flags & R_TREE) - set_option (OPTREDRAWTREE); +static const struct mapping_t* get_sortmap (struct option_t* option) { + const struct mapping_t* map = NULL; + + switch (option->type & DT_SUBTYPE_MASK) { + case DT_SORT_ALIAS: + map = SortAliasMethods; + break; + case DT_SORT_BROWSER: + map = SortBrowserMethods; + break; + case DT_SORT_KEYS: + map = SortKeyMethods; + break; + case DT_SORT_AUX: + map = SortAuxMethods; + break; + default: + map = SortMethods; + break; + } + return (map); } -static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) +#define CHECK_PAGER \ + if ((CurrentMenu == MENU_PAGER) && \ + (!option || (option->flags & R_RESORT))) \ + { \ + snprintf (err->data, err->dsize, \ + _("Not available in this menu.")); \ + return (-1); \ + } + +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]; + int query, unset, inv, reset, r = 0; + struct option_t* option = NULL; - 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 (m_strncmp("no", s->dptr, 2) == 0) { s->dptr += 2; unset = !unset; } - else if (mutt_strncmp ("inv", s->dptr, 3) == 0) - { + else if (m_strncmp("inv", s->dptr, 3) == 0) { s->dptr += 3; inv = !inv; } - else if (*s->dptr == '&') - { + else if (*s->dptr == '&') { reset = 1; s->dptr++; } @@ -1295,406 +1872,208 @@ static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) /* get the variable name */ mutt_extract_token (tmp, s, M_TOKEN_EQUAL); - if ((idx = mutt_option_index (tmp->data)) == -1 && - !(reset && !mutt_strcmp ("all", tmp->data))) - { + /* resolve synonyms */ + if ((option = hash_find (ConfigOptions, tmp->data)) != NULL && + DTYPE (option->type == DT_SYN)) { + struct option_t* newopt = hash_find (ConfigOptions, (char*) option->data); + syn_add (newopt, option); + option = newopt; + } + + /* see if we need to add $user_ var */ + if (!option && ascii_strncmp ("user_", tmp->data, 5) == 0) { + /* there's no option named like this yet so only add one + * if the action isn't any of: reset, unset, query */ + if (!(reset || unset || query || *s->dptr != '=')) { + debug_print (1, ("adding user option '%s'\n", tmp->data)); + option = add_user_option (tmp->data); + hash_insert (ConfigOptions, option->option, option, 0); + } + } + + if (!option && !(reset && m_strcmp("all", tmp->data) == 0)) { 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); - } + s->dptr = vskipspaces(s->dptr); - 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; - } - 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); - } + if (reset) { + if (query || unset || inv) { + snprintf (err->data, err->dsize, _("prefix is illegal with reset")); + return (-1); } - if (query) - { - snprintf (err->data, err->dsize, option (MuttVars[idx].data) - ? _("%s is set") : _("%s is unset"), tmp->data); - return 0; + if (s && *s->dptr == '=') { + snprintf (err->data, err->dsize, _("value is illegal with reset")); + return (-1); } - if (unset) - unset_option (MuttVars[idx].data); - else if (inv) - toggle_option (MuttVars[idx].data); - else - 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 ((void *)MuttVars[idx].data); + if (!m_strcmp("all", tmp->data)) { + if (CurrentMenu == MENU_PAGER) { + snprintf (err->data, err->dsize, _("Not available in this menu.")); + return (-1); + } + hash_map (ConfigOptions, mutt_restore_default, 1); + set_option (OPTFORCEREDRAWINDEX); + set_option (OPTFORCEREDRAWPAGER); + set_option (OPTSORTSUBTHREADS); + set_option (OPTNEEDRESORT); + set_option (OPTRESORTINIT); + set_option (OPTREDRAWTREE); + return (0); } - 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 (!FuncTable[DTYPE (option->type)].opt_from_string) { + snprintf (err->data, err->dsize, _("$%s is read-only"), option->option); + r = -1; + break; + } else { + CHECK_PAGER; + mutt_restore_default (NULL, option, 1); } - else - { - s->dptr++; - - /* copy the value of the string */ - if (DTYPE (MuttVars[idx].type) == DT_ADDR) - rfc822_free_address ((ADDRESS **) MuttVars[idx].data); - else - FREE ((void *)MuttVars[idx].data); + } + else if (DTYPE (option->type) == DT_BOOL) { + /* XXX this currently ignores the function table + * as we don't get invert and stuff into it */ + 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 (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); + 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); } - 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; - 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 (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; + if (query) { + bool_to_string (err->data, err->dsize, option); + return 0; } - - 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; - - /* $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; - } - } -#undef CUR_ENV - } - } + CHECK_PAGER; + if (unset) + unset_option (option->data); + else if (inv) + toggle_option (option->data); + else + set_option (option->data); } - 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 (option->type) == DT_STR || + DTYPE (option->type) == DT_PATH || + DTYPE (option->type) == DT_ADDR || + DTYPE (option->type) == DT_MAGIC || + DTYPE (option->type) == DT_NUM || + DTYPE (option->type) == DT_SORT || + DTYPE (option->type) == DT_RX || + DTYPE (option->type) == DT_USER || + DTYPE (option->type) == DT_SYS) { + + /* XXX maybe we need to get unset into handlers? */ + if (DTYPE (option->type) == DT_STR || + DTYPE (option->type) == DT_PATH || + DTYPE (option->type) == DT_ADDR || + DTYPE (option->type) == DT_USER || + DTYPE (option->type) == DT_SYS) { + if (unset) { + CHECK_PAGER; + if (!FuncTable[DTYPE (option->type)].opt_from_string) { + snprintf (err->data, err->dsize, _("$%s is read-only"), + option->option); + r = -1; + break; + } else if (DTYPE (option->type) == DT_ADDR) + address_delete ((address_t **) option->data); + else if (DTYPE (option->type) == DT_USER) + /* to unset $user_ means remove */ + hash_delete (ConfigOptions, option->option, + option, del_option); + else + p_delete((void **)&option->data); + 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; - } - } - 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 != '=') { + FuncTable[DTYPE (option->type)].opt_to_string + (err->data, err->dsize, option); + break; } - s->dptr++; - - 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; - } - else - *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 (); - } - else if (mutt_strcmp (MuttVars[idx].option, "pager_index_lines") == 0) - { - if (*ptr < 0) - *ptr = 0; + /* the $muttng_ variables are read-only */ + if (!FuncTable[DTYPE (option->type)].opt_from_string) { + snprintf (err->data, err->dsize, _("$%s is read-only"), + option->option); + r = -1; + break; + } else { + CHECK_PAGER; + s->dptr++; + mutt_extract_token (tmp, s, 0); + if (!FuncTable[DTYPE (option->type)].opt_from_string + (option, tmp->data, err->data, err->dsize)) + r = -1; } } - 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; - } + else if (DTYPE (option->type) == DT_QUAD) { - 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 (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; + if (query) { + quad_to_string (err->data, err->dsize, option); + 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 (*s->dptr == '=') { + CHECK_PAGER; + s->dptr++; + mutt_extract_token (tmp, s, 0); + if (ascii_strcasecmp ("yes", tmp->data) == 0) + set_quadoption (option->data, M_YES); + else if (ascii_strcasecmp ("no", tmp->data) == 0) + set_quadoption (option->data, M_NO); + else if (ascii_strcasecmp ("ask-yes", tmp->data) == 0) + set_quadoption (option->data, M_ASKYES); + else if (ascii_strcasecmp ("ask-no", tmp->data) == 0) + set_quadoption (option->data, M_ASKNO); + else { + snprintf (err->data, err->dsize, _("'%s' is invalid for $%s\n"), + tmp->data, option->option); + r = -1; + break; + } } - s->dptr++; - mutt_extract_token (tmp, s , 0); - - if (parse_sort ((short *) MuttVars[idx].data, tmp->data, map, err) == -1) - { - r = -1; - break; + else { + if (inv) + toggle_quadoption (option->data); + else if (unset) + set_quadoption (option->data, M_NO); + else + set_quadoption (option->data, M_YES); } } - else - { - snprintf (err->data, err->dsize, _("%s: unknown type"), MuttVars[idx].option); + else { + snprintf (err->data, err->dsize, _("%s: unknown type"), + option->option); r = -1; break; } - if (MuttVars[idx].flags & R_INDEX) + if (option->flags & R_INDEX) set_option (OPTFORCEREDRAWINDEX); - if (MuttVars[idx].flags & R_PAGER) + if (option->flags & R_PAGER) set_option (OPTFORCEREDRAWPAGER); - if (MuttVars[idx].flags & R_RESORT_SUB) + if (option->flags & R_RESORT_SUB) set_option (OPTSORTSUBTHREADS); - if (MuttVars[idx].flags & R_RESORT) + if (option->flags & R_RESORT) set_option (OPTNEEDRESORT); - if (MuttVars[idx].flags & R_RESORT_INIT) + if (option->flags & R_RESORT_INIT) set_option (OPTRESORTINIT); - if (MuttVars[idx].flags & R_TREE) + if (option->flags & R_TREE) set_option (OPTREDRAWTREE); } return (r); @@ -1704,7 +2083,7 @@ 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, conv = 0; @@ -1714,55 +2093,54 @@ static int source_rc (const char *rcfile, BUFFER *err) size_t buflen; pid_t pid; - dprint (2, (debugfile, "Reading configuration file '%s'.\n", - rcfile)); - - if ((f = mutt_open_read (rcfile, &pid)) == NULL) - { + debug_print (2, ("reading configuration file '%s'.\n", rcfile)); + + 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) - { - 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) - { + p_clear(&token, 1); + while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) { + conv = ConfigCharset && (*ConfigCharset) && Charset; + if (conv) { + currentline = m_strdup(linebuf); + if (!currentline) + continue; + mutt_convert_string (¤tline, ConfigCharset, Charset, 0); + } + else + currentline = linebuf; + + CurRCLine = line; + CurRCFile = rcfile; + + 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 (conv) FREE(¤tline); + if (--rc < -MAXERRS) { + if (conv) + p_delete(¤tline); break; } } - else - { + else { if (rc < 0) rc = -1; } if (conv) - FREE(¤tline); + p_delete(¤tline); } - FREE (&token.data); - FREE (&linebuf); + p_delete(&token.data); + p_delete(&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); @@ -1770,21 +2148,21 @@ 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 __attribute__ ((unused)), + 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); } - strfcpy (path, tmp->data, sizeof (path)); - mutt_expand_path (path, sizeof (path)); + m_strcpy(path, sizeof(path), tmp->data); + mutt_expand_path (path, sizeof(path)); rc += source_rc (path, err); } @@ -1803,60 +2181,58 @@ 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; - memset (&expn, 0, sizeof (expn)); + p_clear(&expn, 1); expn.data = expn.dptr = line; - expn.dsize = mutt_strlen (line); + expn.dsize = m_strlen(line); *err->data = 0; - SKIPWS (expn.dptr); - while (*expn.dptr) - { + debug_print (1, ("expand '%s'\n", line)); + + expn.dptr = vskipspaces(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 (!m_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; } } r = 0; finish: if (expn.destroy) - FREE (&expn.data); + p_delete(&expn.data); return (r); } -#define NUMVARS (sizeof (MuttVars)/sizeof (MuttVars[0])) -#define NUMCOMMANDS (sizeof (Commands)/sizeof (Commands[0])) -/* initial string that starts completion. No telling how much crap +#define NUMVARS (sizeof(MuttVars)/sizeof(MuttVars[0])) +#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) */ +const 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. @@ -1865,17 +2241,15 @@ char *Matches[MAX(NUMVARS,NUMCOMMANDS) + 1]; /* all the matches + User_typed */ try == user entered data for completion. len == length of dest buffer. */ -static void candidate (char *dest, char *try, char *src, int len) +static void candidate (char *dest, char *try, const 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 - { + m_strcpy(dest, len, src); + else { for (l = 0; src[l] && src[l] == dest[l]; l++); dest[l] = 0; } @@ -1886,85 +2260,80 @@ 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); + buffer = vskipspaces(buffer); spaces = buffer - pt; pt = buffer + pos - spaces; 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)); + m_strcpy(User_typed, sizeof(User_typed), pt); + p_clear(Matches, sizeof(Matches)); + p_clear(Completed, 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 */ - char *prefixes[] = { "no", "inv", "?", "&", 0 }; - + m_strcpy(buffer, len - spaces, Completed); + } + else if (!m_strncmp(buffer, "set", 3) + || !m_strncmp(buffer, "unset", 5) + || !m_strncmp(buffer, "reset", 5) + || !m_strncmp(buffer, "toggle", 6)) { /* complete variables */ + const char *prefixes[] = { "no", "inv", "?", "&", NULL }; + 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 (!m_strncmp(buffer, "set", 3)) { + for (num = 0; prefixes[num]; num++) { + if (!m_strncmp(pt, prefixes[num], m_strlen(prefixes[num]))) { + pt += m_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)); + m_strcpy(User_typed, sizeof(User_typed), pt); + p_clear(Matches, sizeof(Matches)); + p_clear(Completed, 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]) @@ -1973,44 +2342,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); + m_strcpy(pt, buffer + len - pt - spaces, Completed); } - else if (!mutt_strncmp (buffer, "exec", 4)) - { + else if (!m_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)); + m_strcpy(User_typed, sizeof(User_typed), pt); + p_clear(Matches, sizeof(Matches)); + p_clear(Completed, 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]) @@ -2019,13 +2386,13 @@ 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); + m_strcpy(pt, buffer + len - pt - spaces, Completed); } else return 0; @@ -2037,98 +2404,108 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) { char var[STRING], *pt = buffer; int spaces; - + struct option_t* option = NULL; + if (buffer[0] == 0) return 0; - SKIPWS (buffer); + buffer = vskipspaces(buffer); spaces = buffer - pt; 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) - { - int idx; - strfcpy (var, pt, sizeof (var)); + if (m_strncmp(buffer, "set", 3) == 0) { + m_strcpy(var, sizeof(var), pt); /* 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]; + var[m_strlen(var) - 1] = 0; + if (!(option = hash_find (ConfigOptions, var))) + 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" }; + const 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 (option->type) == DT_STR) || + (DTYPE (option->type) == DT_PATH) || + (DTYPE (option->type) == DT_RX)) { + m_strcpy(tmp, sizeof(tmp), NONULL(*((char **)option->data))); + if (DTYPE (option->type) == DT_PATH) + mutt_pretty_mailbox (tmp); + } + else if (DTYPE (option->type) == DT_ADDR) { + rfc822_write_address (tmp, sizeof(tmp), + *((address_t **) option->data), 0); } - else if (DTYPE (MuttVars[idx].type) == DT_ADDR) - { - rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) MuttVars[idx].data), 0); + else if (DTYPE (option->type) == DT_QUAD) + m_strcpy(tmp, sizeof(tmp), vals[quadoption(option->data)]); + else if (DTYPE (option->type) == DT_NUM) + snprintf (tmp, sizeof(tmp), "%d", (*((short *) option->data))); + else if (DTYPE (option->type) == DT_SORT) { + const struct mapping_t *map; + const char *p; + + switch (option->type & DT_SUBTYPE_MASK) { + case DT_SORT_ALIAS: + map = SortAliasMethods; + break; + case DT_SORT_BROWSER: + map = SortBrowserMethods; + break; + case DT_SORT_KEYS: + map = SortKeyMethods; + break; + default: + map = SortMethods; + break; + } + p = mutt_getnamebyvalue(*((short *) option->data) & SORT_MASK, map); + snprintf(tmp, sizeof(tmp), "%s%s%s", + (*((short *)option->data) & SORT_REVERSE) ? "reverse-" : "", + (*((short *)option->data) & SORT_LAST) ? "last-" : "", p); } - else if (DTYPE (MuttVars[idx].type) == DT_QUAD) - 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); + else if (DTYPE (option->type) == DT_MAGIC) { + const char *p; + 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"; + } + m_strcpy(tmp, sizeof(tmp), p); } - else if (DTYPE (MuttVars[idx].type) == DT_BOOL) - strfcpy (tmp, option (MuttVars[idx].data) ? "yes" : "no", sizeof (tmp)); + else if (DTYPE (option->type) == DT_BOOL) + m_strcpy(tmp, sizeof(tmp), option(option->data) ? "yes" : "no"); 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) < ssizeof(tmp2) - 2;) { + if (*s == '\\' || *s == '"') + *d++ = '\\'; + *d++ = *s++; } *d = '\0'; - - strfcpy (tmp, pt, sizeof (tmp)); + + m_strcpy(tmp, sizeof(tmp), pt); snprintf (pt, dlen, "%s\"%s\"", tmp, tmp2); - + return 1; } } @@ -2136,371 +2513,316 @@ 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)); - + + p_clear(&err, 1); + p_clear(&token, 1); + err.data = errbuff; - err.dsize = sizeof (errbuff); - - 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) - { + err.dsize = sizeof(errbuff); + + 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) { fprintf (stderr, "%s\n", err.data); - FREE (&token.data); + p_delete(&token.data); return 1; } printf ("%s\n", err.data); } - - FREE (&token.data); - return 0; -} - -char *mutt_getnamebyvalue (int val, const struct mapping_t *map) -{ - int i; - - for (i=0; map[i].name; i++) - if (map[i].value == val) - return (map[i].name); - return NULL; -} - -int mutt_getvaluebyname (const char *name, const struct mapping_t *map) -{ - int i; - - for (i = 0; map[i].name; i++) - if (ascii_strcasecmp (map[i].name, name) == 0) - return (map[i].value); - return (-1); -} - -#ifdef DEBUG -static void start_debug (void) -{ - time_t t; - int i; - char buf[_POSIX_PATH_MAX]; - 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); - rename (buf, buf2); - } - if ((debugfile = safe_fopen(buf, "w")) != NULL) - { - t = time (0); - 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); - } + p_delete(&token.data); + return 0; } -#endif -static int mutt_execute_commands (LIST *p) +static int mutt_execute_commands (LIST * p) { BUFFER err, token; char errstr[SHORT_STRING]; - memset (&err, 0, sizeof (err)); + p_clear(&err, 1); 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) - { + err.dsize = sizeof(errstr); + p_clear(&token, 1); + 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); + p_delete(&token.data); return (-1); } } - FREE (&token.data); + p_delete(&token.data); 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; - char *p, buffer[STRING], error[STRING]; - int i, default_rc = 0, need_pause = 0; + const char *p; + char buffer[STRING], error[STRING]; + int default_rc = 0, need_pause = 0; + unsigned int i; BUFFER err; - memset (&err, 0, sizeof (err)); + p_clear(&err, 1); err.data = error; - err.dsize = sizeof (error); + err.dsize = sizeof(error); + + /* use 3*sizeof(muttvars) instead of 2*sizeof() + * to have some room for $user_ vars */ + ConfigOptions = hash_create (sizeof(MuttVars) * 3); + for (i = 0; MuttVars[i].option; i++) { + if (DTYPE (MuttVars[i].type) != DT_SYS) + hash_insert (ConfigOptions, MuttVars[i].option, &MuttVars[i], 0); + else + hash_insert (ConfigOptions, MuttVars[i].option, + add_option (MuttVars[i].option, MuttVars[i].init, + DT_SYS, 0), 0); + } - /* + /* * XXX - use something even more difficult to predict? */ - snprintf (AttachmentMarker, sizeof (AttachmentMarker), - "\033]9;%ld\a", (long) time (NULL)); - + snprintf (AttachmentMarker, sizeof(AttachmentMarker), + "\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); + Homedir = m_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); + Username = m_strdup(pw->pw_name); if (!Homedir) - Homedir = safe_strdup (pw->pw_dir); + Homedir = m_strdup(pw->pw_dir); - Realname = safe_strdup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw)); - Shell = safe_strdup (pw->pw_shell); + Realname = m_strdup(mutt_gecos_name (rnbuf, sizeof(rnbuf), pw)); + Shell = m_strdup(pw->pw_shell); + endpwent (); } - 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 - { + Username = m_strdup(p); + else { mutt_endwin (NULL); fputs (_("unable to determine username"), stderr); exit (1); } - Shell = safe_strdup ((p = getenv ("SHELL")) ? p : "/bin/sh"); + Shell = m_strdup((p = getenv ("SHELL")) ? p : "/bin/sh"); } -#ifdef DEBUG - /* Start up debugging mode if requested */ - if (debuglevel > 0) - start_debug (); -#endif + debug_start(Homedir); /* And about the host... */ uname (&utsname); /* some systems report the FQDN instead of just the hostname */ - if ((p = strchr (utsname.nodename, '.'))) - { - Hostname = mutt_substrdup (utsname.nodename, p); + if ((p = strchr (utsname.nodename, '.'))) { + Hostname = p_dupstr(utsname.nodename, p - utsname.nodename); p++; - strfcpy (buffer, p, sizeof (buffer)); /* save the domain for below */ + m_strcpy(buffer, sizeof(buffer), p); /* save the domain for below */ } else - Hostname = safe_strdup (utsname.nodename); + Hostname = m_strdup(utsname.nodename); -#ifndef DOMAIN -#define DOMAIN buffer - if (!p && getdnsdomainname (buffer, sizeof (buffer)) == -1) - Fqdn = safe_strdup ("@"); + if (!p && getdnsdomainname (buffer, sizeof(buffer)) == -1) + Fqdn = m_strdup("@"); else -#endif /* DOMAIN */ - if (*DOMAIN != '@') - { - Fqdn = safe_malloc (mutt_strlen (DOMAIN) + mutt_strlen (Hostname) + 2); - sprintf (Fqdn, "%s.%s", NONULL(Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */ + if (*buffer != '@') { + Fqdn = p_new(char, m_strlen(buffer) + m_strlen(Hostname) + 2); + sprintf (Fqdn, "%s.%s", NONULL(Hostname), buffer); /* __SPRINTF_CHECKED__ */ } else - Fqdn = safe_strdup(NONULL(Hostname)); + Fqdn = m_strdup(NONULL (Hostname)); #ifdef USE_NNTP { FILE *f; - char *i; + char *q; - if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) - { + if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) { buffer[0] = '\0'; - fgets (buffer, sizeof (buffer), f); - p = &buffer; - SKIPWS (p); - i = p; - while (*i && (*i != ' ') && (*i != '\t') && (*i != '\r') && (*i != '\n')) i++; - *i = '\0'; - NewsServer = safe_strdup (p); + fgets (buffer, sizeof(buffer), f); + p = vskipspaces(buffer); + q = (char*)p; + while (*q && !isspace(*q)) + q++; + *q = '\0'; + NewsServer = m_strdup(p); fclose (f); } } if ((p = getenv ("NNTPSERVER"))) - NewsServer = safe_strdup (p); + NewsServer = m_strdup(p); #endif if ((p = getenv ("MAIL"))) - Spoolfile = safe_strdup (p); + Spoolfile = m_strdup(p); else if ((p = getenv ("MAILDIR"))) - Spoolfile = safe_strdup (p); - else - { + Spoolfile = m_strdup(p); + else { #ifdef HOMESPOOL - mutt_concat_path (buffer, NONULL (Homedir), MAILPATH, sizeof (buffer)); + mutt_concat_path(buffer, sizeof(buffer), NONULL(Homedir), MAILPATH); #else - mutt_concat_path (buffer, MAILPATH, NONULL(Username), sizeof (buffer)); + mutt_concat_path(buffer, sizeof(buffer), MAILPATH, NONULL(Username)); #endif - Spoolfile = safe_strdup (buffer); + Spoolfile = m_strdup(buffer); } if ((p = getenv ("MAILCAPS"))) - MailcapPath = safe_strdup (p); - else - { + MailcapPath = m_strdup(p); + else { /* Default search path from RFC1524 */ - MailcapPath = safe_strdup ("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"); + MailcapPath = + m_strdup("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR + "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"); } - Tempdir = safe_strdup ((p = getenv ("TMPDIR")) ? p : "/tmp"); + Tempdir = m_strdup((p = getenv ("TMPDIR")) ? p : "/tmp"); p = getenv ("VISUAL"); - if (!p) - { + if (!p) { p = getenv ("EDITOR"); if (!p) p = "vi"; } - Editor = safe_strdup (p); - Visual = safe_strdup (p); + Editor = m_strdup(p); + Visual = m_strdup(p); - if ((p = getenv ("REPLYTO")) != NULL) - { + if ((p = getenv ("REPLYTO")) != NULL) { BUFFER buf, token; - snprintf (buffer, sizeof (buffer), "Reply-To: %s", p); + snprintf (buffer, sizeof(buffer), "Reply-To: %s", p); - memset (&buf, 0, sizeof (buf)); + p_clear(&buf, 1); buf.data = buf.dptr = buffer; - buf.dsize = mutt_strlen (buffer); + buf.dsize = m_strlen(buffer); - memset (&token, 0, sizeof (token)); + p_clear(&token, 1); parse_my_hdr (&token, &buf, 0, &err); - FREE (&token.data); + p_delete(&token.data); } 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++) - { - mutt_set_default (&MuttVars[i]); - mutt_restore_default (&MuttVars[i]); - } + hash_map (ConfigOptions, mutt_set_default, 0); + hash_map (ConfigOptions, mutt_restore_default, 0); CurrentMenu = MENU_MAIN; - -#ifndef LOCALES_HACK /* Do we have a locale definition? */ if (((p = getenv ("LC_ALL")) != NULL && p[0]) || ((p = getenv ("LANG")) != NULL && p[0]) || ((p = getenv ("LC_CTYPE")) != NULL && p[0])) set_option (OPTLOCALES); -#endif #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) { +#if 0 + snprintf (buffer, sizeof(buffer), "%s/.muttngrc-%s", NONULL (Homedir), + MUTT_VERSION); + if (access (buffer, F_OK) == -1) +#endif + snprintf (buffer, sizeof(buffer), "%s/.muttngrc", NONULL (Homedir)); + if (access (buffer, F_OK) == -1) +#if 0 + snprintf (buffer, sizeof(buffer), "%s/.muttng/muttngrc-%s", + NONULL (Homedir), MUTT_VERSION); + if (access (buffer, F_OK) == -1) +#endif + snprintf (buffer, sizeof(buffer), "%s/.muttng/muttngrc", + NONULL (Homedir)); + default_rc = 1; - Muttrc = safe_strdup (buffer); + Muttrc = m_strdup(buffer); } - else - { - strfcpy (buffer, Muttrc, sizeof (buffer)); - FREE (&Muttrc); - mutt_expand_path (buffer, sizeof (buffer)); - Muttrc = safe_strdup (buffer); + else { + m_strcpy(buffer, sizeof(buffer), Muttrc); + p_delete(&Muttrc); + mutt_expand_path (buffer, sizeof(buffer)); + Muttrc = m_strdup(buffer); } - FREE (&AliasFile); - AliasFile = safe_strdup (NONULL(Muttrc)); + p_delete(&AliasFile); + AliasFile = m_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); 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; + 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; } } } /* 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) - { + mutt_endwin (NULL); + 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)); + snprintf (buffer, sizeof(buffer), "%s: %s", Muttrc, strerror (errno)); mutt_endwin (buffer); exit (1); } @@ -2508,14 +2830,33 @@ void mutt_init (int skip_sys_rc, LIST *commands) if (mutt_execute_commands (commands) != 0) need_pause = 1; - if (need_pause && !option (OPTNOCURSES)) - { + /* warn about synonym variables */ + if (!list_empty(Synonyms)) { + i = 0; + fprintf (stderr, _("Warning: the following synonym variables were found:\n")); + for (i = 0; i < Synonyms->length; i++) { + struct option_t* newopt = NULL, *oldopt = NULL; + newopt = (struct option_t*) ((syn_t*) Synonyms->data[i])->n; + oldopt = (struct option_t*) ((syn_t*) Synonyms->data[i])->o; + fprintf (stderr, "$%s ($%s should be used) (%s:%d)\n", + oldopt ? NONULL (oldopt->option) : "", + newopt ? NONULL (newopt->option) : "", + NONULL(((syn_t*) Synonyms->data[i])->f), + ((syn_t*) Synonyms->data[i])->l); + } + fprintf (stderr, _("Warning: synonym variables are scheduled" + " for removal.\n")); + list_del (&Synonyms, syn_del); + need_pause = 1; + } + + 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 } @@ -2523,8 +2864,67 @@ 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; } + +/* compare two option_t*'s for sorting -t/-T output */ +static int opt_cmp (const void* a, const void* b) { + return (m_strcmp((*(struct option_t**) a)->option, + (*(struct option_t**) b)->option)); +} + +/* callback for hash_map() to put all non-synonym vars into list */ +static void opt_sel_full (const char* key __attribute__ ((unused)), + void* data, + unsigned long more) { + list2_t** l = (list2_t**) more; + struct option_t* option = (struct option_t*) data; + + if (DTYPE (option->type) == DT_SYN) + return; + list_push_back (l, option); +} + +/* callback for hash_map() to put all changed non-synonym vars into list */ +static void opt_sel_diff (const char* key __attribute__ ((unused)), + void* data, + unsigned long more) { + list2_t** l = (list2_t**) more; + struct option_t* option = (struct option_t*) data; + char buf[LONG_STRING]; + + if (DTYPE (option->type) == DT_SYN) + return; + + mutt_option_value (option->option, buf, sizeof(buf)); + if (m_strcmp(buf, option->init) != 0) + list_push_back (l, option); +} + +/* dump out the value of all the variables we have */ +int mutt_dump_variables (int full) { + size_t i = 0; + char outbuf[STRING]; + list2_t* tmp = NULL; + struct option_t* option = NULL; + + /* get all non-synonyms into list... */ + hash_map (ConfigOptions, full ? opt_sel_full : opt_sel_diff, + (unsigned long) &tmp); + + if (!list_empty(tmp)) { + /* ...and dump list sorted */ + qsort (tmp->data, tmp->length, sizeof(void*), opt_cmp); + for (i = 0; i < tmp->length; i++) { + option = (struct option_t*) tmp->data[i]; + FuncTable[DTYPE (option->type)].opt_to_string + (outbuf, sizeof(outbuf), option); + printf ("%s\n", outbuf); + } + } + list_del (&tmp, NULL); + return 0; +}