X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=c96e35095b7b9971aee7202e21d69e60051099f8;hp=3e34dc8a7f5b371e1709e9469af546f2df585dd1;hb=91d0c04349c9345f0ee29a61cc18dfc144b60edc;hpb=364bf52ada05bf7d7158dba9d2391f63b71258f6 diff --git a/init.c b/init.c index 3e34dc8..c96e350 100644 --- a/init.c +++ b/init.c @@ -2,6 +2,9 @@ * Copyright notice from original mutt: * Copyright (C) 1996-2002 Michael R. Elkins * + * 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. @@ -11,15 +14,21 @@ # include "config.h" #endif +#include +#include +#include +#include +#include +#include +#include + #include "mutt.h" -#include "buffer.h" -#include "ascii.h" -#include "mapping.h" #include "mutt_curses.h" #include "history.h" #include "keymap.h" #include "mbyte.h" #include "charset.h" +#include "thread.h" #include "mutt_crypt.h" #include "mutt_idna.h" @@ -34,9 +43,6 @@ #include "mx.h" #include "init.h" -#include "lib/mem.h" -#include "lib/intl.h" -#include "lib/str.h" #include "lib/rx.h" #include "lib/list.h" #include "lib/debug.h" @@ -49,42 +55,518 @@ #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 */ - int n; /* new name (index) */ - int o; /* old name (index) */ + 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 */ -list2_t* Synonyms; +static list2_t* Synonyms; /* for synonym warning reports: current rc file */ -char* CurRCFile = NULL; +static const char* CurRCFile = NULL; /* for synonym warning reports: current rc line */ -int CurRCLine = 0; +static int CurRCLine = 0; /* prototypes for checking for special vars */ -static int check_dsn_return (const char*); -static int check_dsn_notify (const char*); +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*); + int (*check) (const char* option, unsigned long val, + char* errbuf, size_t errlen); } SpecialVars[] = { - { "dsn_notify", check_dsn_notify }, - { "dsn_return", check_dsn_return }, + { "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 }, + { "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, size_t errlen) { + 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) { + + size_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 = CurrentFolder; + + } else + val = 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, size_t errlen) { + 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)); + str_replace ((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); + + str_replace ((char**) dst->data, val); + return (1); +} + +static int user_from_string (struct option_t* dst, const char* val, + char* errbuf, size_t errlen) { + /* 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; + str_replace (&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, size_t errlen) { + 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); + } + + str_replace (&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, size_t errlen) { + 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**) 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, size_t errlen) { + if (!dst) + return (0); + rfc822_free_address ((ADDRESS**) dst->data); + if (val && *val) + *((ADDRESS**) 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 (int n, int o) { - syn_t* tmp = mem_malloc (sizeof (syn_t)); - tmp->f = str_dup (CurRCFile); +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; @@ -93,8 +575,8 @@ static void syn_add (int n, int o) { /* for synonym warning reports: free single item (for list_del()) */ static void syn_del (void** p) { - mem_free(&(*(syn_t**) p)->f); - mem_free(p); + p_delete(&(*(syn_t**) p)->f); + p_delete(p); } void toggle_quadoption (int opt) @@ -140,22 +622,6 @@ int query_quadoption (int opt, const char *prompt) /* 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 (str_cmp (s, MuttVars[i].option) == 0) { - if (MuttVars[i].type == DT_SYN) - syn_add (mutt_option_index ((char *) MuttVars[i].data), i); - return (MuttVars[i].type == - DT_SYN ? mutt_option_index ((char *) MuttVars[i].data) : i); - } - return (-1); -} - static void add_to_list (LIST ** list, const char *str) { LIST *t, *last = NULL; @@ -176,8 +642,8 @@ static void add_to_list (LIST ** list, const char *str) } if (!*list || last) { - t = (LIST *) mem_calloc (1, sizeof (LIST)); - t->data = str_dup (str); + t = p_new(LIST, 1); + t->data = m_strdup(str); if (last) { last->next = t; last = last->next; @@ -235,7 +701,7 @@ static int add_to_spam_list (SPAM_LIST ** list, const char *pat, * the template, and leaving t pointed at the current item. */ t = last; - mem_free(t->template); + p_delete(&t->template); break; } if (!last->next) @@ -255,7 +721,7 @@ static int add_to_spam_list (SPAM_LIST ** list, const char *pat, } /* Now t is the SPAM_LIST* that we want to modify. It is prepared. */ - t->template = str_dup (templ); + t->template = m_strdup(templ); /* Find highest match number in template string */ t->nmatch = 0; @@ -284,21 +750,21 @@ static int remove_from_spam_list (SPAM_LIST ** list, const char *pat) spam = *list; if (!spam) return 0; - if (spam->rx && !str_cmp (spam->rx->pattern, pat)) { + if (spam->rx && !m_strcmp(spam->rx->pattern, pat)) { *list = spam->next; rx_free (&spam->rx); - mem_free(&spam->template); - mem_free(&spam); + p_delete(&spam->template); + p_delete(&spam); return 1; } prev = spam; for (spam = prev->next; spam;) { - if (!str_cmp (spam->rx->pattern, pat)) { + if (!m_strcmp(spam->rx->pattern, pat)) { prev->next = spam->next; rx_free (&spam->rx); - mem_free(spam->template); - mem_free(spam); + p_delete(&spam->template); + p_delete(&spam); spam = prev->next; ++nremoved; } @@ -314,19 +780,19 @@ static void remove_from_list (LIST ** l, const char *str) { LIST *p, *last = NULL; - if (str_cmp ("*", str) == 0) + 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) { - mem_free (&p->data); + p_delete(&p->data); if (last) last->next = p->next; else (*l) = p->next; - mem_free (&p); + p_delete(&p); } else { last = p; @@ -340,7 +806,7 @@ static int remove_from_rx_list (list2_t** l, const char *str) { int i = 0; - if (str_cmp ("*", str) == 0) { + if (m_strcmp("*", str) == 0) { list_del (l, (list_del_t*) rx_free); return (0); } @@ -360,12 +826,15 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data, { int i, j, 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))) + 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); @@ -373,30 +842,24 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data, continue; for (j = 0; b[j].name; j++) - if (!ascii_strncasecmp (tmp->data, b[j].name, str_len (tmp->data)) - && (str_len (b[j].name) == str_len (tmp->data))) { + if (!ascii_strncasecmp (tmp->data, b[j].name, m_strlen(tmp->data)) + && (m_strlen(b[j].name) == m_strlen(tmp->data))) { res = 1; break; } } + } /* check for feature_* */ - if (!res) { - char *p = NULL; - + if (!res && ascii_strncasecmp (tmp->data, "feature_", 8) == 0 && + (j = m_strlen(tmp->data)) > 8) { i = 0; - j = str_len (tmp->data); - /* need at least input of 'feature_X' */ - if (j >= 7) { - p = tmp->data + 7; - j -= 7; - while (Features[i].name) { - if (str_len (Features[i].name) == j && - ascii_strncasecmp (Features[i].name, p, j)) { - res = 1; - break; - } - i++; + while (Features[i]) { + if (m_strlen(Features[i]) == j-8 && + ascii_strncasecmp (Features[i], tmp->data+8, j-8) == 0) { + res = 1; + break; } + i++; } } @@ -407,15 +870,16 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data, 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 (data == res) { if (mutt_parse_rc_line (tmp->data, &token, err) == -1) { mutt_error ("Error: %s", err->data); - mem_free (&token.data); + p_delete(&token.data); return (-1); } - mem_free (&token.data); + p_delete(&token.data); } return 0; } @@ -496,7 +960,7 @@ static int parse_unalternates (BUFFER * buf, BUFFER * s, unsigned long data, mutt_extract_token (buf, s, 0); remove_from_rx_list (&Alternates, buf->data); - if (str_cmp (buf->data, "*") && + if (m_strcmp(buf->data, "*") && add_to_rx_list (&UnAlternates, buf->data, REG_ICASE, err) != 0) return -1; @@ -511,14 +975,14 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data, { BUFFER templ; - memset (&templ, 0, sizeof (templ)); + p_clear(&templ, 1); /* Insist on at least one parameter */ 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; } @@ -533,10 +997,10 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data, /* Add to the spam list. */ if (add_to_spam_list (&SpamList, buf->data, templ.data, err) != 0) { - mem_free (&templ.data); + p_delete(&templ.data); return -1; } - mem_free (&templ.data); + p_delete(&templ.data); } /* If not, try to remove from the nospam list. */ @@ -552,7 +1016,7 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data, /* nospam only ever has one parameter. */ /* "*" is a special case. */ - if (!str_cmp (buf->data, "*")) { + if (!m_strcmp(buf->data, "*")) { mutt_free_spam_list (&SpamList); list_del (&NoSpamList, (list_del_t*) rx_free); return 0; @@ -570,7 +1034,7 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data, } /* 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; } @@ -582,7 +1046,7 @@ static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data, /* * Check for deletion of entire list */ - if (str_cmp (buf->data, "*") == 0) { + if (m_strcmp(buf->data, "*") == 0) { mutt_free_list ((LIST **) data); break; } @@ -608,6 +1072,247 @@ static int parse_lists (BUFFER * buf, BUFFER * s, unsigned long data, return 0; } +/* 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) { + 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) { + 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 = "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, 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, 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, BUFFER * err) { @@ -616,7 +1321,7 @@ static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data, remove_from_rx_list (&SubscribedLists, buf->data); remove_from_rx_list (&MailLists, buf->data); - if (str_cmp (buf->data, "*") && + if (m_strcmp(buf->data, "*") && add_to_rx_list (&UnMailLists, buf->data, REG_ICASE, err) != 0) return -1; } @@ -650,7 +1355,7 @@ static int parse_unsubscribe (BUFFER * buf, BUFFER * s, unsigned long data, mutt_extract_token (buf, s, 0); remove_from_rx_list (&SubscribedLists, buf->data); - if (str_cmp (buf->data, "*") && + if (m_strcmp(buf->data, "*") && add_to_rx_list (&UnSubscribedLists, buf->data, REG_ICASE, err) != 0) return -1; } @@ -667,7 +1372,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data, do { mutt_extract_token (buf, s, 0); - if (str_cmp ("*", buf->data) == 0) { + if (m_strcmp("*", buf->data) == 0) { if (CurrentMenu == MENU_ALIAS) { for (tmp = Aliases; tmp; tmp = tmp->next) tmp->del = 1; @@ -679,7 +1384,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data, } else for (tmp = Aliases; tmp; tmp = tmp->next) { - if (str_casecmp (buf->data, tmp->name) == 0) { + if (m_strcasecmp(buf->data, tmp->name) == 0) { if (CurrentMenu == MENU_ALIAS) { tmp->del = 1; set_option (OPTFORCEREDRAWINDEX); @@ -709,7 +1414,7 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data, char *estr = NULL; if (!MoreArgs (s)) { - strfcpy (err->data, _("alias: no address"), err->dsize); + m_strcpy(err->data, err->dsize, _("alias: no address")); return (-1); } @@ -719,16 +1424,16 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data, /* check to see if an alias with this name already exists */ for (; tmp; tmp = tmp->next) { - if (!str_casecmp (tmp->name, buf->data)) + if (!m_strcasecmp(tmp->name, buf->data)) break; last = tmp; } if (!tmp) { /* create a new alias */ - tmp = (ALIAS *) mem_calloc (1, sizeof (ALIAS)); + tmp = p_new(ALIAS, 1); tmp->self = tmp; - tmp->name = str_dup (buf->data); + tmp->name = m_strdup(buf->data); /* give the main addressbook code a chance */ if (CurrentMenu == MENU_ALIAS) set_option (OPTMENUCALLER); @@ -757,7 +1462,8 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data, if (DebugLevel >= 2) { ADDRESS *a; - for (a = tmp->addr; a; a = a->next) { + /* 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) debug_print (2, ("%s\n", a->mailbox)); else @@ -778,13 +1484,13 @@ parse_unmy_hdr (BUFFER * buf, BUFFER * s, unsigned long data, BUFFER * err) do { mutt_extract_token (buf, s, 0); - if (str_cmp ("*", buf->data) == 0) + if (m_strcmp("*", buf->data) == 0) mutt_free_list (&UserHeader); else { tmp = UserHeader; last = NULL; - l = str_len (buf->data); + l = m_strlen(buf->data); if (buf->data[l - 1] == ':') l--; @@ -820,7 +1526,7 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data, 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); + m_strcpy(err->data, err->dsize, _("invalid header field")); return (-1); } keylen = p - buf->data + 1; @@ -830,9 +1536,9 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data, /* see if there is already a field by this name */ if (ascii_strncasecmp (buf->data, tmp->data, keylen) == 0) { /* replace the old value */ - mem_free (&tmp->data); + p_delete(&tmp->data); tmp->data = buf->data; - memset (buf, 0, sizeof (BUFFER)); + p_clear(buf, 1); return 0; } if (!tmp->next) @@ -846,169 +1552,177 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data, 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 (str_ncmp ("reverse-", s, 8) == 0) { + if (m_strncmp("reverse-", s, 8) == 0) { s += 8; flags = SORT_REVERSE; } - if (str_ncmp ("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 (errbuf) + snprintf (errbuf, errlen, _("'%s' is invalid for $%s"), s, dst->option); return (-1); } - *val = i | flags; - + *((short*) dst->data) = i | flags; return 0; } -static void mutt_set_default (struct option_t *p) +/* if additional data more == 1, we want to resolve synonyms */ +static void mutt_set_default(const char *name, void* p, unsigned long more) { - switch (p->type & DT_MASK) { - case DT_STR: - if (!p->init && *((char **) p->data)) - p->init = (unsigned long) str_dup (*((char **) p->data)); - break; - case DT_PATH: - if (!p->init && *((char **) p->data)) { - char *cp = str_dup (*((char **) p->data)); + char buf[LONG_STRING]; + struct option_t *ptr = p; - /* mutt_pretty_mailbox (cp); */ - p->init = (unsigned long) cp; + if (DTYPE(ptr->type) == DT_SYN) { + if (!more) + return; + ptr = hash_find(ConfigOptions, (const char *)ptr->data); } - break; - case DT_ADDR: - if (!p->init && *((ADDRESS **) p->data)) { - char tmp[HUGE_STRING]; + if (!ptr || *ptr->init || !FuncTable[DTYPE (ptr->type)].opt_from_string) + return; - *tmp = '\0'; - rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) p->data), 0); - p->init = (unsigned long) str_dup (tmp); - } - break; - case DT_RX: - { - rx_t* pp = (rx_t*) p->data; + mutt_option_value(ptr->option, buf, sizeof(buf)); + if (m_strlen(ptr->init) == 0 && buf && *buf) + ptr->init = m_strdup(buf); +} - if (!p->init && pp->pattern) - p->init = (unsigned long) str_dup (pp->pattern); - break; - } - } +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); } -static void mutt_restore_default (struct option_t *p) -{ - switch (p->type & DT_MASK) { - case DT_STR: - if (p->init) - str_replace ((char **) p->data, (char *) p->init); - break; - case DT_PATH: - if (p->init) { - char path[_POSIX_PATH_MAX]; +/* 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)); +} - strfcpy (path, (char *) p->init, sizeof (path)); - mutt_expand_path (path, sizeof (path)); - str_replace ((char **) p->data, path); - } - break; - case DT_ADDR: - if (p->init) { - rfc822_free_address ((ADDRESS **) p->data); - *((ADDRESS **) p->data) = rfc822_parse_adrlist (NULL, (char *) p->init); - } - break; - case DT_BOOL: - if (p->init) - set_option (p->data); - else - unset_option (p->data); - break; - case DT_QUAD: - set_quadoption (p->data, p->init); - break; - case DT_NUM: - case DT_SORT: - case DT_MAGIC: - *((short *) p->data) = p->init; - break; - case DT_RX: - { - rx_t *pp = (rx_t *) p->data; - int flags = 0; - - mem_free (&pp->pattern); - if (pp->rx) { - regfree (pp->rx); - mem_free (&pp->rx); - } +/* 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 (p->init) { - char *s = (char *) p->init; +/* if additional data more == 1, we want to resolve synonyms */ +static void mutt_restore_default (const char* name, void* p, + unsigned long more) { + char errbuf[STRING]; + struct option_t* ptr = (struct option_t*) p; + char* init = NULL; - pp->rx = mem_calloc (1, sizeof (regex_t)); - if (str_cmp (p->option, "mask") != 0) - flags |= mutt_which_case ((const char *) p->init); - if (str_cmp (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); - mem_free (&pp->pattern); - regfree (pp->rx); - mem_free (&pp->rx); - } - else - str_replace (&pp->pattern, (char *) p->init); - } + 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); } - break; + p_delete(&init); } - if (p->flags & R_INDEX) + if (ptr->flags & R_INDEX) set_option (OPTFORCEREDRAWINDEX); - if (p->flags & R_PAGER) + if (ptr->flags & R_PAGER) set_option (OPTFORCEREDRAWPAGER); - if (p->flags & R_RESORT_SUB) + if (ptr->flags & R_RESORT_SUB) set_option (OPTSORTSUBTHREADS); - if (p->flags & R_RESORT) + if (ptr->flags & R_RESORT) set_option (OPTNEEDRESORT); - if (p->flags & R_RESORT_INIT) + if (ptr->flags & R_RESORT_INIT) set_option (OPTRESORTINIT); - if (p->flags & R_TREE) + if (ptr->flags & R_TREE) set_option (OPTREDRAWTREE); } /* check whether value for $dsn_return would be valid */ -static int check_dsn_return (const char* val) { - if (val && *val && str_ncmp (val, "hdrs", 4) != 0 && - str_ncmp (val, "full", 4) != 0) +static int check_dsn_return (const char* option, 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); } /* check whether value for $dsn_notify would be valid */ -static int check_dsn_notify (const char* val) { +static int check_dsn_notify (const char* option, unsigned long p, + char* errbuf, size_t errlen) { list2_t* list = NULL; int i = 0, rc = 1; + char* val = (char*) p; if (!val || !*val) return (1); @@ -1017,32 +1731,102 @@ static int check_dsn_notify (const char* val) { return (1); for (i = 0; i < list->length; i++) - if (str_ncmp (list->data[i], "never", 5) != 0 && - str_ncmp (list->data[i], "failure", 7) != 0 && - str_ncmp (list->data[i], "delay", 5) != 0 && - str_ncmp (list->data[i], "success", 7) != 0) { + 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*) _mem_free); + list_del (&list, (list_del_t*)xmemfree); return (rc); } -static int check_special (const char* name, const char* val) { +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); +} + +#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, 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 (str_cmp (SpecialVars[i].name, name) == 0) - return (SpecialVars[i].check (val)); + if (m_strcmp(SpecialVars[i].name, name) == 0) { + return (SpecialVars[i].check (SpecialVars[i].name, + val, errbuf, errlen)); + } } return (1); } +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: + if ((WithCrypto & APPLICATION_PGP)) + map = SortKeyMethods; + break; + case DT_SORT_AUX: + map = SortAuxMethods; + break; + default: + map = SortMethods; + break; + } + return (map); +} + +#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)) { /* reset state variables */ @@ -1055,11 +1839,11 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data, query = 1; s->dptr++; } - else if (str_ncmp ("no", s->dptr, 2) == 0) { + else if (m_strncmp("no", s->dptr, 2) == 0) { s->dptr += 2; unset = !unset; } - else if (str_ncmp ("inv", s->dptr, 3) == 0) { + else if (m_strncmp("inv", s->dptr, 3) == 0) { s->dptr += 3; inv = !inv; } @@ -1071,12 +1855,30 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data, /* get the variable name */ mutt_extract_token (tmp, s, M_TOKEN_EQUAL); - if ((idx = mutt_option_index (tmp->data)) == -1 && - !(reset && !str_cmp ("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); + s->dptr = vskipspaces(s->dptr); if (reset) { if (query || unset || inv) { @@ -1089,15 +1891,32 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data, return (-1); } - if (!str_cmp ("all", tmp->data)) { - for (idx = 0; MuttVars[idx].option; idx++) - mutt_restore_default (&MuttVars[idx]); - return 0; + 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 (!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 - mutt_restore_default (&MuttVars[idx]); } - else if (DTYPE (MuttVars[idx].type) == DT_BOOL) { + 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"); @@ -1117,330 +1936,127 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data, } if (query) { - snprintf (err->data, err->dsize, option (MuttVars[idx].data) - ? _("%s is set") : _("%s is unset"), tmp->data); + bool_to_string (err->data, err->dsize, option); return 0; } + CHECK_PAGER; if (unset) - unset_option (MuttVars[idx].data); + unset_option (option->data); else if (inv) - toggle_option (MuttVars[idx].data); + toggle_option (option->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 - mem_free ((void *) MuttVars[idx].data); - } - else if (query || *s->dptr != '=') { - char _tmp[STRING]; - char *val = NULL; - - if (DTYPE (MuttVars[idx].type) == DT_ADDR) { - _tmp[0] = '\0'; - rfc822_write_address (_tmp, sizeof (_tmp), - *((ADDRESS **) MuttVars[idx].data), 0); - val = _tmp; - } - else - val = *((char **) MuttVars[idx].data); - - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, - NONULL (val)); - break; - } - else { - s->dptr++; - - /* copy the value of the string */ - if (DTYPE (MuttVars[idx].type) == DT_ADDR) - rfc822_free_address ((ADDRESS **) MuttVars[idx].data); - else - mem_free ((void *) MuttVars[idx].data); - - mutt_extract_token (tmp, s, 0); - if (DTYPE (MuttVars[idx].type) == DT_PATH) { - strfcpy (scratch, tmp->data, sizeof (scratch)); - mutt_expand_path (scratch, sizeof (scratch)); - *((char **) MuttVars[idx].data) = str_dup (scratch); - } - else if (DTYPE (MuttVars[idx].type) == DT_STR) { - /* see if the value may only be a certain value... */ - if (check_special (MuttVars[idx].option, tmp->data)) { - *((char **) MuttVars[idx].data) = str_dup (tmp->data); - if (str_cmp (MuttVars[idx].option, "charset") == 0) - mutt_set_charset (Charset); - } else { - /* ... and abort if it fails */ - snprintf (err->data, err->dsize, "'%s' is invalid for $%s", - tmp->data, MuttVars[idx].option); - return (-1); - } - } - else { - *((ADDRESS **) MuttVars[idx].data) = - rfc822_parse_adrlist (NULL, tmp->data); - } - } - } - else if (DTYPE (MuttVars[idx].type) == DT_RX) { - rx_t *ptr = (rx_t *) MuttVars[idx].data; - regex_t *rx; - int e, flags = 0; - - if (query || *s->dptr != '=') { - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, - NONULL (ptr->pattern)); - break; - } - - if (option (OPTATTACHMSG) - && !str_cmp (MuttVars[idx].option, "reply_regexp")) { - snprintf (err->data, err->dsize, - "Operation not permitted when in attach-message mode."); - r = -1; - break; - } - - s->dptr++; - - /* copy the value of the string */ - mutt_extract_token (tmp, s, 0); - - if (!ptr->pattern || str_cmp (ptr->pattern, tmp->data) != 0) { - int not = 0; - - /* $mask is case-sensitive */ - if (str_cmp (MuttVars[idx].option, "mask") != 0) - flags |= mutt_which_case (tmp->data); - - p = tmp->data; - if (str_cmp (MuttVars[idx].option, "mask") == 0) { - if (*p == '!') { - not = 1; - p++; - } - } - - rx = (regex_t *) mem_malloc (sizeof (regex_t)); - if ((e = REGCOMP (rx, p, flags)) != 0) { - regerror (e, rx, err->data, err->dsize); - regfree (rx); - mem_free (&rx); - break; - } - - /* get here only if everything went smootly */ - if (ptr->pattern) { - mem_free (&ptr->pattern); - regfree ((regex_t *) ptr->rx); - mem_free (&ptr->rx); - } - - ptr->pattern = str_dup (tmp->data); - ptr->rx = rx; - ptr->not = not; - - /* $reply_regexp and $alterantes require special treatment */ - - if (Context && Context->msgcount && - str_cmp (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 - } - } + 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"; + 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) + rfc822_free_address ((ADDRESS **) 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; } - snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, p); - break; } - s->dptr++; - - /* copy the value of the string */ - mutt_extract_token (tmp, s, 0); - if (mx_set_magic (tmp->data)) { - snprintf (err->data, err->dsize, _("%s: invalid mailbox type"), - tmp->data); - r = -1; - break; - } - } - 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); + 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); + /* 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 - *ptr = (short) val; - - /* these ones need a sanity check */ - if (str_cmp (MuttVars[idx].option, "history") == 0) { - if (*ptr < 0) - *ptr = 0; - mutt_init_history (); - } - else if (str_cmp (MuttVars[idx].option, "pager_index_lines") == 0) { - if (*ptr < 0) - *ptr = 0; + } 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" }; + else if (DTYPE (option->type) == DT_QUAD) { - snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, - vals[quadoption (MuttVars[idx].data)]); + if (query) { + quad_to_string (err->data, err->dsize, option); break; } if (*s->dptr == '=') { + CHECK_PAGER; s->dptr++; mutt_extract_token (tmp, s, 0); if (ascii_strcasecmp ("yes", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_YES); + set_quadoption (option->data, M_YES); else if (ascii_strcasecmp ("no", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_NO); + set_quadoption (option->data, M_NO); else if (ascii_strcasecmp ("ask-yes", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_ASKYES); + set_quadoption (option->data, M_ASKYES); else if (ascii_strcasecmp ("ask-no", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_ASKNO); + set_quadoption (option->data, M_ASKNO); else { - snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); + snprintf (err->data, err->dsize, _("'%s' is invalid for $%s\n"), + tmp->data, option->option); r = -1; break; } } else { if (inv) - toggle_quadoption (MuttVars[idx].data); + toggle_quadoption (option->data); else if (unset) - set_quadoption (MuttVars[idx].data, M_NO); + set_quadoption (option->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 (!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; - } - s->dptr++; - mutt_extract_token (tmp, s, 0); - - if (parse_sort ((short *) MuttVars[idx].data, tmp->data, map, err) == - -1) { - r = -1; - break; + set_quadoption (option->data, M_YES); } } else { snprintf (err->data, err->dsize, _("%s: unknown type"), - MuttVars[idx].option); + 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); @@ -1461,20 +2077,17 @@ static int source_rc (const char *rcfile, BUFFER * err) pid_t pid; debug_print (2, ("reading configuration file '%s'.\n", rcfile)); - str_replace (&CurRCFile, rcfile); - CurRCLine = 0; 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)); + p_clear(&token, 1); while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) { - CurRCLine++; conv = ConfigCharset && (*ConfigCharset) && Charset; if (conv) { - currentline = str_dup (linebuf); + currentline = m_strdup(linebuf); if (!currentline) continue; mutt_convert_string (¤tline, ConfigCharset, Charset, 0); @@ -1482,11 +2095,14 @@ static int source_rc (const char *rcfile, BUFFER * err) 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) - mem_free (¤tline); + p_delete(¤tline); break; } } @@ -1495,10 +2111,10 @@ static int source_rc (const char *rcfile, BUFFER * err) rc = -1; } if (conv) - mem_free (¤tline); + p_delete(¤tline); } - mem_free (&token.data); - mem_free (&linebuf); + p_delete(&token.data); + p_delete(&linebuf); fclose (f); if (pid != -1) mutt_wait_filter (pid); @@ -1527,8 +2143,8 @@ static int parse_source (BUFFER * tmp, BUFFER * s, unsigned long data, 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); } @@ -1552,13 +2168,15 @@ 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 = str_len (line); + expn.dsize = m_strlen(line); *err->data = 0; - SKIPWS (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 */ @@ -1568,7 +2186,7 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err) } mutt_extract_token (token, &expn, 0); for (i = 0; Commands[i].name; i++) { - if (!str_cmp (token->data, Commands[i].name)) { + if (!m_strcmp(token->data, Commands[i].name)) { if (Commands[i].func (token, &expn, Commands[i].data, err) != 0) goto finish; break; @@ -1583,20 +2201,20 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err) r = 0; finish: if (expn.destroy) - mem_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 }; 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 */ +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. @@ -1605,14 +2223,14 @@ 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) { Matches[Num_matched++] = src; if (dest[0] == 0) - strfcpy (dest, src, len); + m_strcpy(dest, len, src); else { for (l = 0; src[l] && src[l] == dest[l]; l++); dest[l] = 0; @@ -1626,7 +2244,7 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) int num; 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; @@ -1637,12 +2255,12 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) /* first TAB. Collect all the matches */ 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)); + sizeof(Completed)); Matches[Num_matched++] = User_typed; /* All matches are stored. Longest non-ambiguous string is "" @@ -1657,27 +2275,27 @@ 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", + snprintf (Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % Num_matched]); /* return the completed command */ - strncpy (buffer, Completed, len - spaces); + m_strcpy(buffer, len - spaces, Completed); } - else if (!str_ncmp (buffer, "set", 3) - || !str_ncmp (buffer, "unset", 5) - || !str_ncmp (buffer, "reset", 5) - || !str_ncmp (buffer, "toggle", 6)) { /* complete variables */ - char *prefixes[] = { "no", "inv", "?", "&", 0 }; + 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 (!str_ncmp (buffer, "set", 3)) { + if (!m_strncmp(buffer, "set", 3)) { for (num = 0; prefixes[num]; num++) { - if (!str_ncmp (pt, prefixes[num], str_len (prefixes[num]))) { - pt += str_len (prefixes[num]); + if (!m_strncmp(pt, prefixes[num], m_strlen(prefixes[num]))) { + pt += m_strlen(prefixes[num]); break; } } @@ -1686,12 +2304,12 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) /* first TAB. Collect all the matches */ 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 "" @@ -1706,15 +2324,15 @@ 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", + 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 (!str_ncmp (buffer, "exec", 4)) { + else if (!m_strncmp(buffer, "exec", 4)) { struct binding_t *menu = km_get_table (CurrentMenu); if (!menu && CurrentMenu != MENU_PAGER) @@ -1724,17 +2342,17 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) /* first TAB. Collect all the matches */ 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)); + sizeof(Completed)); } Matches[Num_matched++] = User_typed; @@ -1750,13 +2368,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", + 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; @@ -1768,11 +2386,12 @@ 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; @@ -1782,42 +2401,40 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) if (*pt == '=') /* abort if no var before the '=' */ return 0; - if (str_ncmp (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[str_len (var) - 1] = 0; - if ((idx = mutt_option_index (var)) == -1) + 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) + 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 (MuttVars[idx].type) == DT_ADDR) { - rfc822_write_address (tmp, sizeof (tmp), - *((ADDRESS **) MuttVars[idx].data), 0); + else if (DTYPE (option->type) == DT_ADDR) { + rfc822_write_address (tmp, sizeof(tmp), + *((ADDRESS **) option->data), 0); } - 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) { + 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; - char *p; + const char *p; - switch (MuttVars[idx].type & DT_SUBTYPE_MASK) { + switch (option->type & DT_SUBTYPE_MASK) { case DT_SORT_ALIAS: map = SortAliasMethods; break; @@ -1834,17 +2451,13 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) map = SortMethods; break; } - p = - mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, - map); - snprintf (tmp, sizeof (tmp), "%s%s%s", - (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? - "reverse-" : "", - (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : - "", p); - } - else if (DTYPE (MuttVars[idx].type) == DT_MAGIC) { - char *p; + 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 (option->type) == DT_MAGIC) { + const char *p; switch (DefaultMagic) { case M_MBOX: p = "mbox"; @@ -1861,22 +2474,21 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) default: p = "unknown"; } - strfcpy (tmp, p, sizeof (tmp)); + 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;) { + for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof(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; @@ -1895,63 +2507,43 @@ int mutt_query_variables (LIST * queries) 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); + err.dsize = sizeof(errbuff); for (p = queries; p; p = p->next) { - snprintf (command, sizeof (command), "set ?%s\n", p->data); + snprintf (command, sizeof(command), "set ?%s\n", p->data); if (mutt_parse_rc_line (command, &token, &err) == -1) { fprintf (stderr, "%s\n", err.data); - mem_free (&token.data); + p_delete(&token.data); return 1; } printf ("%s\n", err.data); } - mem_free (&token.data); + p_delete(&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); -} - 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)); + 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); - mem_free (&token.data); + p_delete(&token.data); return (-1); } } - mem_free (&token.data); + p_delete(&token.data); return 0; } @@ -1959,35 +2551,49 @@ void mutt_init (int skip_sys_rc, LIST * commands) { struct passwd *pw; struct utsname utsname; - char *p, buffer[STRING], error[STRING]; + const char *p; + char buffer[STRING], error[STRING]; int i, default_rc = 0, need_pause = 0; 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), + 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 = str_dup (p); + Homedir = m_strdup(p); /* Get some information about the user */ if ((pw = getpwuid (getuid ()))) { char rnbuf[STRING]; - Username = str_dup (pw->pw_name); + Username = m_strdup(pw->pw_name); if (!Homedir) - Homedir = str_dup (pw->pw_dir); + Homedir = m_strdup(pw->pw_dir); - Realname = str_dup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw)); - Shell = str_dup (pw->pw_shell); + Realname = m_strdup(mutt_gecos_name (rnbuf, sizeof(rnbuf), pw)); + Shell = m_strdup(pw->pw_shell); + endpwent (); } else { if (!Homedir) { @@ -1996,13 +2602,13 @@ void mutt_init (int skip_sys_rc, LIST * commands) exit (1); } if ((p = getenv ("USER"))) - Username = str_dup (p); + Username = m_strdup(p); else { mutt_endwin (NULL); fputs (_("unable to determine username"), stderr); exit (1); } - Shell = str_dup ((p = getenv ("SHELL")) ? p : "/bin/sh"); + Shell = m_strdup((p = getenv ("SHELL")) ? p : "/bin/sh"); } debug_start(Homedir); @@ -2013,70 +2619,68 @@ void mutt_init (int skip_sys_rc, LIST * commands) if ((p = strchr (utsname.nodename, '.'))) { Hostname = str_substrdup (utsname.nodename, p); p++; - strfcpy (buffer, p, sizeof (buffer)); /* save the domain for below */ + m_strcpy(buffer, sizeof(buffer), p); /* save the domain for below */ } else - Hostname = str_dup (utsname.nodename); + Hostname = m_strdup(utsname.nodename); #ifndef DOMAIN #define DOMAIN buffer - if (!p && getdnsdomainname (buffer, sizeof (buffer)) == -1) - Fqdn = str_dup ("@"); + if (!p && getdnsdomainname (buffer, sizeof(buffer)) == -1) + Fqdn = m_strdup("@"); else #endif /* DOMAIN */ if (*DOMAIN != '@') { - Fqdn = mem_malloc (str_len (DOMAIN) + str_len (Hostname) + 2); + Fqdn = p_new(char, m_strlen(DOMAIN) + m_strlen(Hostname) + 2); sprintf (Fqdn, "%s.%s", NONULL (Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */ } else - Fqdn = str_dup (NONULL (Hostname)); + Fqdn = m_strdup(NONULL (Hostname)); #ifdef USE_NNTP { FILE *f; - char *i; + char *q; if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) { buffer[0] = '\0'; - fgets (buffer, sizeof (buffer), f); - p = (char*) &buffer; - SKIPWS (p); - i = p; - while (*i && (*i != ' ') && (*i != '\t') && (*i != '\r') - && (*i != '\n')) - i++; - *i = '\0'; - NewsServer = str_dup (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 = str_dup (p); + NewsServer = m_strdup(p); #endif if ((p = getenv ("MAIL"))) - Spoolfile = str_dup (p); + Spoolfile = m_strdup(p); else if ((p = getenv ("MAILDIR"))) - Spoolfile = str_dup (p); + 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 = str_dup (buffer); + Spoolfile = m_strdup(buffer); } if ((p = getenv ("MAILCAPS"))) - MailcapPath = str_dup (p); + MailcapPath = m_strdup(p); else { /* Default search path from RFC1524 */ MailcapPath = - str_dup ("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR + m_strdup("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"); } - Tempdir = str_dup ((p = getenv ("TMPDIR")) ? p : "/tmp"); + Tempdir = m_strdup((p = getenv ("TMPDIR")) ? p : "/tmp"); p = getenv ("VISUAL"); if (!p) { @@ -2084,21 +2688,21 @@ void mutt_init (int skip_sys_rc, LIST * commands) if (!p) p = "vi"; } - Editor = str_dup (p); - Visual = str_dup (p); + Editor = m_strdup(p); + Visual = m_strdup(p); 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 = str_len (buffer); + buf.dsize = m_strlen(buffer); - memset (&token, 0, sizeof (token)); + p_clear(&token, 1); parse_my_hdr (&token, &buf, 0, &err); - mem_free (&token.data); + p_delete(&token.data); } if ((p = getenv ("EMAIL")) != NULL) @@ -2109,10 +2713,8 @@ void mutt_init (int skip_sys_rc, LIST * commands) /* 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; @@ -2137,13 +2739,13 @@ void mutt_init (int skip_sys_rc, LIST * commands) /* - * + * * BIG FAT WARNING - * + * * When changing the code which looks for a configuration file, * please also change the corresponding code in muttbug.sh.in. - * - * + * + * */ @@ -2151,44 +2753,44 @@ void mutt_init (int skip_sys_rc, LIST * commands) if (!Muttrc) { #if 0 - snprintf (buffer, sizeof (buffer), "%s/.muttngrc-%s", NONULL (Homedir), + 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)); + snprintf (buffer, sizeof(buffer), "%s/.muttngrc", NONULL (Homedir)); if (access (buffer, F_OK) == -1) #if 0 - snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc-%s", + 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", + snprintf (buffer, sizeof(buffer), "%s/.muttng/muttngrc", NONULL (Homedir)); default_rc = 1; - Muttrc = str_dup (buffer); + Muttrc = m_strdup(buffer); } else { - strfcpy (buffer, Muttrc, sizeof (buffer)); - mem_free (&Muttrc); - mutt_expand_path (buffer, sizeof (buffer)); - Muttrc = str_dup (buffer); + m_strcpy(buffer, sizeof(buffer), Muttrc); + p_delete(&Muttrc); + mutt_expand_path (buffer, sizeof(buffer)); + Muttrc = m_strdup(buffer); } - mem_free (&AliasFile); - AliasFile = str_dup (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, + snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", SYSCONFDIR, MUTT_VERSION); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc", SYSCONFDIR); + snprintf (buffer, sizeof(buffer), "%s/Muttngrc", SYSCONFDIR); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", PKGDATADIR, + snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", PKGDATADIR, MUTT_VERSION); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc", PKGDATADIR); + snprintf (buffer, sizeof(buffer), "%s/Muttngrc", PKGDATADIR); if (access (buffer, F_OK) != -1) { if (source_rc (buffer, &err) != 0) { fputs (err.data, stderr); @@ -2201,7 +2803,7 @@ void mutt_init (int skip_sys_rc, LIST * commands) /* Read the user's initialization file. */ if (access (Muttrc, F_OK) != -1) { if (!option (OPTNOCURSES)) - endwin (); + mutt_endwin (NULL); if (source_rc (Muttrc, &err) != 0) { fputs (err.data, stderr); fputc ('\n', stderr); @@ -2210,7 +2812,7 @@ void mutt_init (int skip_sys_rc, LIST * commands) } 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); } @@ -2222,18 +2824,21 @@ void mutt_init (int skip_sys_rc, LIST * commands) if (!list_empty(Synonyms)) { int i = 0; fprintf (stderr, _("Warning: the following synonym variables were found:\n")); - for (i = 0; i < Synonyms->length; i++) + 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", - MuttVars[((syn_t*) Synonyms->data[i])->o].option, - MuttVars[((syn_t*) Synonyms->data[i])->n].option, + 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")); + } + fprintf (stderr, _("Warning: synonym variables are scheduled" + " for removal.\n")); list_del (&Synonyms, syn_del); need_pause = 1; } - /* this is not needed during runtime */ - mem_free(&CurRCFile); if (need_pause && !option (OPTNOCURSES)) { if (mutt_any_key_to_continue (NULL) == -1) @@ -2255,49 +2860,59 @@ int mutt_get_hook_type (const char *name) return 0; } +/* compare two option_t*'s for sorting -t/-T output */ static int opt_cmp (const void* a, const void* b) { - return (str_cmp ((*(struct option_t**) a)->option, + return (m_strcmp((*(struct option_t**) a)->option, (*(struct option_t**) b)->option)); } -/* dump out the value of all the variables we have */ -int mutt_dump_variables (void) { - int i; +/* callback for hash_map() to put all non-synonym vars into list */ +static void opt_sel_full (const char* key, void* data, + unsigned long more) { + list2_t** l = (list2_t**) more; + struct option_t* option = (struct option_t*) data; - char errbuff[STRING]; - char command[STRING]; - list2_t* tmp = NULL; + if (DTYPE (option->type) == DT_SYN) + return; + list_push_back (l, option); +} - BUFFER err, token; +/* callback for hash_map() to put all changed non-synonym vars into list */ +static void opt_sel_diff (const char* key, void* data, + unsigned long more) { + list2_t** l = (list2_t**) more; + struct option_t* option = (struct option_t*) data; + char buf[LONG_STRING]; - memset (&err, 0, sizeof (err)); - memset (&token, 0, sizeof (token)); + if (DTYPE (option->type) == DT_SYN) + return; - err.data = errbuff; - err.dsize = sizeof (errbuff); + 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) { + int i = 0; + char outbuf[STRING]; + list2_t* tmp = NULL; + struct option_t* option = NULL; /* get all non-synonyms into list... */ - for (i = 0; MuttVars[i].option; i++) { - if (MuttVars[i].type == DT_SYN) - continue; - list_push_back (&tmp, &MuttVars[i]); - } + 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); + qsort (tmp->data, tmp->length, sizeof(void*), opt_cmp); for (i = 0; i < tmp->length; i++) { - snprintf (command, sizeof (command), "set ?%s\n", - ((struct option_t*) tmp->data[i])->option); - if (mutt_parse_rc_line (command, &token, &err) == -1) { - fprintf (stderr, "%s\n", err.data); - mem_free (&token.data); - list_del (&tmp, NULL); - return 1; - } - printf("%s\n", err.data); + option = (struct option_t*) tmp->data[i]; + FuncTable[DTYPE (option->type)].opt_to_string + (outbuf, sizeof(outbuf), option); + printf ("%s\n", outbuf); } } - mem_free (&token.data); list_del (&tmp, NULL); return 0; }