X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=e4eb8018749f2376aed5638fa9ec059ef01c42f3;hp=e59984ec921823fce69fd01b8bc81bd8a759b077;hb=d3c39b017ce3de4a07c34a1d7017495ea1b7ed4b;hpb=e4ebc9b0ae5de07d53d8b0ecf594244e1bc44d0a

diff --git a/init.c b/init.c
index e59984e..e4eb801 100644
--- a/init.c
+++ b/init.c
@@ -79,135 +79,453 @@ static const char* CurRCFile = NULL;
 static int CurRCLine = 0;
 
 /* prototypes for checking for special vars */
-static int check_dsn_return (const char*);
-static int check_dsn_notify (const char*);
+static int check_dsn_return (const char* option, unsigned long val,
+                             char* errbuf, size_t errlen);
+static int check_dsn_notify (const char* option, unsigned long val,
+                             char* errbuf, size_t errlen);
+static int check_history    (const char* option, unsigned long val,
+                             char* errbuf, size_t errlen);
+/* this checks that numbers are >= 0 */
+static int check_num        (const char* option, unsigned long val,
+                             char* errbuf, size_t errlen);
+#ifdef DEBUG
+static int check_debug      (const char* option, unsigned long val,
+                             char* errbuf, size_t errlen);
+#endif
+
+/* use this to check only */
+static int check_special (const char* option, unsigned long val,
+                          char* errbuf, size_t errlen);
 
-/* variable <-> sanity check function mappings */
+/* variable <-> sanity check function mappings
+ * when changing these, make sure the proper _from_string handler
+ * does this checking!
+ */
 static struct {
   const char* name;
-  int (*check) (const char*);
+  int (*check) (const char* option, unsigned long val,
+                char* errbuf, size_t errlen);
 } SpecialVars[] = {
-  { "dsn_notify", check_dsn_notify },
-  { "dsn_return", check_dsn_return },
+  { "dsn_notify",               check_dsn_notify },
+  { "dsn_return",               check_dsn_return },
 #if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS))
-  { "smtp_use_tls", mutt_libesmtp_check_usetls },
+  { "smtp_use_tls",             mutt_libesmtp_check_usetls },
+#endif
+  { "history",                  check_history },
+  { "pager_index_lines",        check_num },
+#ifdef DEBUG
+  { "debug_level",              check_debug },
 #endif
   /* last */
   { NULL,         NULL }
 };
 
-/* protos for config type handles */
-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, size_t dstlen, struct option_t* option);
+static void num_to_string   (char* dst, size_t dstlen, struct option_t* option);
+static void str_to_string   (char* dst, size_t dstlen, struct option_t* option);
+static void quad_to_string  (char* dst, size_t dstlen, struct option_t* option);
+static void sort_to_string  (char* dst, size_t dstlen, struct option_t* option);
+static void rx_to_string    (char* dst, size_t dstlen, struct option_t* option);
+static void magic_to_string (char* dst, size_t dstlen, struct option_t* option);
+static void addr_to_string  (char* dst, size_t dstlen, struct option_t* option);
+static void user_to_string  (char* dst, size_t dstlen, struct option_t* option);
+static void sys_to_string   (char* dst, size_t dstlen, struct option_t* option);
+
+/* protos for config type handles: convert to value from string */
+static int bool_from_string  (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int num_from_string   (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int str_from_string   (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int path_from_string  (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int quad_from_string  (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int sort_from_string  (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int rx_from_string    (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int magic_from_string (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int addr_from_string  (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
+static int user_from_string  (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen);
 
 static struct {
   unsigned short type;
-  void (*opt_to_string) (char* dst, size_t dstlen, int idx);
+  void (*opt_to_string) (char* dst, size_t dstlen, struct option_t* option);
+  int (*opt_from_string) (struct option_t* dst, const char* val,
+                          char* errbuf, size_t errlen);
 } FuncTable[] = {
-  { 0,          NULL            }, /* 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,
-            option (MuttVars[idx].data) ? "yes" : "no");
+static void bool_to_string (char* dst, size_t dstlen,
+                            struct option_t* option) {
+  snprintf (dst, dstlen, "%s=%s", option->option,
+            option (option->data) ? "yes" : "no");
+}
+
+static int bool_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  int flag = -1;
+
+  if (!dst)
+    return (0);
+  if (ascii_strncasecmp (val, "yes", 3) == 0)
+    flag = 1;
+  else if (ascii_strncasecmp (val, "no", 2) == 0)
+    flag = 0;
+
+  if (flag < 0)
+    return (0);
+  if (flag)
+    set_option (dst->data);
+  else
+    unset_option (dst->data);
+  return (1);
 }
 
-static void num_to_string (char* dst, size_t dstlen, int idx) {
+static void num_to_string (char* dst, size_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 = (str_cmp (option->option, "umask") == 0) ? 
+                    "%s=%04o" : "%s=%d";
+  snprintf (dst, dstlen, fmt, option->option,
+            *((short*) option->data));
+}
+
+static int num_from_string (struct option_t* dst, const char* val,
+                            char* errbuf, size_t errlen) {
+  int num = 0, old = 0;
+  char* t = NULL;
+
+  if (!dst)
+    return (0);
+
+  num = strtol (val, &t, 0);
+
+  if (!*val || *t || (short) num != num) {
+    if (errbuf) {
+      snprintf (errbuf, errlen, _("'%s' is invalid for $%s"),
+                val, dst->option);
+    }
+    return (0);
+  }
+
+  /* just temporarily accept new val so that check_special for
+   * $history already has it when doing history's init() */
+  old = *((short*) dst->data);
+  *((short*) dst->data) = (short) num;
+
+  if (!check_special (dst->option, (unsigned long) num, errbuf, errlen)) {
+    *((short*) dst->data) = old;
+    return (0);
+  }
+
+  return (1);
+}
+
+static void str_to_string (char* dst, size_t dstlen,
+                           struct option_t* option) {
+  snprintf (dst, dstlen, "%s=\"%s\"", option->option,
+            NONULL (*((char**) option->data)));
+}
+
+static void user_to_string (char* dst, size_t dstlen,
+                            struct option_t* option) {
+  snprintf (dst, dstlen, "%s=\"%s\"", option->option,
+            NONULL (((char*) option->data)));
+}
+
+static void sys_to_string (char* dst, size_t dstlen,
+                           struct option_t* option) {
+  char* val = NULL, *t = NULL;
+  int clean = 0;
+
+  /* get some $muttng_ values dynamically */
+  if (ascii_strcmp ("muttng_pwd", option->option) == 0) {
+    val = mem_malloc (_POSIX_PATH_MAX);
+    val = getcwd (val, _POSIX_PATH_MAX-1);
+    clean = 1;
+  } else if (ascii_strcmp ("muttng_folder_path", option->option) == 0 &&
+             CurrentFolder && *CurrentFolder) {
+    val = CurrentFolder;
+  } else if (ascii_strcmp ("muttng_folder_name", option->option) == 0 &&
+             CurrentFolder && *CurrentFolder) {
+    if ((t = strrchr (CurrentFolder, '/')) != NULL)
+      val = t+1;
+    else
+      val = CurrentFolder;
+  } else
+    val = option->init;
+
+  snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (val));
+  if (clean)
+    mem_free (&val);
+}
+
+static int path_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  char path[_POSIX_PATH_MAX];
+
+  if (!dst)
+    return (0);
+
+  if (!val || !*val) {
+    mem_free ((char**) dst->data);
+    return (1);
+  }
+
+  path[0] = '\0';
+  strfcpy (path, val, sizeof (path));
+  mutt_expand_path (path, sizeof (path));
+  str_replace ((char **) dst->data, path);
+  return (1);
+}
+
+static int str_from_string (struct option_t* dst, const char* val,
+                            char* errbuf, size_t errlen) {
+  if (!dst)
+    return (0);
+
+  if (!check_special (dst->option, (unsigned long) val, errbuf, errlen))
+    return (0);
+
+  str_replace ((char**) dst->data, val);
+  return (1);
 }
 
-static 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 user_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  /* if dst == NULL, we may get here in case the user did unset it,
+   * see parse_set() where item is free()'d before coming here; so
+   * just silently ignore it */
+  if (!dst)
+    return (1);
+  if (str_len ((char*) dst->data) == 0)
+    dst->data = (unsigned long) str_dup (val);
+  else {
+    char* s = (char*) dst->data;
+    str_replace (&s, val);
+  }
+  if (str_len (dst->init) == 0)
+    dst->init = str_dup ((char*) dst->data);
+  return (1);
 }
 
-static void quad_to_string (char* dst, size_t dstlen, int idx) {
+static void quad_to_string (char* dst, size_t dstlen,
+                            struct option_t* option) {
   char *vals[] = { "no", "yes", "ask-no", "ask-yes" };
-  snprintf (dst, dstlen, "%s=%s", MuttVars[idx].option,
-            vals[quadoption (MuttVars[idx].data)]);
+  snprintf (dst, dstlen, "%s=%s", option->option,
+            vals[quadoption (option->data)]);
 }
 
-static void sort_to_string (char* dst, size_t dstlen, int idx) {
-  const struct mapping_t *map = get_sortmap (idx);
+static int quad_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  int flag = -1;
+
+  if (!dst)
+    return (0);
+  if (ascii_strncasecmp (val, "yes", 3) == 0)
+    flag = M_YES;
+  else if (ascii_strncasecmp (val, "no", 2) == 0)
+    flag = M_NO;
+  else if (ascii_strncasecmp (val, "ask-yes", 7) == 0)
+    flag = M_ASKYES;
+  else if (ascii_strncasecmp (val, "ask-no", 6) == 0)
+    flag = M_ASKNO;
+
+  if (flag < 0)
+    return (0);
+
+  set_quadoption (dst->data, flag);
+  return (1);
+}
+
+static void sort_to_string (char* dst, size_t dstlen,
+                            struct option_t* option) {
+  const struct mapping_t *map = get_sortmap (option);
   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,
+  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, size_t errlen) {
+  const struct mapping_t *map = NULL;
+  if (!(map = get_sortmap (dst))) {
+    if (errbuf)
+      snprintf (errbuf, errlen, _("%s: Unknown type."),
+                dst->option);
+    return (0);
+  }
+  if (parse_sort (dst, val, map, errbuf, errlen) == -1)
+    return (0);
+  return (1);
+}
+
+static void rx_to_string (char* dst, size_t dstlen,
+                          struct option_t* option) {
+  rx_t* p = (rx_t*) option->data;
+  snprintf (dst, dstlen, "%s=\"%s\"", option->option,
             NONULL (p->pattern));
 }
 
-static 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, size_t errlen) {
+  rx_t* p = NULL;
+  regex_t* rx = NULL;
+  int flags = 0, e = 0, not = 0;
+  char* s = NULL;
+
+  if (!dst)
+    return (0);
+
+  if (option (OPTATTACHMSG) && !str_cmp (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) = mem_calloc (1, sizeof (rx_t));
+
+  p = (rx_t*) dst->data;
+
+  /* something to do? */
+  if (!val || !*val || (p->pattern && str_cmp (p->pattern, val) == 0))
+    return (1);
+
+  if (str_cmp (dst->option, "mask") != 0)
+    flags |= mutt_which_case (val);
+
+  s = (char*) val;
+  if (str_cmp (dst->option, "mask") == 0 && *s == '!') {
+    not = 1;
+    s++;
+  }
+
+  rx = mem_malloc (sizeof (regex_t));
+
+  if ((e = REGCOMP (rx, s, flags)) != 0) {
+    regerror (e, rx, errbuf, errlen);
+    regfree (rx);
+    mem_free (&rx);
+    return (0);
+  }
+
+  if (p->rx) {
+    regfree (p->rx);
+    mem_free (&p->rx);
+  }
+
+  str_replace (&p->pattern, val);
+  p->rx = rx;
+  p->not = not;
+
+  if (str_cmp (dst->option, "reply_regexp") == 0)
+    mutt_adjust_all_subjects ();
+
+  return (1);
+}
+
+static void magic_to_string (char* dst, size_t dstlen,
+                             struct option_t* option) {
   const char* s = NULL;
-  switch (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, size_t errlen) {
+  int flag = -1;
+
+  if (!dst || !val || !*val)
+    return (0);
+  if (ascii_strncasecmp (val, "mbox", 4) == 0)
+    flag = M_MBOX;
+  else if (ascii_strncasecmp (val, "mmdf", 4) == 0)
+    flag = M_MMDF;
+  else if (ascii_strncasecmp (val, "mh", 2) == 0)
+    flag = M_MH;
+  else if (ascii_strncasecmp (val, "maildir", 7) == 0)
+    flag = M_MAILDIR;
+
+  if (flag < 0)
+    return (0);
+
+  *((short*) dst->data) = flag;
+  return (1);
+
 }
 
-static void addr_to_string (char* dst, size_t dstlen, int idx) {
-  char s[STRING];
+static void addr_to_string (char* dst, size_t dstlen,
+                            struct option_t* option) {
+  char s[HUGE_STRING];
   s[0] = '\0';
-  rfc822_write_address (s, sizeof (s), *((ADDRESS**) MuttVars[idx].data), 0);
-  snprintf (dst, dstlen, "%s=\"%s\"", MuttVars[idx].option, NONULL (s));
+  rfc822_write_address (s, sizeof (s), *((ADDRESS**) option->data), 0);
+  snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s));
+}
+
+static int addr_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  if (!dst)
+    return (0);
+  rfc822_free_address ((ADDRESS**) dst->data);
+  if (val && *val)
+    *((ADDRESS**) dst->data) = rfc822_parse_adrlist (NULL, val);
+  return (1);
 }
 
 int mutt_option_value (const char* val, char* dst, size_t dstlen) {
-  int i = mutt_option_index ((char*) val);
+  struct option_t* option = NULL;
   char* tmp = NULL, *t = NULL;
   size_t l = 0;
 
-  if (i < 0) {
-    debug_print (1, ("var '%s' not found, i = %d\n", val, i));
+  if (!(option = hash_find (ConfigOptions, val))) {
+    debug_print (1, ("var '%s' not found\n", val));
     *dst = '\0';
     return (0);
   }
   tmp = mem_malloc (dstlen+1);
-  FuncTable[DTYPE (MuttVars[i].type)].opt_to_string (tmp, dstlen, i);
+  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 */
@@ -497,7 +815,7 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
   mutt_extract_token (tmp, s, 0);
 
   /* is the item defined as a variable or a function? */
-  if ((option = hash_find (ConfigOptions, tmp->data)))
+  if ((option = hash_find (ConfigOptions, tmp->data)) != NULL)
     res = 1;
   else {
     for (i = 0; !res && i < MENU_MAX; i++) {
@@ -515,23 +833,16 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
     }
   }
   /* check for feature_* */
-  if (!res) {
-    char *p = NULL;
-
+  if (!res && ascii_strncasecmp (tmp->data, "feature_", 8) == 0 &&
+      (j = str_len (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 (str_len (Features[i]) == j-8 &&
+          ascii_strncasecmp (Features[i], tmp->data+8, j-8) == 0) {
+        res = 1;
+        break;
       }
+      i++;
     }
   }
 
@@ -542,9 +853,10 @@ 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);
@@ -1020,17 +1332,81 @@ static void mutt_set_default (const char* name, void* p, unsigned long more) {
       return;
     ptr = hash_find (ConfigOptions, (char*) ptr->data);
   }
-  if (!ptr || *ptr->init)
+  if (!ptr || *ptr->init || !FuncTable[DTYPE (ptr->type)].opt_from_string)
     return;
   mutt_option_value (ptr->option, buf, sizeof (buf));
   if (str_len (ptr->init) == 0 && buf && *buf)
     ptr->init = str_dup (buf);
 }
 
+static struct option_t* add_option (const char* name, const char* init,
+                                    short type, short dup) {
+  struct option_t* option = mem_calloc (1, sizeof (struct option_t));
+
+  debug_print (1, ("adding $%s\n", name));
+
+  option->option = str_dup (name);
+  option->type = type;
+  if (init)
+    option->init = dup ? str_dup (init) : (char*) init;
+  return (option);
+}
+
+/* creates new option_t* of type DT_USER for $user_ var */
+static struct option_t* add_user_option (const char* name) {
+  return (add_option (name, NULL, DT_USER, 1));
+}
+
+/* free()'s option_t* */
+static void del_option (void* p) {
+  struct option_t* ptr = (struct option_t*) p;
+  char* s = (char*) ptr->data;
+  debug_print (1, ("removing option '%s' from table\n", NONULL (ptr->option)));
+  mem_free (&ptr->option);
+  mem_free (&s);
+  mem_free (&ptr->init);
+  mem_free (&ptr);
+}
+
+static int init_expand (char** dst, struct option_t* src) {
+  BUFFER token, in;
+  size_t len = 0;
+
+  mem_free (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) {
+      memset (&token, 0, sizeof (BUFFER));
+      memset (&in, 0, sizeof (BUFFER));
+      len = str_len (src->init) + 2;
+      in.data = mem_malloc (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 = str_dup (token.data);
+      else
+        *dst = str_dup ("");
+      mem_free (&in.data);
+      mem_free (&token.data);
+    } else
+      *dst = str_dup ("");
+  } else
+    /* for non-string: take value as is */
+    *dst = str_dup (src->init);
+  return (1);
+}
+
 /* if additional data more == 1, we want to resolve synonyms */
-static void mutt_restore_default (const char* name, void* p, unsigned long more) {
+static void mutt_restore_default (const char* name, void* p,
+                                  unsigned long more) {
   char errbuf[STRING];
   struct option_t* ptr = (struct option_t*) p;
+  char* init = NULL;
 
   if (DTYPE (ptr->type) == DT_SYN) {
     if (!more)
@@ -1039,12 +1415,18 @@ static void mutt_restore_default (const char* name, void* p, unsigned long more)
   }
   if (!ptr)
     return;
-  if (FuncTable[DTYPE (ptr->type)].opt_from_string (ptr, ptr->init, errbuf,
-                                                    sizeof (errbuf)) < 0) {
-    mutt_endwin (NULL);
-    fprintf (stderr, _("Invalid default setting found. Please report this "
-                       "error:\n\"%s\"\n"), errbuf);
-    exit (1);
+  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);
+    }
+    mem_free (&init);
   }
 
   if (ptr->flags & R_INDEX)
@@ -1112,6 +1494,19 @@ static int check_num (const char* option, unsigned long p,
   return (1);
 }
 
+#ifdef DEBUG
+static int check_debug (const char* option, unsigned long p,
+                        char* errbuf, size_t errlen) {
+  if ((int) p <= DEBUG_MAX_LEVEL &&
+      (int) p >= DEBUG_MIN_LEVEL)
+    return (1);
+
+  if (errbuf)
+    snprintf (errbuf, errlen, _("'%d' is invalid for $%s"), (int) p, option);
+  return (0);
+}
+#endif
+
 static int check_history (const char* option, unsigned long p,
                           char* errbuf, size_t errlen) {
   if (!check_num ("history", p, errbuf, errlen))
@@ -1157,14 +1552,6 @@ static const struct mapping_t* get_sortmap (struct option_t* option) {
   return (map);
 }
 
-/* creates new option_t* of type DT_USER for $user_ var */
-static struct option_t* add_user_option (const char* name) {
-  struct option_t* option = mem_calloc (1, sizeof (struct option_t));
-  option->option = str_dup (name);
-  option->type = DT_USER;
-  return (option);
-}
-
 static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
                       BUFFER * err)
 {
@@ -1207,11 +1594,14 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
     }
 
     /* see if we need to add $user_ var */
-    if (!option && !reset && !unset && 
-        ascii_strncasecmp ("user_", tmp->data, 5) == 0) {
-      debug_print (1, ("adding user option '%s'\n", tmp->data));
-      option = add_user_option (tmp->data);
-      hash_insert (ConfigOptions, option->option, option, 0);
+    if (!option && ascii_strncmp ("user_", tmp->data, 5) == 0) {
+      /* there's no option named like this yet so only add one
+       * if the action isn't any of: reset, unset, query */
+      if (!(reset || unset || query || *s->dptr != '=')) {
+        debug_print (1, ("adding user option '%s'\n", tmp->data));
+        option = add_user_option (tmp->data);
+        hash_insert (ConfigOptions, option->option, option, 0);
+      }
     }
 
     if (!option && !(reset && str_cmp ("all", tmp->data) == 0)) {
@@ -1235,7 +1625,11 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         hash_map (ConfigOptions, mutt_restore_default, 1);
         return (0);
       }
-      else
+      else if (!FuncTable[DTYPE (option->type)].opt_from_string) {
+        snprintf (err->data, err->dsize, _("$%s is read-only"), option->option);
+        r = -1;
+        break;
+      } else
         mutt_restore_default (NULL, option, 1);
     }
     else if (DTYPE (option->type) == DT_BOOL) {
@@ -1278,20 +1672,28 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
              DTYPE (option->type) == DT_NUM ||
              DTYPE (option->type) == DT_SORT ||
              DTYPE (option->type) == DT_RX ||
-             DTYPE (option->type) == DT_USER) {
+             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_USER ||
+          DTYPE (option->type) == DT_SYS) {
         if (unset) {
-          if (DTYPE (option->type) == DT_ADDR)
+          if (!FuncTable[DTYPE (option->type)].opt_from_string) {
+            snprintf (err->data, err->dsize, _("$%s is read-only"),
+                      option->option);
+            r = -1;
+            break;
+          } else if (DTYPE (option->type) == DT_ADDR)
             rfc822_free_address ((ADDRESS **) option->data);
-          else if (DTYPE (option->type == DT_USER)) {
-            void* p = (void*) option->data;
-            mem_free (&p);
-          } else
+          else if (DTYPE (option->type) == DT_USER)
+            /* to unset $user_ means remove */
+            hash_delete (ConfigOptions, option->option,
+                         option, del_option);
+          else
             mem_free ((void *) option->data);
           break;
         }
@@ -1303,11 +1705,19 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         break;
       }
 
-      s->dptr++;
-      mutt_extract_token (tmp, s, 0);
-      if (!FuncTable[DTYPE (option->type)].opt_from_string
-          (option, tmp->data, err->data, err->dsize))
+      /* the $muttng_ variables are read-only */
+      if (!FuncTable[DTYPE (option->type)].opt_from_string) {
+        snprintf (err->data, err->dsize, _("$%s is read-only"),
+                  option->option);
         r = -1;
+        break;
+      } else {
+        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 (option->type) == DT_QUAD) {
 
@@ -1478,6 +1888,8 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err)
 
   *err->data = 0;
 
+  debug_print (1, ("expand '%s'\n", line));
+
   SKIPWS (expn.dptr);
   while (*expn.dptr) {
     if (*expn.dptr == '#')
@@ -1886,10 +2298,17 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   err.data = error;
   err.dsize = sizeof (error);
 
-  /* use 3*sizeof(muttvars) to have some room for $user_ vars */
+  /* 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++)
-    hash_insert (ConfigOptions, MuttVars[i].option, &MuttVars[i], 0);
+  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?
@@ -1912,6 +2331,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
     Realname = str_dup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw));
     Shell = str_dup (pw->pw_shell);
+    endpwent ();
   }
   else {
     if (!Homedir) {
@@ -2123,7 +2543,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);