From: Pierre Habouzit <madcoder@debian.org>
Date: Sat, 28 Oct 2006 01:40:04 +0000 (+0200)
Subject: fix a segfault introduced by some nasty const /o\
X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=commitdiff_plain;h=df9a60705a8b714c1929339fe9173cf0a06ab3ba

fix a segfault introduced by some nasty const /o\

rewrites.

Signed-off-by: Pierre Habouzit <madcoder@debian.org>
---

diff --git a/crypt-mod.h b/crypt-mod.h
index 389e1fd..eb12b93 100644
--- a/crypt-mod.h
+++ b/crypt-mod.h
@@ -65,48 +65,35 @@ typedef void (*crypt_func_init_t) (void);
    A structure to keep all crypto module fucntions together.
  */
 typedef struct crypt_module_functions {
-  /* Common/General functions.  */
-  crypt_func_init_t init;
-  crypt_func_void_passphrase_t void_passphrase;
-  crypt_func_valid_passphrase_t valid_passphrase;
-  crypt_func_decrypt_mime_t decrypt_mime;
-  crypt_func_application_handler_t application_handler;
-  crypt_func_encrypted_handler_t encrypted_handler;
-  crypt_func_findkeys_t findkeys;
-  crypt_func_sign_message_t sign_message;
-  crypt_func_verify_one_t verify_one;
-  crypt_func_send_menu_t send_menu;
-
-  /* PGP specific functions.  */
-  crypt_func_pgp_encrypt_message_t pgp_encrypt_message;
-  crypt_func_pgp_make_key_attachment_t pgp_make_key_attachment;
-  crypt_func_pgp_check_traditional_t pgp_check_traditional;
-  crypt_func_pgp_traditional_encryptsign_t pgp_traditional_encryptsign;
-  crypt_func_pgp_invoke_getkeys_t pgp_invoke_getkeys;
-  crypt_func_pgp_invoke_import_t pgp_invoke_import;
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     crypt_func_pgp_extract_keys_from_attachment_list_t
-    pgp_extract_keys_from_attachment_list;
-
-  /* S/MIME specific functions.  */
-
-  crypt_func_smime_getkeys_t smime_getkeys;
-  crypt_func_smime_verify_sender_t smime_verify_sender;
-  crypt_func_smime_build_smime_entity_t smime_build_smime_entity;
-  crypt_func_smime_invoke_import_t smime_invoke_import;
+    /* Common/General functions.  */
+    crypt_func_init_t init;
+    crypt_func_void_passphrase_t void_passphrase;
+    crypt_func_valid_passphrase_t valid_passphrase;
+    crypt_func_decrypt_mime_t decrypt_mime;
+    crypt_func_application_handler_t application_handler;
+    crypt_func_encrypted_handler_t encrypted_handler;
+    crypt_func_findkeys_t findkeys;
+    crypt_func_sign_message_t sign_message;
+    crypt_func_verify_one_t verify_one;
+    crypt_func_send_menu_t send_menu;
+
+    /* PGP specific functions.  */
+    crypt_func_pgp_encrypt_message_t pgp_encrypt_message;
+    crypt_func_pgp_make_key_attachment_t pgp_make_key_attachment;
+    crypt_func_pgp_check_traditional_t pgp_check_traditional;
+    crypt_func_pgp_traditional_encryptsign_t pgp_traditional_encryptsign;
+    crypt_func_pgp_invoke_getkeys_t pgp_invoke_getkeys;
+    crypt_func_pgp_invoke_import_t pgp_invoke_import;
+
+    crypt_func_pgp_extract_keys_from_attachment_list_t
+        pgp_extract_keys_from_attachment_list;
+
+    /* S/MIME specific functions.  */
+
+    crypt_func_smime_getkeys_t smime_getkeys;
+    crypt_func_smime_verify_sender_t smime_verify_sender;
+    crypt_func_smime_build_smime_entity_t smime_build_smime_entity;
+    crypt_func_smime_invoke_import_t smime_invoke_import;
 } crypt_module_functions_t;
 
 
diff --git a/hash.h b/hash.h
index 1a4f985..2e3f98d 100644
--- a/hash.h
+++ b/hash.h
@@ -11,31 +11,33 @@
 #define _HASH_H
 
 struct hash_elem {
-  const char *key;
-  void *data;
-  struct hash_elem *next;
+    const char *key;
+    void *data;
+    struct hash_elem *next;
 };
 
 typedef struct {
-  int nelem, curnelem;
-  struct hash_elem **table;
+    int nelem, curnelem;
+    struct hash_elem **table;
 } HASH;
 
-#define hash_find(table, key) hash_find_hash(table, hash_string ((unsigned char *)key, table->nelem), key)
+#define hash_find(table, key) \
+    hash_find_hash(table, hash_string((unsigned char *)key, table->nelem), key)
 
-#define hash_delete(table,key,data,destroy) hash_delete_hash(table, hash_string ((unsigned char *)key, table->nelem), key, data, destroy)
+#define hash_delete(table,key,data,destroy) \
+    hash_delete_hash(table, hash_string((unsigned char *)key, table->nelem), key, data, destroy)
 
-HASH *hash_create (int nelem);
-int hash_string (const unsigned char *s, int n);
-int hash_insert (HASH * table, const char *key, void *data, int allow_dup);
-HASH *hash_resize (HASH * table, int nelem);
-void *hash_find_hash (const HASH * table, int hash, const char *key);
-void hash_delete_hash (HASH * table, int hash, const char *key,
-                       const void *data, void (*destroy) (void *));
-void hash_destroy (HASH ** hash, void (*destroy) (void *));
+HASH *hash_create(int nelem);
+int hash_string(const unsigned char *s, int n);
+int hash_insert(HASH * table, const char *key, void *data, int allow_dup);
+HASH *hash_resize(HASH * table, int nelem);
+void *hash_find_hash(const HASH *table, int hash, const char *key);
+void hash_delete_hash(HASH * table, int hash, const char *key,
+                      const void *data, void (*destroy) (void *));
+void hash_destroy(HASH ** hash, void (*destroy) (void *));
 
-void hash_map (HASH* table,
-               void (*mapfunc) (const char* key, void* data, unsigned long more),
-               unsigned long more);
+void hash_map(HASH* table,
+              void (*mapfunc) (const char* key, void* data, unsigned long more),
+              unsigned long more);
 
 #endif
diff --git a/init.c b/init.c
index 6ac482f..169b8b6 100644
--- a/init.c
+++ b/init.c
@@ -61,7 +61,7 @@ static int parse_sort (struct option_t* dst, const char *s,
                        const struct mapping_t *map,
                        char* errbuf, size_t errlen);
 
-static HASH* ConfigOptions = NULL;
+static HASH *ConfigOptions = NULL;
 
 /* for synonym warning reports: synonym found during parsing */
 typedef struct {
@@ -311,8 +311,8 @@ static int path_from_string (struct option_t* dst, const char* val,
   }
 
   path[0] = '\0';
-  strfcpy (path, val, sizeof (path));
-  mutt_expand_path (path, sizeof (path));
+  strfcpy (path, val, sizeof(path));
+  mutt_expand_path (path, sizeof(path));
   str_replace ((char **) dst->data, path);
   return (1);
 }
@@ -382,7 +382,7 @@ static void sort_to_string (char* dst, size_t dstlen,
   const char *p = NULL;
 
   if (!map) {
-    snprintf (dst, sizeof (dst), "%s=unknown", option->option);
+    snprintf (dst, sizeof(dst), "%s=unknown", option->option);
     return;
   }
 
@@ -434,7 +434,7 @@ static int rx_from_string (struct option_t* dst, const char* val,
   }
 
   if (!((rx_t*) dst->data))
-    *((rx_t**) dst->data) = mem_calloc (1, sizeof (rx_t));
+    *((rx_t**) dst->data) = mem_calloc (1, sizeof(rx_t));
 
   p = (rx_t*) dst->data;
 
@@ -451,7 +451,7 @@ static int rx_from_string (struct option_t* dst, const char* val,
     s++;
   }
 
-  rx = mem_malloc (sizeof (regex_t));
+  rx = mem_malloc (sizeof(regex_t));
 
   if ((e = REGCOMP (rx, s, flags)) != 0) {
     regerror (e, rx, errbuf, errlen);
@@ -515,7 +515,7 @@ static void addr_to_string (char* dst, size_t dstlen,
                             struct option_t* option) {
   char s[HUGE_STRING];
   s[0] = '\0';
-  rfc822_write_address (s, sizeof (s), *((ADDRESS**) option->data), 0);
+  rfc822_write_address (s, sizeof(s), *((ADDRESS**) option->data), 0);
   snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s));
 }
 
@@ -563,7 +563,7 @@ int mutt_option_value (const char* val, char* dst, size_t dstlen) {
 
 /* for synonym warning reports: adds synonym to end of list */
 static void syn_add (struct option_t* n, struct option_t* o) {
-  syn_t* tmp = mem_malloc (sizeof (syn_t));
+  syn_t* tmp = mem_malloc (sizeof(syn_t));
   tmp->f = str_dup (CurRCFile);
   tmp->l = CurRCLine;
   tmp->n = n;
@@ -640,7 +640,7 @@ static void add_to_list (LIST ** list, const char *str)
   }
 
   if (!*list || last) {
-    t = (LIST *) mem_calloc (1, sizeof (LIST));
+    t = (LIST *) mem_calloc (1, sizeof(LIST));
     t->data = str_dup (str);
     if (last) {
       last->next = t;
@@ -826,7 +826,7 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
   BUFFER token;
   struct option_t* option = NULL;
 
-  memset (&token, 0, sizeof (token));
+  memset (&token, 0, sizeof(token));
   mutt_extract_token (tmp, s, 0);
 
   /* is the item defined as a variable or a function? */
@@ -973,7 +973,7 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data,
 {
   BUFFER templ;
 
-  memset (&templ, 0, sizeof (templ));
+  memset (&templ, 0, sizeof(templ));
 
   /* Insist on at least one parameter */
   if (!MoreArgs (s)) {
@@ -1429,7 +1429,7 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data,
 
   if (!tmp) {
     /* create a new alias */
-    tmp = (ALIAS *) mem_calloc (1, sizeof (ALIAS));
+    tmp = (ALIAS *) mem_calloc (1, sizeof(ALIAS));
     tmp->self = tmp;
     tmp->name = str_dup (buf->data);
     /* give the main addressbook code a chance */
@@ -1536,7 +1536,7 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data,
         /* replace the old value */
         mem_free (&tmp->data);
         tmp->data = buf->data;
-        memset (buf, 0, sizeof (BUFFER));
+        memset (buf, 0, sizeof(BUFFER));
         return 0;
       }
       if (!tmp->next)
@@ -1550,7 +1550,7 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data,
     UserHeader = tmp;
   }
   tmp->data = buf->data;
-  memset (buf, 0, sizeof (BUFFER));
+  memset (buf, 0, sizeof(BUFFER));
   return 0;
 }
 
@@ -1580,25 +1580,27 @@ parse_sort (struct option_t* dst, const char *s, const struct mapping_t *map,
 }
 
 /* if additional data more == 1, we want to resolve synonyms */
-static void mutt_set_default (const char* name, void* p, unsigned long more) {
-  char buf[LONG_STRING];
-  struct option_t* ptr = (struct option_t*) p;
+static void mutt_set_default(const char *name, void* p, unsigned long more)
+{
+    char buf[LONG_STRING];
+    struct option_t *ptr = p;
 
-  if (DTYPE (ptr->type) == DT_SYN) {
-    if (!more)
-      return;
-    ptr = hash_find (ConfigOptions, (char*) ptr->data);
-  }
-  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);
+    if (DTYPE(ptr->type) == DT_SYN) {
+        if (!more)
+            return;
+        ptr = hash_find(ConfigOptions, (const char *)ptr->data);
+    }
+    if (!ptr || *ptr->init || !FuncTable[DTYPE (ptr->type)].opt_from_string)
+        return;
+
+    mutt_option_value(ptr->option, buf, sizeof(buf));
+    if (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 dodup) {
-  struct option_t* option = mem_calloc (1, sizeof (struct option_t));
+  struct option_t* option = mem_calloc (1, sizeof(struct option_t));
 
   debug_print (1, ("adding $%s\n", name));
 
@@ -1636,8 +1638,8 @@ static int init_expand (char** dst, struct option_t* src) {
     /* 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));
+      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);
@@ -1675,7 +1677,7 @@ static void mutt_restore_default (const char* name, void* p,
   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))) {
+                                                       sizeof(errbuf))) {
       if (!option (OPTNOCURSES))
         mutt_endwin (NULL);
       fprintf (stderr, _("Invalid default setting for $%s found: \"%s\".\n"
@@ -2079,7 +2081,7 @@ static int source_rc (const char *rcfile, BUFFER * err)
     return (-1);
   }
 
-  memset (&token, 0, sizeof (token));
+  memset (&token, 0, sizeof(token));
   while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) {
     conv = ConfigCharset && (*ConfigCharset) && Charset;
     if (conv) {
@@ -2139,8 +2141,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));
+    strfcpy (path, tmp->data, sizeof(path));
+    mutt_expand_path (path, sizeof(path));
 
     rc += source_rc (path, err);
   }
@@ -2164,7 +2166,7 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err)
   int i, r = -1;
   BUFFER expn;
 
-  memset (&expn, 0, sizeof (expn));
+  memset (&expn, 0, sizeof(expn));
   expn.data = expn.dptr = line;
   expn.dsize = str_len (line);
 
@@ -2202,8 +2204,8 @@ finish:
 }
 
 
-#define NUMVARS (sizeof (MuttVars)/sizeof (MuttVars[0]))
-#define NUMCOMMANDS (sizeof (Commands)/sizeof (Commands[0]))
+#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 };
@@ -2251,12 +2253,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));
+      strfcpy (User_typed, pt, sizeof(User_typed));
+      memset (Matches, 0, sizeof(Matches));
+      memset (Completed, 0, sizeof(Completed));
       for (num = 0; Commands[num].name; num++)
         candidate (Completed, User_typed, Commands[num].name,
-                   sizeof (Completed));
+                   sizeof(Completed));
       Matches[Num_matched++] = User_typed;
 
       /* All matches are stored. Longest non-ambiguous string is ""
@@ -2271,10 +2273,10 @@ 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 */
@@ -2300,12 +2302,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));
+      strfcpy (User_typed, pt, sizeof(User_typed));
+      memset (Matches, 0, sizeof(Matches));
+      memset (Completed, 0, sizeof(Completed));
       for (num = 0; MuttVars[num].option; num++)
         candidate (Completed, User_typed, MuttVars[num].option,
-                   sizeof (Completed));
+                   sizeof(Completed));
       Matches[Num_matched++] = User_typed;
 
       /* All matches are stored. Longest non-ambiguous string is ""
@@ -2320,10 +2322,10 @@ 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);
@@ -2338,17 +2340,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));
+      strfcpy (User_typed, pt, sizeof(User_typed));
+      memset (Matches, 0, sizeof(Matches));
+      memset (Completed, 0, sizeof(Completed));
       for (num = 0; menu[num].name; num++)
-        candidate (Completed, User_typed, menu[num].name, sizeof (Completed));
+        candidate (Completed, User_typed, menu[num].name, sizeof(Completed));
       /* try the generic menu */
       if (Completed[0] == 0 && CurrentMenu != MENU_PAGER) {
         menu = OpGeneric;
         for (num = 0; menu[num].name; num++)
           candidate (Completed, User_typed, menu[num].name,
-                     sizeof (Completed));
+                     sizeof(Completed));
       }
       Matches[Num_matched++] = User_typed;
 
@@ -2364,10 +2366,10 @@ 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);
@@ -2398,7 +2400,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
     return 0;
 
   if (str_ncmp (buffer, "set", 3) == 0) {
-    strfcpy (var, pt, sizeof (var));
+    strfcpy (var, pt, sizeof(var));
     /* ignore the trailing '=' when comparing */
     var[str_len (var) - 1] = 0;
     if (!(option = hash_find (ConfigOptions, var)))
@@ -2414,18 +2416,18 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
       if ((DTYPE (option->type) == DT_STR) ||
           (DTYPE (option->type) == DT_PATH) ||
           (DTYPE (option->type) == DT_RX)) {
-        strfcpy (tmp, NONULL (*((char **) option->data)), sizeof (tmp));
+        strfcpy (tmp, NONULL (*((char **) option->data)), sizeof(tmp));
         if (DTYPE (option->type) == DT_PATH)
           mutt_pretty_mailbox (tmp);
       }
       else if (DTYPE (option->type) == DT_ADDR) {
-        rfc822_write_address (tmp, sizeof (tmp),
+        rfc822_write_address (tmp, sizeof(tmp),
                               *((ADDRESS **) option->data), 0);
       }
       else if (DTYPE (option->type) == DT_QUAD)
-        strfcpy (tmp, vals[quadoption (option->data)], sizeof (tmp));
+        strfcpy (tmp, vals[quadoption (option->data)], sizeof(tmp));
       else if (DTYPE (option->type) == DT_NUM)
-        snprintf (tmp, sizeof (tmp), "%d", (*((short *) option->data)));
+        snprintf (tmp, sizeof(tmp), "%d", (*((short *) option->data)));
       else if (DTYPE (option->type) == DT_SORT) {
         const struct mapping_t *map;
         const char *p;
@@ -2448,7 +2450,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
           break;
         }
         p = mutt_getnamebyvalue(*((short *) option->data) & SORT_MASK, map);
-        snprintf(tmp, sizeof (tmp), "%s%s%s",
+        snprintf(tmp, sizeof(tmp), "%s%s%s",
                  (*((short *)option->data) & SORT_REVERSE) ? "reverse-" : "",
                  (*((short *)option->data) & SORT_LAST) ? "last-" : "", p);
       }
@@ -2470,22 +2472,22 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
           default:
             p = "unknown";
         }
-        strfcpy (tmp, p, sizeof (tmp));
+        strfcpy (tmp, p, sizeof(tmp));
       }
       else if (DTYPE (option->type) == DT_BOOL)
         strfcpy (tmp, option (option->data) ? "yes" : "no",
-                 sizeof (tmp));
+                 sizeof(tmp));
       else
         return 0;
 
-      for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof (tmp2) - 2;) {
+      for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof(tmp2) - 2;) {
         if (*s == '\\' || *s == '"')
           *d++ = '\\';
         *d++ = *s++;
       }
       *d = '\0';
 
-      strfcpy (tmp, pt, sizeof (tmp));
+      strfcpy (tmp, pt, sizeof(tmp));
       snprintf (pt, dlen, "%s\"%s\"", tmp, tmp2);
 
       return 1;
@@ -2504,14 +2506,14 @@ int mutt_query_variables (LIST * queries)
 
   BUFFER err, token;
 
-  memset (&err, 0, sizeof (err));
-  memset (&token, 0, sizeof (token));
+  memset (&err, 0, sizeof(err));
+  memset (&token, 0, sizeof(token));
 
   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);
@@ -2549,10 +2551,10 @@ static int mutt_execute_commands (LIST * p)
   BUFFER err, token;
   char errstr[SHORT_STRING];
 
-  memset (&err, 0, sizeof (err));
+  memset (&err, 0, sizeof(err));
   err.data = errstr;
-  err.dsize = sizeof (errstr);
-  memset (&token, 0, sizeof (token));
+  err.dsize = sizeof(errstr);
+  memset (&token, 0, sizeof(token));
   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);
@@ -2573,13 +2575,13 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   int i, default_rc = 0, need_pause = 0;
   BUFFER err;
 
-  memset (&err, 0, sizeof (err));
+  memset (&err, 0, sizeof(err));
   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);
+  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);
@@ -2592,7 +2594,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   /*
    * 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
@@ -2608,7 +2610,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     if (!Homedir)
       Homedir = str_dup (pw->pw_dir);
 
-    Realname = str_dup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw));
+    Realname = str_dup (mutt_gecos_name (rnbuf, sizeof(rnbuf), pw));
     Shell = str_dup (pw->pw_shell);
     endpwent ();
   }
@@ -2636,14 +2638,14 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   if ((p = strchr (utsname.nodename, '.'))) {
     Hostname = str_substrdup (utsname.nodename, p);
     p++;
-    strfcpy (buffer, p, sizeof (buffer));       /* save the domain for below */
+    strfcpy (buffer, p, sizeof(buffer));       /* save the domain for below */
   }
   else
     Hostname = str_dup (utsname.nodename);
 
 #ifndef DOMAIN
 #define DOMAIN buffer
-  if (!p && getdnsdomainname (buffer, sizeof (buffer)) == -1)
+  if (!p && getdnsdomainname (buffer, sizeof(buffer)) == -1)
     Fqdn = str_dup ("@");
   else
 #endif /* DOMAIN */
@@ -2661,7 +2663,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
     if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) {
       buffer[0] = '\0';
-      fgets (buffer, sizeof (buffer), f);
+      fgets (buffer, sizeof(buffer), f);
       p = buffer;
       SKIPWS (p);
       q = (char*)p;
@@ -2682,9 +2684,9 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     Spoolfile = str_dup (p);
   else {
 #ifdef HOMESPOOL
-    mutt_concat_path (buffer, NONULL (Homedir), MAILPATH, sizeof (buffer));
+    mutt_concat_path (buffer, NONULL (Homedir), MAILPATH, sizeof(buffer));
 #else
-    mutt_concat_path (buffer, MAILPATH, NONULL (Username), sizeof (buffer));
+    mutt_concat_path (buffer, MAILPATH, NONULL (Username), sizeof(buffer));
 #endif
     Spoolfile = str_dup (buffer);
   }
@@ -2712,13 +2714,13 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   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));
+    memset (&buf, 0, sizeof(buf));
     buf.data = buf.dptr = buffer;
     buf.dsize = str_len (buffer);
 
-    memset (&token, 0, sizeof (token));
+    memset (&token, 0, sizeof(token));
     parse_my_hdr (&token, &buf, 0, &err);
     mem_free (&token.data);
   }
@@ -2771,27 +2773,27 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
   if (!Muttrc) {
 #if 0
-    snprintf (buffer, sizeof (buffer), "%s/.muttngrc-%s", NONULL (Homedir),
+    snprintf (buffer, sizeof(buffer), "%s/.muttngrc-%s", NONULL (Homedir),
               MUTT_VERSION);
     if (access (buffer, F_OK) == -1)
 #endif
-      snprintf (buffer, sizeof (buffer), "%s/.muttngrc", NONULL (Homedir));
+      snprintf (buffer, sizeof(buffer), "%s/.muttngrc", NONULL (Homedir));
     if (access (buffer, F_OK) == -1)
 #if 0
-      snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc-%s",
+      snprintf (buffer, sizeof(buffer), "%s/.muttng/muttngrc-%s",
                 NONULL (Homedir), MUTT_VERSION);
     if (access (buffer, F_OK) == -1)
 #endif
-      snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc",
+      snprintf (buffer, sizeof(buffer), "%s/.muttng/muttngrc",
                 NONULL (Homedir));
 
     default_rc = 1;
     Muttrc = str_dup (buffer);
   }
   else {
-    strfcpy (buffer, Muttrc, sizeof (buffer));
+    strfcpy (buffer, Muttrc, sizeof(buffer));
     mem_free (&Muttrc);
-    mutt_expand_path (buffer, sizeof (buffer));
+    mutt_expand_path (buffer, sizeof(buffer));
     Muttrc = str_dup (buffer);
   }
   mem_free (&AliasFile);
@@ -2800,15 +2802,15 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   /* Process the global rc file if it exists and the user hasn't explicity
      requested not to via "-n".  */
   if (!skip_sys_rc) {
-    snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", SYSCONFDIR,
+    snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", SYSCONFDIR,
               MUTT_VERSION);
     if (access (buffer, F_OK) == -1)
-      snprintf (buffer, sizeof (buffer), "%s/Muttngrc", SYSCONFDIR);
+      snprintf (buffer, sizeof(buffer), "%s/Muttngrc", SYSCONFDIR);
     if (access (buffer, F_OK) == -1)
-      snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", PKGDATADIR,
+      snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", PKGDATADIR,
                 MUTT_VERSION);
     if (access (buffer, F_OK) == -1)
-      snprintf (buffer, sizeof (buffer), "%s/Muttngrc", PKGDATADIR);
+      snprintf (buffer, sizeof(buffer), "%s/Muttngrc", PKGDATADIR);
     if (access (buffer, F_OK) != -1) {
       if (source_rc (buffer, &err) != 0) {
         fputs (err.data, stderr);
@@ -2830,7 +2832,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);
   }
@@ -2905,7 +2907,7 @@ static void opt_sel_diff (const char* key, void* data,
   if (DTYPE (option->type) == DT_SYN)
     return;
 
-  mutt_option_value (option->option, buf, sizeof (buf));
+  mutt_option_value (option->option, buf, sizeof(buf));
   if (str_cmp (buf, option->init) != 0)
     list_push_back (l, option);
 }
@@ -2923,11 +2925,11 @@ int mutt_dump_variables (int full) {
 
   if (!list_empty(tmp)) {
     /* ...and dump list sorted */
-    qsort (tmp->data, tmp->length, sizeof (void*), opt_cmp);
+    qsort (tmp->data, tmp->length, sizeof(void*), opt_cmp);
     for (i = 0; i < tmp->length; i++) {
       option = (struct option_t*) tmp->data[i];
       FuncTable[DTYPE (option->type)].opt_to_string
-        (outbuf, sizeof (outbuf), option);
+        (outbuf, sizeof(outbuf), option);
       printf ("%s\n", outbuf);
     }
   }
diff --git a/init.h b/init.h
index f411a0f..1d93b5a 100644
--- a/init.h
+++ b/init.h
@@ -122,7 +122,7 @@ struct option_t {
 # endif
 #endif
 
-struct option_t const MuttVars[] = {
+struct option_t MuttVars[] = {
   /*++*/
   {"abort_noattach", DT_QUAD, R_NONE, OPT_ATTACH, "no" },
   /*