X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=21bdd4f255773d36d7a38fa66c6f712797a8ac92;hp=523a10dae647df2bb30732d96fe2c1ecb5f3aa10;hb=f3cbb9f51357972f6e74244494236a41dc4d84cd;hpb=e83dbdbc6200a71981d06773869cd0492f81f16c diff --git a/init.c b/init.c index 523a10d..21bdd4f 100644 --- a/init.c +++ b/init.c @@ -2,211 +2,534 @@ * 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. */ -#if HAVE_CONFIG_H -# 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 "mutt_crypt.h" +#include "thread.h" +#include #include "mutt_idna.h" -#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 "alias.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" - -#include -#include -#include -#include -#include -#include -#include - /* * prototypes */ -static int mutt_option_index (char*); -static const struct mapping_t* get_sortmap (int idx); +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, ssize_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) */ +typedef struct syn_t { + struct syn_t *next; + char* f; /* file */ + int l; /* line */ + struct option_t* n; /* new */ + struct option_t* o; /* old */ } syn_t; +DO_INIT(syn_t, syn); +static void syn_wipe(syn_t *syn) { + p_delete(&syn->f); +} +DO_NEW(syn_t, syn); +DO_DELETE(syn_t, syn); +DO_SLIST(syn_t, syn, syn_delete); + /* for synonym warning reports: list of synonyms found */ -static list2_t* Synonyms; +static syn_t *Synonyms = NULL; /* 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*); -static int check_dsn_notify (const char*); - -/* variable <-> sanity check function mappings */ +static int check_dsn_return (const char* option, unsigned long val, + char* errbuf, ssize_t errlen); +static int check_dsn_notify (const char* option, unsigned long val, + char* errbuf, ssize_t errlen); +static int check_history (const char* option, unsigned long val, + char* errbuf, ssize_t errlen); +/* this checks that numbers are >= 0 */ +static int check_num (const char* option, unsigned long val, + char* errbuf, ssize_t errlen); + +/* use this to check only */ +static int check_special (const char* option, unsigned long val, + char* errbuf, ssize_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, ssize_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 }, /* last */ { NULL, NULL } }; -/* protos for config type handles */ -static void bool_to_string (char* dst, size_t dstlen, int idx); -static void num_to_string (char* dst, size_t dstlen, int idx); -static void str_to_string (char* dst, size_t dstlen, int idx); -static void quad_to_string (char* dst, size_t dstlen, int idx); -static void sort_to_string (char* dst, size_t dstlen, int idx); -static void rx_to_string (char* dst, size_t dstlen, int idx); -static void magic_to_string (char* dst, size_t dstlen, int idx); -static void syn_to_string (char* dst, size_t dstlen, int idx); -static void addr_to_string (char* dst, size_t dstlen, int idx); +/* protos for config type handles: convert value to string */ +static void bool_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void num_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void str_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void quad_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void sort_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void rx_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void magic_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void addr_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void user_to_string (char* dst, ssize_t dstlen, struct option_t* option); +static void sys_to_string (char* dst, ssize_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, ssize_t errlen); +static int num_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int str_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int path_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int quad_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int sort_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int rx_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int magic_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int addr_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); +static int user_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); static struct { unsigned short type; - void (*opt_to_string) (char* dst, size_t dstlen, int idx); + void (*opt_to_string) (char* dst, ssize_t dstlen, struct option_t* option); + int (*opt_from_string) (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen); } FuncTable[] = { - { 0, NULL }, /* there's no DT_ type with 0 */ - { DT_BOOL, bool_to_string }, - { DT_NUM, num_to_string }, - { DT_STR, str_to_string }, - { DT_PATH, str_to_string }, - { DT_QUAD, quad_to_string }, - { DT_SORT, sort_to_string }, - { DT_RX, rx_to_string }, - { DT_MAGIC, magic_to_string }, - { DT_SYN, syn_to_string }, - { DT_ADDR, addr_to_string } + { 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, int idx) { - snprintf (dst, dstlen, "%s=%s", MuttVars[idx].option, - MuttVars[idx].data ? "yes" : "no"); +static void bool_to_string (char* dst, ssize_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)), + ssize_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, int idx) { +static void num_to_string (char* dst, ssize_t dstlen, + struct option_t* option) { /* XXX puke */ - const char* fmt = (idx == mutt_option_index ("umask")) ? "%s=%04o" : "%s=%d"; - snprintf (dst, dstlen, fmt, MuttVars[idx].option, - *((short*) MuttVars[idx].data)); + const char* fmt = (m_strcmp(option->option, "umask") == 0) ? + "%s=%04o" : "%s=%d"; + snprintf (dst, dstlen, fmt, option->option, + *((short*) option->data)); } -static void str_to_string (char* dst, size_t dstlen, int idx) { - snprintf (dst, dstlen, "%s=\"%s\"", MuttVars[idx].option, - NONULL (*((char**) MuttVars[idx].data))); +static int num_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_t errlen) { + int num = 0, old = 0; + char* t = NULL; + + if (!dst) + return (0); + + num = strtol (val, &t, 0); + + if (m_strisempty(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, ssize_t dstlen, + struct option_t* option) { + snprintf (dst, dstlen, "%s=\"%s\"", option->option, + NONULL (*((char**) option->data))); +} + +static void user_to_string (char* dst, ssize_t dstlen, + struct option_t* option) { + snprintf (dst, dstlen, "%s=\"%s\"", option->option, + NONULL (((char*) option->data))); } -static void quad_to_string (char* dst, size_t dstlen, int idx) { - char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; - snprintf (dst, dstlen, "%s=%s", MuttVars[idx].option, - vals[quadoption (MuttVars[idx].data)]); +static void sys_to_string (char* dst, ssize_t dstlen, + struct option_t* option) { + char *val = NULL, *t = NULL; + int clean = 0; + + /* get some $madmutt_ values dynamically */ + if (m_strcmp("madmutt_pwd", option->option) == 0) { + val = p_new(char, _POSIX_PATH_MAX); + val = getcwd (val, _POSIX_PATH_MAX-1); + clean = 1; + } else if (m_strcmp("madmutt_folder_path", option->option) == 0 && + CurrentFolder && *CurrentFolder) { + val = CurrentFolder; + } else if (m_strcmp("madmutt_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[Maildirlength]!='/') + 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 void sort_to_string (char* dst, size_t dstlen, int idx) { - const struct mapping_t *map = get_sortmap (idx); - char* p = NULL; +static int path_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) { + char path[_POSIX_PATH_MAX]; + + if (!dst) + return (0); + + if (m_strisempty(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, ssize_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)), ssize_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, ssize_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)), ssize_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, ssize_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", MuttVars[idx].option); + snprintf (dst, sizeof(dst), "%s=unknown", option->option); return; } - p = mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, - map); + p = mutt_getnamebyvalue(*((short *)option->data) & SORT_MASK, map); - snprintf (dst, dstlen, "%s=%s%s%s", MuttVars[idx].option, - (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? + snprintf (dst, dstlen, "%s=%s%s%s", option->option, + (*((short *) option->data) & SORT_REVERSE) ? "reverse-" : "", - (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : + (*((short *) option->data) & SORT_LAST) ? "last-" : "", NONULL (p)); } -static void rx_to_string (char* dst, size_t dstlen, int idx) { - rx_t* p = (rx_t*) MuttVars[idx].data; - snprintf (dst, dstlen, "%s=\"%s\"", MuttVars[idx].option, +static int sort_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_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, ssize_t dstlen, + struct option_t* option) { + rx_t* p = (rx_t*) option->data; + snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (p->pattern)); } -static void magic_to_string (char* dst, size_t dstlen, int idx) { +static int rx_from_string (struct option_t* dst, const char* val, + char* errbuf, ssize_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 (m_strisempty(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, ssize_t dstlen, + struct option_t* option) { const char* s = NULL; - switch (MuttVars[idx].data) { + 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", MuttVars[idx].option, s); + snprintf (dst, dstlen, "%s=%s", option->option, s); } -static void syn_to_string (char* dst, size_t dstlen, int idx) { - int i = mutt_option_index ((char*) MuttVars[idx].data); - FuncTable[MuttVars[i].type].opt_to_string (dst, dstlen, i); +static int magic_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) { + int flag = -1; + + if (!dst || m_strisempty(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, int idx) { - char s[STRING]; +static void addr_to_string (char* dst, ssize_t dstlen, + struct option_t* option) { + char s[HUGE_STRING]; s[0] = '\0'; - rfc822_write_address (s, sizeof (s), *((ADDRESS**) MuttVars[idx].data), 0); - snprintf (dst, dstlen, "%s=\"%s\"", MuttVars[idx].option, NONULL (s)); + rfc822_write_address (s, sizeof(s), *((address_t**) option->data), 0); + snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s)); } -int mutt_option_value (const char* val, char* dst, size_t dstlen) { - int i = mutt_option_index ((char*) val); +static int addr_from_string (struct option_t* dst, const char* val, + char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) { + if (!dst) + return (0); + address_list_wipe((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, ssize_t dstlen) { + struct option_t* option = NULL; char* tmp = NULL, *t = NULL; - size_t l = 0; + ssize_t l = 0; - if (i < 0) { - debug_print (1, ("var '%s' not found, i = %d\n", val, i)); + if (!(option = hash_find (ConfigOptions, val))) { *dst = '\0'; return (0); } - tmp = mem_malloc (dstlen+1); - FuncTable[DTYPE (MuttVars[i].type)].opt_to_string (tmp, dstlen, i); + 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 = str_len (t); + l = m_strlen(t); if (l >= 2) { if (t[l-1] == '"' && *t == '"') { t[l-1] = '\0'; @@ -214,29 +537,12 @@ int mutt_option_value (const char* val, char* dst, size_t dstlen) { } } memcpy (dst, t, l+1); - mem_free (&tmp); - debug_print (1, ("stripped == '%s'\n", dst)); + p_delete(&tmp); 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); - 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) { - mem_free(&(*(syn_t**) p)->f); - mem_free(p); -} - -void toggle_quadoption (int opt) +static void toggle_quadoption (int opt) { int n = opt / 4; int b = (opt % 4) * 2; @@ -279,25 +585,9 @@ 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. */ -static 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) +static void add_to_list (string_list_t ** list, const char *str) { - LIST *t, *last = NULL; + string_list_t *t, *last = NULL; /* don't add a NULL or empty string to the list */ if (!str || *str == '\0') @@ -315,8 +605,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(string_list_t, 1); + t->data = m_strdup(str); if (last) { last->next = t; last = last->next; @@ -326,146 +616,90 @@ static void add_to_list (LIST ** list, const char *str) } } -static int add_to_rx_list (list2_t** list, const char *s, int flags, - BUFFER * err) +static int +add_to_rx_list(rx_t **list, const char *s, int flags, BUFFER *err) { - rx_t* rx; - int i = 0; + rx_t* rx; - if (!s || !*s) - return 0; + if (m_strisempty(s)) + return 0; - if (!(rx = rx_compile (s, flags))) { - snprintf (err->data, err->dsize, "Bad regexp: %s\n", s); - return -1; - } + if (rx_lookup(list, s)) + return 0; - i = rx_lookup ((*list), rx->pattern); - if (i >= 0) - rx_free (&rx); - else - list_push_back (list, rx); - return 0; + rx = rx_compile(s, flags); + if (!rx) { + snprintf(err->data, err->dsize, "Bad regexp: %s\n", s); + return -1; + } + + rx_list_append(list, rx); + return 0; } -static int add_to_spam_list (SPAM_LIST ** list, const char *pat, +static int add_to_spam_list(rx_t **list, const char *pat, const char *templ, BUFFER * err) { - SPAM_LIST *t = NULL, *last = NULL; - rx_t* rx; - int n; - const char *p; - - if (!pat || !*pat || !templ) - return 0; + rx_t **last, *rx; - if (!(rx = rx_compile (pat, REG_ICASE))) { - snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat); - return -1; - } + if (m_strisempty(pat) || !templ) + return 0; - /* 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. Formerly we just skipped this case, but - * now we're supporting removals, which means we're supporting - * re-adds conceptually. So we probably want this to imply a - * removal, then do an add. We can achieve the removal by freeing - * the template, and leaving t pointed at the current item. - */ - t = last; - mem_free(t->template); - break; + if (!(rx = rx_compile (pat, REG_ICASE))) { + snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat); + return -1; } - if (!last->next) - break; - } - /* If t is set, it's pointing into an extant SPAM_LIST* that we want to - * update. Otherwise we want to make a new one to link at the list's end. - */ - if (!t) { - t = mutt_new_spam_list (); - t->rx = rx; - if (last) - last->next = t; - else - *list = t; - } - - /* Now t is the SPAM_LIST* that we want to modify. It is prepared. */ - t->template = str_dup (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; + /* 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)->pattern) == 0) { + rx_t *tmp = rx_list_pop(last); + rx_delete(&tmp); + last = rx_list_last(last); + break; + } } - else - ++p; - } - t->nmatch++; /* match 0 is always the whole expr */ - return 0; + *last = rx; + rx_set_template(rx, templ); + return 0; } -static int remove_from_spam_list (SPAM_LIST ** list, const char *pat) +static int remove_from_spam_list (rx_t ** list, const char *pat) { - SPAM_LIST *spam, *prev; int nremoved = 0; - /* Being first is a special case. */ - spam = *list; - if (!spam) - return 0; - if (spam->rx && !str_cmp (spam->rx->pattern, pat)) { - *list = spam->next; - rx_free (&spam->rx); - mem_free(&spam->template); - mem_free(&spam); - return 1; - } - - prev = spam; - for (spam = prev->next; spam;) { - if (!str_cmp (spam->rx->pattern, pat)) { - prev->next = spam->next; - rx_free (&spam->rx); - mem_free(spam->template); - mem_free(spam); - spam = prev->next; - ++nremoved; - } - else - spam = spam->next; + while (*list) { + if (!m_strcmp((*list)->pattern, pat)) { + rx_t *spam = rx_list_pop(list); + rx_delete(&spam); + nremoved++; + } else { + list = &(*list)->next; + } } return nremoved; } -static void remove_from_list (LIST ** l, const char *str) +static void remove_from_list (string_list_t ** l, const char *str) { - LIST *p, *last = NULL; + string_list_t *p, *last = NULL; - if (str_cmp ("*", str) == 0) - mutt_free_list (l); /* ``unCMD *'' means delete all current entries */ + if (m_strcmp("*", str) == 0) + string_list_wipe(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; @@ -475,36 +709,38 @@ static void remove_from_list (LIST ** l, const char *str) } } -static int remove_from_rx_list (list2_t** l, const char *str) +static int remove_from_rx_list(rx_t **l, const char *str) { - int i = 0; + if (m_strcmp("*", str) == 0) { + rx_list_wipe(l); + return 0; + } - if (str_cmp ("*", 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); + l = rx_lookup(l, str); + if (l) { + rx_t *r = rx_list_pop(l); + rx_delete(&r); + return 0; } - } - return (-1); + + return -1; } 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))) + 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); @@ -512,30 +748,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++; } } @@ -546,27 +776,29 @@ 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; } -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 { mutt_extract_token (buf, s, 0); /* don't add "*" to the unignore list */ - if (strcmp (buf->data, "*")) + if (m_strcmp (buf->data, "*")) add_to_list (&UnIgnore, buf->data); remove_from_list (&Ignore, buf->data); @@ -576,8 +808,9 @@ static int parse_unignore (BUFFER * buf, BUFFER * s, unsigned long data, 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 { mutt_extract_token (buf, s, 0); @@ -589,12 +822,13 @@ static int parse_ignore (BUFFER * buf, BUFFER * s, unsigned long data, 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 { mutt_extract_token (buf, s, 0); - add_to_list ((LIST **) data, buf->data); + add_to_list ((string_list_t **) data, buf->data); } while (MoreArgs (s)); @@ -611,8 +845,9 @@ static void _alternates_clean (void) } } -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 { @@ -627,15 +862,16 @@ static int parse_alternates (BUFFER * buf, BUFFER * s, unsigned long data, 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 { 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; @@ -650,14 +886,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; } @@ -672,10 +908,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. */ @@ -691,9 +927,9 @@ 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, "*")) { - mutt_free_spam_list (&SpamList); - list_del (&NoSpamList, (list_del_t*) rx_free); + if (!m_strcmp(buf->data, "*")) { + rx_list_wipe(&SpamList); + rx_list_wipe(&NoSpamList); return 0; } @@ -709,30 +945,31 @@ 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; } static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data, - BUFFER * err) + BUFFER * err __attribute__ ((unused))) { do { mutt_extract_token (buf, s, 0); /* * Check for deletion of entire list */ - if (str_cmp (buf->data, "*") == 0) { - mutt_free_list ((LIST **) data); + if (m_strcmp(buf->data, "*") == 0) { + string_list_wipe((string_list_t **) data); break; } - remove_from_list ((LIST **) data, buf->data); + remove_from_list ((string_list_t **) data, buf->data); } while (MoreArgs (s)); return 0; } -static int parse_lists (BUFFER * buf, BUFFER * s, unsigned long data, +static int parse_lists (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), BUFFER * err) { do { @@ -747,15 +984,250 @@ static int parse_lists (BUFFER * buf, BUFFER * s, unsigned long data, 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, string_list_t **ldata, + BUFFER *err __attribute__ ((unused))) { + ATTACH_MATCH *a; + string_list_t *listp, *lastp; + char *p; + char *tmpminor; + int len; + + /* Find the last item in the list that data points to. */ + lastp = NULL; + for (listp = *ldata; listp; listp = listp->next) { + a = (ATTACH_MATCH *)listp->data; + 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); + m_strcpy(&tmpminor[1], len + 3, a->minor); + 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); + + listp = p_new(string_list_t, 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, string_list_t **ldata, + BUFFER *err __attribute__ ((unused))) { + ATTACH_MATCH *a; + string_list_t *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 string_list_t->data, not anything pointed to by the string_list_t->data. */ + lastp = NULL; + for(lp = *ldata; lp; ) { + a = (ATTACH_MATCH *)lp->data; + if (a->major_int == major && !m_strcasecmp(minor, a->minor)) { + 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 (string_list_t *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; + string_list_t **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; + string_list_t **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 { mutt_extract_token (buf, s, 0); 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; } @@ -764,7 +1236,7 @@ static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data, return 0; } -static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data, +static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)), BUFFER * err) { do { @@ -782,14 +1254,15 @@ static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data, 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 { 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; } @@ -798,27 +1271,28 @@ static int parse_unsubscribe (BUFFER * buf, BUFFER * s, unsigned long data, 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; + alias_t *tmp, *last = NULL; 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; set_option (OPTFORCEREDRAWINDEX); } else - mutt_free_alias (&Aliases); + alias_list_wipe(&Aliases); break; } 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); @@ -830,7 +1304,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data, else Aliases = tmp->next; tmp->next = NULL; - mutt_free_alias (&tmp); + alias_list_wipe(&tmp); break; } last = tmp; @@ -840,48 +1314,45 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data, return 0; } -static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data, +static int parse_alias (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), BUFFER * err) { - ALIAS *tmp = Aliases; - ALIAS *last = NULL; + alias_t *tmp = Aliases; + alias_t *last = NULL; 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); } mutt_extract_token (buf, s, 0); - 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 (!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->self = tmp; - tmp->name = str_dup (buf->data); + tmp = alias_new(); + tmp->name = m_strdup(buf->data); /* give the main addressbook code a chance */ if (CurrentMenu == MENU_ALIAS) set_option (OPTMENUCALLER); } else { /* override the previous value */ - rfc822_free_address (&tmp->addr); + address_list_wipe(&tmp->addr); if (CurrentMenu == MENU_ALIAS) set_option (OPTFORCEREDRAWINDEX); } 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; @@ -890,40 +1361,32 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data, if (mutt_addrlist_to_idna (tmp->addr, &estr)) { snprintf (err->data, err->dsize, _("Warning: Bad IDN '%s' in alias '%s'.\n"), estr, tmp->name); + p_delete(&estr); return -1; } -#ifdef DEBUG - if (DebugLevel >= 2) { - ADDRESS *a; - for (a = tmp->addr; a; a = a->next) { - if (!a->group) - debug_print (2, ("%s\n", a->mailbox)); - else - debug_print (2, ("group %s\n", a->mailbox)); - } - } -#endif return 0; } static int -parse_unmy_hdr (BUFFER * buf, BUFFER * s, unsigned long data, BUFFER * err) +parse_unmy_hdr (BUFFER * buf, BUFFER * s, + unsigned long data __attribute__ ((unused)), + BUFFER * err __attribute__ ((unused))) { - LIST *last = NULL; - LIST *tmp = UserHeader; - LIST *ptr; - size_t l; + string_list_t *last = NULL; + string_list_t *tmp = UserHeader; + string_list_t *ptr; + ssize_t l; do { mutt_extract_token (buf, s, 0); - if (str_cmp ("*", buf->data) == 0) - mutt_free_list (&UserHeader); + if (m_strcmp("*", buf->data) == 0) + string_list_wipe(&UserHeader); else { tmp = UserHeader; last = NULL; - l = str_len (buf->data); + l = m_strlen(buf->data); if (buf->data[l - 1] == ':') l--; @@ -937,7 +1400,7 @@ parse_unmy_hdr (BUFFER * buf, BUFFER * s, unsigned long data, BUFFER * err) UserHeader = tmp->next; tmp = tmp->next; ptr->next = NULL; - mutt_free_list (&ptr); + string_list_wipe(&ptr); } else { last = tmp; @@ -950,16 +1413,16 @@ 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, +static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)), BUFFER * err) { - LIST *tmp; - size_t keylen; + string_list_t *tmp; + ssize_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); + m_strcpy(err->data, err->dsize, _("invalid header field")); return (-1); } keylen = p - buf->data + 1; @@ -969,218 +1432,245 @@ 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) break; } - tmp->next = mutt_new_list (); + tmp->next = string_item_new(); tmp = tmp->next; } else { - tmp = mutt_new_list (); + tmp = string_item_new(); 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, ssize_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 __attribute__ ((unused)), 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); + + 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; +/* free()'s option_t* */ +static void del_option (void* p) { + struct option_t *ptr = (struct option_t*) p; + char* s = (char*) ptr->data; + p_delete(&ptr->option); + p_delete(&s); + p_delete(&ptr->init); + p_delete(&ptr); +} - mem_free (&pp->pattern); - if (pp->rx) { - regfree (pp->rx); - mem_free (&pp->rx); - } +static int init_expand (char** dst, struct option_t* src) { + BUFFER token, in; + ssize_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 __attribute__ ((unused)), + 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 __attribute__ ((unused)), unsigned long p, + char* errbuf, ssize_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) { - list2_t* list = NULL; - int i = 0, rc = 1; - - if (!val || !*val) - return (1); - list = list_from_str (val, ","); - if (list_empty (list)) - return (1); +static int +check_dsn_notify (const char* option __attribute__ ((unused)), + unsigned long val, char* errbuf, ssize_t errlen) +{ + const char *p = (const char*)val; + + while (p && *p) { + const char *q = m_strchrnul(p, ','); + int len = q - p; + + if (!m_strncmp(p, "never", len) && !m_strncmp(p, "delay", len) + && !m_strncmp(p, "failure", len) && !m_strncmp(p, "success", len)) + { + if (errbuf) + snprintf(errbuf, errlen, _("'%.*s' is invalid for $%s"), + len, p, "dsn_notify"); + return 0; + } - 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) { - rc = 0; - break; + p = q + 1; } - list_del (&list, (list_del_t*) _mem_free); - return (rc); + + return 1; +} + +static int check_num (const char* option, unsigned long p, + char* errbuf, ssize_t errlen) { + if ((int) p < 0) { + if (errbuf) + snprintf (errbuf, errlen, _("'%d' is invalid for $%s"), (int) p, option); + return (0); + } + return (1); +} + +static int check_history (const char* option __attribute__ ((unused)), unsigned long p, + char* errbuf, ssize_t errlen) { + if (!check_num ("history", p, errbuf, errlen)) + return (0); + mutt_init_history (); + return (1); } -static int check_special (const char* name, const char* val) { +static int check_special (const char* name, unsigned long val, + char* errbuf, ssize_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 (int idx) { +static const struct mapping_t* get_sortmap (struct option_t* option) { const struct mapping_t* map = NULL; - switch (MuttVars[idx].type & DT_SUBTYPE_MASK) { + switch (option->type & DT_SUBTYPE_MASK) { case DT_SORT_ALIAS: map = SortAliasMethods; break; @@ -1188,8 +1678,7 @@ static const struct mapping_t* get_sortmap (int idx) { map = SortBrowserMethods; break; case DT_SORT_KEYS: - if ((WithCrypto & APPLICATION_PGP)) - map = SortKeyMethods; + map = SortKeyMethods; break; case DT_SORT_AUX: map = SortAuxMethods; @@ -1201,11 +1690,20 @@ static const struct mapping_t* get_sortmap (int idx) { 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 */ @@ -1218,11 +1716,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; } @@ -1234,12 +1732,35 @@ 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_t* syn = syn_new(); + syn->f = m_strdup(CurRCFile); + syn->l = CurRCLine; + syn->n = newopt; + syn->o = option; + syn_list_push(&Synonyms, syn); + option = newopt; + } + + /* see if we need to add $user_ var */ + if (!option && m_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 != '=')) { + 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) { @@ -1252,15 +1773,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"); @@ -1280,269 +1818,127 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data, } if (query) { - bool_to_string (err->data, err->dsize, idx); + 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); + set_option (option->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 != '=') { - FuncTable[DTYPE (MuttVars[idx].type)].opt_to_string (err->data, err->dsize, idx); - 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 != '=') { - rx_to_string (err->data, err->dsize, idx); - 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); + 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_list_wipe((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 **)(void *)&option->data); 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 - } - } - } - else if (DTYPE (MuttVars[idx].type) == DT_MAGIC) { - - if (query || *s->dptr != '=') { - magic_to_string (err->data, err->dsize, idx); - 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 != '=') { - num_to_string (err->data, err->dsize, idx); + 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 $madmutt_ 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) { + else if (DTYPE (option->type) == DT_QUAD) { if (query) { - quad_to_string (err->data, err->dsize, idx); + 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; - - if (query || *s->dptr != '=') { - sort_to_string (err->data, err->dsize, idx); - return 0; - } - - /* do this here so we don't ordinarily do it twice for queries */ - if (!(map = get_sortmap (idx))) { - snprintf (err->data, err->dsize, _("%s: Unknown type."), - MuttVars[idx].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; + 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); @@ -1559,21 +1955,19 @@ static int source_rc (const char *rcfile, BUFFER * err) BUFFER token; char *linebuf = NULL; char *currentline = NULL; - size_t buflen; + ssize_t buflen; pid_t pid; - 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) { + p_clear(&token, 1); + while ((linebuf = mutt_read_line(linebuf, &buflen, f, &line)) != NULL) { conv = ConfigCharset && (*ConfigCharset) && Charset; if (conv) { - currentline = str_dup (linebuf); + currentline = m_strdup(linebuf); if (!currentline) continue; mutt_convert_string (¤tline, ConfigCharset, Charset, 0); @@ -1588,7 +1982,7 @@ static int source_rc (const char *rcfile, BUFFER * err) mutt_error (_("Error in %s, line %d: %s"), rcfile, line, err->data); if (--rc < -MAXERRS) { if (conv) - mem_free (¤tline); + p_delete(¤tline); break; } } @@ -1597,11 +1991,11 @@ 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); - fclose (f); + p_delete(&token.data); + p_delete(&linebuf); + m_fclose(&f); if (pid != -1) mutt_wait_filter (pid); if (rc) { @@ -1617,7 +2011,8 @@ static int source_rc (const char *rcfile, BUFFER * err) #undef MAXERRS -static int parse_source (BUFFER * tmp, BUFFER * s, unsigned long data, +static int parse_source (BUFFER * tmp, BUFFER * s, + unsigned long data __attribute__ ((unused)), BUFFER * err) { char path[_POSIX_PATH_MAX]; @@ -1629,8 +2024,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); } @@ -1654,13 +2049,13 @@ 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); + expn.dptr = vskipspaces(expn.dptr); while (*expn.dptr) { if (*expn.dptr == '#') break; /* rest of line is a comment */ @@ -1670,7 +2065,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; @@ -1685,20 +2080,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. @@ -1707,14 +2102,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; @@ -1722,13 +2117,13 @@ static void candidate (char *dest, char *try, char *src, int len) } } -int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) +int mutt_command_complete (char *buffer, ssize_t len, int pos, int numtabs) { char *pt = buffer; 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; @@ -1739,12 +2134,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, countof(Matches)); + p_clear(Completed, countof(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 "" @@ -1759,27 +2154,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; } } @@ -1788,12 +2183,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, countof(Matches)); + p_clear(Completed, countof(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 "" @@ -1808,15 +2203,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) @@ -1826,17 +2221,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, countof(Matches)); + p_clear(Completed, countof(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; @@ -1852,13 +2247,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; @@ -1866,15 +2261,16 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) return 1; } -int mutt_var_value_complete (char *buffer, size_t len, int pos) +int mutt_var_value_complete (char *buffer, ssize_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; @@ -1884,42 +2280,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" }; + ssize_t dlen = buffer + len - pt - spaces; + 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_t **) 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; @@ -1927,26 +2321,19 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) map = SortBrowserMethods; break; case DT_SORT_KEYS: - if ((WithCrypto & APPLICATION_PGP)) - map = SortKeyMethods; - else - map = SortMethods; + map = SortKeyMethods; break; default: map = SortMethods; break; } - p = - mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, - map); - snprintf (tmp, sizeof (tmp), "%s%s%s", - (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? - "reverse-" : "", - (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : - "", p); - } - else if (DTYPE (MuttVars[idx].type) == DT_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"; @@ -1963,22 +2350,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) < 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; @@ -1988,108 +2374,104 @@ 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 (string_list_t * queries) { - LIST *p; + string_list_t *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); + 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) +static int mutt_execute_commands (string_list_t * 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; } -void mutt_init (int skip_sys_rc, LIST * commands) +void mutt_init (int skip_sys_rc, string_list_t * 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; + 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), + 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); + mutt_gecos_name(rnbuf, sizeof(rnbuf), pw, GecosMask.rx); + Realname = m_strdup(rnbuf); + Shell = m_strdup(pw->pw_shell); + endpwent (); } else { if (!Homedir) { @@ -2098,87 +2480,80 @@ 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); - /* And about the host... */ uname (&utsname); /* some systems report the FQDN instead of just the hostname */ if ((p = strchr (utsname.nodename, '.'))) { - Hostname = str_substrdup (utsname.nodename, p); + 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 = 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); - 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); } 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); - fclose (f); + fgets (buffer, sizeof(buffer), f); + p = vskipspaces(buffer); + q = (char*)p; + while (*q && !isspace(*q)) + q++; + *q = '\0'; + NewsServer = m_strdup(p); + m_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) { @@ -2186,47 +2561,33 @@ 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); 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) From = rfc822_parse_adrlist (NULL, p); - mutt_set_langinfo_charset (); - mutt_set_charset (Charset); - + charset_initialize(); /* 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 ()) @@ -2235,62 +2596,36 @@ void mutt_init (int skip_sys_rc, LIST * commands) mutt_init_history (); - - - - /* - * - * 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) { -#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); + snprintf (buffer, sizeof(buffer), "%s/.madmuttrc", NONULL (Homedir)); if (access (buffer, F_OK) == -1) -#endif - snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc", + snprintf (buffer, sizeof(buffer), "%s/.madmutt/madmuttrc", 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/Madmuttrc-%s", SYSCONFDIR, MUTT_VERSION); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc", SYSCONFDIR); + snprintf (buffer, sizeof(buffer), "%s/Madmuttrc", SYSCONFDIR); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", PKGDATADIR, + snprintf (buffer, sizeof(buffer), "%s/Madmuttrc-%s", PKGDATADIR, MUTT_VERSION); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc", PKGDATADIR); + snprintf (buffer, sizeof(buffer), "%s/Madmuttrc", PKGDATADIR); if (access (buffer, F_OK) != -1) { if (source_rc (buffer, &err) != 0) { fputs (err.data, stderr); @@ -2303,7 +2638,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); @@ -2312,7 +2647,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); } @@ -2321,17 +2656,20 @@ void mutt_init (int skip_sys_rc, LIST * commands) need_pause = 1; /* warn about synonym variables */ - if (!list_empty(Synonyms)) { - int i = 0; + if (Synonyms) { + syn_t *syn; + fprintf (stderr, _("Warning: the following synonym variables were found:\n")); - for (i = 0; i < Synonyms->length; i++) - 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, - 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); + + for (syn = Synonyms; syn; syn = syn->next) { + fprintf(stderr, "$%s ($%s should be used) (%s:%d)\n", + syn->o ? NONULL(syn->o->option) : "", + syn->n ? NONULL(syn->n->option) : "", + NONULL(syn->f), syn->l); + } + fprintf (stderr, _("Warning: synonym variables are scheduled" + " for removal.\n")); + syn_list_wipe(&Synonyms); need_pause = 1; } @@ -2339,10 +2677,6 @@ void mutt_init (int skip_sys_rc, LIST * commands) if (mutt_any_key_to_continue (NULL) == -1) mutt_exit (1); } - -#if 0 - set_option (OPTWEED); /* turn weeding on by default */ -#endif } int mutt_get_hook_type (const char *name) @@ -2355,32 +2689,30 @@ int mutt_get_hook_type (const char *name) return 0; } -static int opt_cmp (const void* a, const void* b) { - return (str_cmp ((*(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 = 0, idx = 0; - char outbuf[STRING]; - list2_t* tmp = NULL; +int mutt_dump_variables (int full) { + ssize_t i = 0; - /* 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]); - } - if (!list_empty(tmp)) { - /* ...and dump list sorted */ - qsort (tmp->data, tmp->length, sizeof (void*), opt_cmp); - for (i = 0; i < tmp->length; i++) { - idx = mutt_option_index (((struct option_t*) tmp->data[i])->option); - FuncTable[DTYPE (MuttVars[idx].type)].opt_to_string (outbuf, sizeof (outbuf), idx); - printf ("%s\n", outbuf); + /* get all non-synonyms into list... */ + for (i = 0; MuttVars[i].option; i++) { + struct option_t *option = MuttVars + i; + char buf[LONG_STRING]; + + if (DTYPE(option->type) == DT_SYN) + continue; + + if (!full) { + mutt_option_value(option->option, buf, sizeof(buf)); + if (!m_strcmp(buf, option->init)) + continue; + } + + printf("set "); + FuncTable[DTYPE(option->type)].opt_to_string + (buf, sizeof(buf), option); + printf ("%s\n", buf); } - } - list_del (&tmp, NULL); - return 0; + + printf ("\n# vi""m:set ft=muttrc:\n"); + return 0; }