From: Pierre Habouzit <madcoder@debian.org>
Date: Tue, 20 Nov 2007 23:30:22 +0000 (+0100)
Subject: Merge branch 'master' into nohook
X-Git-Url: http://git.madism.org/?a=commitdiff_plain;h=07066d3ea19865d08c4a8fd98b5e87eeace810da;hp=108e0b3c153adc852b07725cbe547f51ae08f436;p=apps%2Fmadmutt.git

Merge branch 'master' into nohook
---

diff --git a/charset.cpkg b/charset.cpkg
index 89905b8..a58b013 100644
--- a/charset.cpkg
+++ b/charset.cpkg
@@ -226,117 +226,41 @@ iconv_t mutt_iconv_open(const char *tocode, const char *fromcode, int flags)
         charset_canonicalize(from1, sizeof(from1), fromcode);
     }
 
+    m_strcat(to1, sizeof(to1), "//TRANSLIT");
     if ((cd = iconv_open(to1, from1)) != MUTT_ICONV_ERROR)
         return cd;
 
     if (rx_list_match2(iconv_hooks, to1, to2, sizeof(to2))
-    &&  rx_list_match2(iconv_hooks, from1, from2, sizeof(from2)))
+    &&  rx_list_match2(iconv_hooks, from1, from2, sizeof(from2))) {
+        m_strcat(to2, sizeof(to2), "//TRANSLIT");
         return iconv_open(to2, from2);
+    }
 
     return MUTT_ICONV_ERROR;
 }
 
 
-/* Like iconv, but keeps going even when the input is invalid
-   If you're supplying inrepls, the source charset should be stateless;
-   if you're supplying an outrepl, the target charset should be.  */
-/* XXX: MC: I do not understand what it does yet */
-ssize_t mutt_iconv(iconv_t cd,
-                   const char **inbuf, ssize_t *inbytesleft,
-                   char **outbuf, ssize_t *outbytesleft,
-                   const char **inrepls, const char *outrepl)
-{
-    ssize_t ret = 0, ret1;
-    const char *ib = *inbuf;
-    ssize_t ibl = *inbytesleft;
-    char *ob = *outbuf;
-    ssize_t obl = *outbytesleft;
-
-    for (;;) {
-        ret1 = my_iconv(cd, &ib, &ibl, &ob, &obl);
-        if (ret1 != -1)
-            ret += ret1;
-
-        if (ibl && obl && errno == EILSEQ) {
-            if (inrepls) {
-                /* Try replacing the input */
-                const char **t;
-
-                for (t = inrepls; *t; t++) {
-                    const char *ib1 = *t;
-                    ssize_t ibl1 = m_strlen(*t);
-                    char *ob1 = ob;
-                    ssize_t obl1 = obl;
-
-                    my_iconv(cd, &ib1, &ibl1, &ob1, &obl1);
-                    if (!ibl1) {
-                        ++ib, --ibl;
-                        ob = ob1, obl = obl1;
-                        ++ret;
-                        break;
-                    }
-                }
-                if (*t)
-                    continue;
-            }
-            /* Replace the output */
-            if (!outrepl)
-                outrepl = "?";
-            my_iconv(cd, 0, 0, &ob, &obl);
-            if (obl) {
-                ssize_t n = m_strlen(outrepl);
-
-                if (n > obl) {
-                    outrepl = "?";
-                    n = 1;
-                }
-                memcpy(ob, outrepl, n);
-                ++ib, --ibl;
-                ob += n, obl -= n;
-                ++ret;
-                my_iconv(cd, 0, 0, 0, 0); /* for good measure */
-                continue;
-            }
-        }
-        *inbuf = ib, *inbytesleft = ibl;
-        *outbuf = ob, *outbytesleft = obl;
-        return ret;
-    }
-}
-
 /* Convert a string */
 int
 mutt_convert_string(char **ps, const char *from, const char *to, int flags)
 {
     iconv_t cd;
-    const char *repls[] = { "\357\277\275", "?", 0 };
-
     if (m_strisempty(*ps))
         return 0;
 
     cd = mutt_iconv_open(to, from, flags);
     if (cd != MUTT_ICONV_ERROR) {
-        const char **inrepls = NULL;
-        const char *outrepl = NULL;
         const char *ib;
         char *buf, *ob;
         ssize_t ibl, obl;
 
-        if (charset_is_utf8(to))
-            outrepl = "\357\277\275";
-        else
-        if (charset_is_utf8(from))
-            inrepls = repls;
-        else
-            outrepl = "?";
-
         ibl = m_strlen(*ps) + 1;
         ib  = *ps;
 
         obl = MB_LEN_MAX * ibl;
         ob  = buf = p_new(char, obl + 1);
 
-        mutt_iconv(cd, &ib, &ibl, &ob, &obl, inrepls, outrepl);
+        mutt_iconv(cd, &ib, &ibl, &ob, &obl);
         iconv_close(cd);
 
         *ob = '\0';
@@ -364,9 +288,9 @@ static ssize_t convert_string(const char *f, ssize_t flen,
 
     obl = 4 * flen + 1;
     ob  = buf = p_new(char, obl);
-    n   = my_iconv(cd, &f, &flen, &ob, &obl);
+    n   = mutt_iconv(cd, &f, &flen, &ob, &obl);
 
-    if (n < 0 || my_iconv(cd, 0, 0, &ob, &obl) < 0) {
+    if (n < 0 || mutt_iconv(cd, 0, 0, &ob, &obl) < 0) {
         e = errno;
         p_delete(&buf);
         iconv_close(cd);
@@ -428,14 +352,11 @@ struct fgetconv_t {
     char *ob;
     char *ib;
     ssize_t ibl;
-    const char **inrepls;
 };
 
 fgetconv_t *
 fgetconv_open(FILE *file, const char *from, const char *to, int flags)
 {
-    static const char *repls[] = { "\357\277\275", "?", 0 };
-
     struct fgetconv_t *fc = p_new(struct fgetconv_t, 1);
 
     fc->file = file;
@@ -447,7 +368,6 @@ fgetconv_open(FILE *file, const char *from, const char *to, int flags)
         fc->p  = fc->ob = fc->bufo;
         fc->ib = fc->bufi;
         fc->ibl = 0;
-        fc->inrepls = repls + charset_is_utf8(to);
     }
     return fc;
 }
@@ -457,7 +377,7 @@ void fgetconv_close(fgetconv_t **fcp)
     struct fgetconv_t *fc = *fcp;
 
     if (fc->cd != MUTT_ICONV_ERROR)
-        iconv_close (fc->cd);
+        iconv_close(fc->cd);
     p_delete(fcp);
 }
 
@@ -480,7 +400,7 @@ int fgetconv(fgetconv_t *fc)
     if (fc->ibl) {
         ssize_t obl = ssizeof(fc->bufo);
 
-        my_iconv(fc->cd, (const char **)&fc->ib, &fc->ibl, &fc->ob, &obl);
+        mutt_iconv(fc->cd, (const char **)&fc->ib, &fc->ibl, &fc->ob, &obl);
         if (fc->p < fc->ob)
             return (unsigned char)*(fc->p)++;
     }
@@ -506,8 +426,7 @@ int fgetconv(fgetconv_t *fc)
     if (fc->ibl) {
         ssize_t obl = ssizeof(fc->bufo);
 
-        mutt_iconv(fc->cd, (const char **)&fc->ib, &fc->ibl, &fc->ob, &obl,
-                   fc->inrepls, 0);
+        mutt_iconv(fc->cd, (const char **)&fc->ib, &fc->ibl, &fc->ob, &obl);
         if (fc->p < fc->ob) {
             return (unsigned char)*(fc->p)++;
         }
diff --git a/charset.h b/charset.h
index 3b7566d..646526b 100644
--- a/charset.h
+++ b/charset.h
@@ -56,18 +56,15 @@ const char *charset_getfirst(const char *);
 
 #include <iconv.h>
 
+iconv_t mutt_iconv_open(const char *, const char *, int);
 static inline ssize_t
-my_iconv(iconv_t ict, const char **in, ssize_t *il, char **out, ssize_t *ol) {
+mutt_iconv(iconv_t ict, const char **in, ssize_t *il, char **out, ssize_t *ol) {
     return iconv(ict, (char **)in, (size_t*)il, out, (size_t*)ol);
 }
 
 #define M_ICONV_HOOK_FROM 1
 #define M_ICONV_HOOK_TO   2
 
-iconv_t mutt_iconv_open(const char *, const char *, int);
-ssize_t mutt_iconv(iconv_t, const char **, ssize_t *, char **, ssize_t *,
-                   const char **, const char *);
-
 int mutt_convert_string(char **, const char *, const char *, int);
 int mutt_convert_nonmime_string (char **);
 
diff --git a/crypt.cpkg b/crypt.cpkg
index 00a3285..8fde1ab 100644
--- a/crypt.cpkg
+++ b/crypt.cpkg
@@ -3402,6 +3402,23 @@ crypt_ask_for_key(const char *tag, int abilities, int app, int *forced_valid)
     }
 }
 
+static char *crypt_hook(address_t *adr)
+{
+    char *res = NULL;
+    lua_State *L = luaM_getruntime();
+    lua_getglobal(L, "mod_core");             /* push mod_core        1 */
+    lua_getfield(L, -1, "crypt_hook");        /* push folder_hook()   2 */
+    if (lua_isfunction(L, -1)) {
+        lua_pushstring(L, adr->mailbox);
+        if (!lua_pcall(L, 1, 1, 0)) {
+            res = m_strdup(lua_tostring(L, -1));
+        }
+        lua_pop(L, 1);
+    }
+    lua_pop(L, 2);
+    return res;
+}
+
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */
 static char *find_keys(ENVELOPE *env, unsigned int app)
@@ -3424,10 +3441,10 @@ static char *find_keys(ENVELOPE *env, unsigned int app)
     while ((addr = address_list_pop(&lst))) {
         char buf[STRING];
         int forced_valid = 0;
-        const char *keyID;
+        char *keyID;
         cryptkey_t *key = NULL;
 
-        if ((keyID = mutt_crypt_hook(addr))) {
+        if ((keyID = crypt_hook(addr))) {
             int r;
 
             snprintf(buf, sizeof(buf), _("Use keyID = \"%s\" for %s?"), keyID,
@@ -3438,6 +3455,7 @@ static char *find_keys(ENVELOPE *env, unsigned int app)
                 address_list_wipe(&lst);
                 address_list_wipe(&addr);
                 buffer_delete(&keylist);
+                p_delete(&keyID);
                 return NULL;
             }
 
@@ -3454,6 +3472,7 @@ static char *find_keys(ENVELOPE *env, unsigned int app)
                 }
             }
         }
+        p_delete(&keyID);
 
         if (!key) {
             key = crypt_getkeybyaddr(addr, KEYFLAG_CANENCRYPT, app, &forced_valid);
diff --git a/hook.c b/hook.c
index 37eda9e..95fd551 100644
--- a/hook.c
+++ b/hook.c
@@ -17,6 +17,7 @@
 #include "crypt.h"
 #include "pattern.h"
 
+#if 0
 typedef struct hook_t {
   int type;                     /* hook type */
   rx_t rx;                      /* regular expression */
@@ -36,252 +37,11 @@ DO_SLIST(hook_t, hook, hook_delete);
 
 static hook_t *Hooks = NULL;
 static unsigned long current_hook_type = 0;
-
-int mutt_parse_hook (BUFFER * buf __attribute__ ((unused)), BUFFER * s,
-                     unsigned long data, BUFFER * err)
-{
-  hook_t *ptr;
-  BUFFER command, pattern;
-  int rc, neg = 0;
-  regex_t *rx = NULL;
-  pattern_t *pat = NULL;
-  char path[_POSIX_PATH_MAX];
-
-  p_clear(&pattern, 1);
-  p_clear(&command, 1);
-
-  if (*s->dptr == '!') {
-    s->dptr = vskipspaces(s->dptr + 1);
-    neg = 1;
-  }
-
-  mutt_extract_token (&pattern, s, 0);
-
-  if (!MoreArgs (s)) {
-    m_strcpy(err->data, err->dsize, _("too few arguments"));
-    goto error;
-  }
-
-  mutt_extract_token(&command, s, (data & (M_FOLDERHOOK | M_SENDHOOK |
-                                           M_SEND2HOOK | M_REPLYHOOK)) ?
-                     M_TOKEN_SPACE : 0);
-
-  if (!command.data) {
-    m_strcpy(err->data, err->dsize, _("too few arguments"));
-    goto error;
-  }
-
-  if (MoreArgs (s)) {
-    m_strcpy(err->data, err->dsize, _("too many arguments"));
-    goto error;
-  }
-
-  if (data & (M_FOLDERHOOK | M_MBOXHOOK)) {
-    _mutt_expand_path (path, sizeof (path), pattern.data, 1);
-    p_delete(&pattern.data);
-    p_clear(&pattern, 1);
-    pattern.data = m_strdup(path);
-  }
-  else if (data & (M_APPENDHOOK | M_OPENHOOK | M_CLOSEHOOK)) {
-    if (mutt_test_compress_command (command.data)) {
-      m_strcpy(err->data, err->dsize, _("bad formatted command string"));
-      return (-1);
-    }
-  }
-  else if (DefaultHook && !(data & M_CRYPTHOOK))
-  {
-    char tmp[HUGE_STRING];
-
-    m_strcpy(tmp, sizeof(tmp), pattern.data);
-    mutt_check_simple (tmp, sizeof (tmp), DefaultHook);
-    p_delete(&pattern.data);
-    p_clear(&pattern, 1);
-    pattern.data = m_strdup(tmp);
-  }
-
-  if (data & (M_MBOXHOOK | M_SAVEHOOK | M_FCCHOOK)) {
-    m_strcpy(path, sizeof(path), command.data);
-    mutt_expand_path (path, sizeof (path));
-    p_delete(&command.data);
-    p_clear(&command, 1);
-    command.data = m_strdup(path);
-  }
-
-  /* check to make sure that a matching hook doesn't already exist */
-  for (ptr = Hooks; ptr; ptr = ptr->next) {
-    if (ptr->type == (int)data &&
-        ptr->rx.neg == neg && !m_strcmp(pattern.data, ptr->rx.pattern)) {
-      if (data & (M_FOLDERHOOK | M_SENDHOOK | M_SEND2HOOK | M_MESSAGEHOOK |
-           M_REPLYHOOK))
-      {
-        /* these hooks allow multiple commands with the same
-         * pattern, so if we've already seen this pattern/command pair, just
-         * ignore it instead of creating a duplicate */
-        if (!m_strcmp(ptr->command, command.data)) {
-          p_delete(&command.data);
-          p_delete(&pattern.data);
-          return 0;
-        }
-      } else {
-        /* other hooks only allow one command per pattern, so update the
-         * entry with the new command.  this currently does not change the
-         * order of execution of the hooks, which i think is desirable since
-         * a common action to perform is to change the default (.) entry
-         * based upon some other information. */
-        p_delete(&ptr->command);
-        ptr->command = command.data;
-        p_delete(&pattern.data);
-        return 0;
-      }
-    }
-    if (!ptr->next)
-      break;
-  }
-
-  if (data & (M_SENDHOOK | M_SEND2HOOK | M_SAVEHOOK | M_FCCHOOK |
-              M_MESSAGEHOOK | M_REPLYHOOK))
-  {
-    if ((pat =
-         mutt_pattern_comp (pattern.data,
-                            (data & (M_SENDHOOK | M_SEND2HOOK | M_FCCHOOK)) ?
-                            0 : M_FULL_MSG, err)) == NULL)
-      goto error;
-  } else {
-    rx = p_new(regex_t, 1);
-    if ((rc = REGCOMP(rx, NONULL(pattern.data),
-                  ((data & M_CRYPTHOOK) ? REG_ICASE : 0))) != 0)
-    {
-      regerror (rc, rx, err->data, err->dsize);
-      regfree (rx);
-      p_delete(&rx);
-      goto error;
-    }
-  }
-
-  if (ptr) {
-    ptr->next = p_new(hook_t, 1);
-    ptr = ptr->next;
-  } else {
-    Hooks = ptr = p_new(hook_t, 1);
-  }
-  ptr->type = data;
-  ptr->command = command.data;
-  ptr->pattern = pat;
-  ptr->rx.pattern = pattern.data;
-  ptr->rx.rx = rx;
-  ptr->rx.neg = neg;
-  return 0;
-
-error:
-  p_delete(&pattern.data);
-  p_delete(&command.data);
-  return (-1);
-}
-
-/* Deletes all hooks of type ``type'', or all defined hooks if ``type'' is 0 */
-static void delete_hooks (long type)
-{
-    hook_t **l = &Hooks;
-
-    while (*l) {
-        if ((*l)->type == type) {
-            hook_t *tmp = hook_list_pop(l);
-            hook_delete(&tmp);
-        } else {
-            l = &(*l)->next;
-        }
-    }
-}
-
-int mutt_parse_unhook (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
-                       BUFFER * err)
-{
-  while (MoreArgs (s)) {
-    mutt_extract_token (buf, s, 0);
-    if (m_strcmp("*", buf->data) == 0) {
-      if (current_hook_type) {
-        snprintf (err->data, err->dsize,
-                  _("unhook: Can't do unhook * from within a hook."));
-        return -1;
-      }
-      hook_list_wipe(&Hooks);
-    } else {
-      unsigned long type = mutt_get_hook_type (buf->data);
-
-      if (!type) {
-        snprintf (err->data, err->dsize,
-                  _("unhook: unknown hook type: %s"), buf->data);
-        return (-1);
-      }
-      if (current_hook_type == type) {
-        snprintf (err->data, err->dsize,
-                  _("unhook: Can't delete a %s from within a %s."), buf->data,
-                  buf->data);
-        return -1;
-      }
-      delete_hooks (type);
-    }
-  }
-  return 0;
-}
-
-void mutt_folder_hook (char *path)
-{
-  hook_t *tmp = Hooks;
-  BUFFER err, token;
-  char buf[STRING];
-
-  current_hook_type = M_FOLDERHOOK;
-
-  err.data = buf;
-  err.dsize = sizeof (buf);
-  p_clear(&token, 1);
-  for (; tmp; tmp = tmp->next) {
-    if (!tmp->command)
-      continue;
-
-    if (tmp->type & M_FOLDERHOOK) {
-      if ((regexec (tmp->rx.rx, path, 0, NULL, 0) == 0) ^ tmp->rx.neg) {
-        if (mutt_parse_rc_line (tmp->command, &token, &err) == -1) {
-          mutt_error ("%s", err.data);
-          mutt_sleep (1);       /* pause a moment to let the user see the error */
-        }
-      }
-    }
-  }
-  p_delete(&token.data);
-
-  current_hook_type = 0;
-
-    {
-        lua_State *L = luaM_getruntime();
-        lua_getfield(L, LUA_GLOBALSINDEX, "mod_core");
-        lua_getfield(L, -1, "folder_hook");
-        lua_remove(L, -2);
-        if (lua_isfunction(L, -1)) {
-            lua_pushstring(L, LastFolder);
-            lua_pushstring(L, CurrentFolder);
-            lua_pcall(L, 2, 0, 0);
-        } else {
-            lua_pop(L, 1);
-        }
-    }
-}
-
-char *mutt_find_hook (int type, const char *pat)
-{
-  hook_t *tmp = Hooks;
-
-  for (; tmp; tmp = tmp->next)
-    if (tmp->type & type) {
-      if (regexec (tmp->rx.rx, pat, 0, NULL, 0) == 0)
-        return (tmp->command);
-    }
-  return (NULL);
-}
+#endif
 
 void mutt_message_hook (CONTEXT * ctx, HEADER * hdr, int type)
 {
+#if 0
   BUFFER err, token;
   hook_t *hook;
   char buf[STRING];
@@ -304,76 +64,47 @@ void mutt_message_hook (CONTEXT * ctx, HEADER * hdr, int type)
   }
   p_delete(&token.data);
   current_hook_type = 0;
+#endif
 }
 
-static int
-mutt_addr_hook (char *path, ssize_t pathlen, unsigned long type, CONTEXT * ctx,
-                HEADER * hdr)
-{
-  hook_t *hook;
-
-  /* determine if a matching hook exists */
-  for (hook = Hooks; hook; hook = hook->next) {
-    if (!hook->command)
-      continue;
-
-    if (hook->type & type)
-      if ((mutt_pattern_exec (hook->pattern, 0, ctx, hdr) > 0) ^ hook->rx.neg) {
-        mutt_make_string (path, pathlen, hook->command, ctx, hdr);
-        return 0;
-      }
-  }
-
-  return -1;
-}
-
-void mutt_default_save (char *path, ssize_t pathlen, HEADER * hdr)
-{
-  *path = 0;
-  if (mutt_addr_hook (path, pathlen, M_SAVEHOOK, Context, hdr) != 0) {
-    char tmp[_POSIX_PATH_MAX];
-    address_t *adr;
-    ENVELOPE *env = hdr->env;
-    int fromMe = mutt_addr_is_user (env->from);
-
-    if (!fromMe && env->reply_to && env->reply_to->mailbox)
-      adr = env->reply_to;
-    else if (!fromMe && env->from && env->from->mailbox)
-      adr = env->from;
-    else if (env->to && env->to->mailbox)
-      adr = env->to;
-    else if (env->cc && env->cc->mailbox)
-      adr = env->cc;
-    else
-      adr = NULL;
-    if (adr) {
-      mutt_safe_path (tmp, sizeof (tmp), adr);
-      snprintf (path, pathlen, "=%s", tmp);
-    }
-  }
-}
-
-void mutt_select_fcc (char *path, ssize_t pathlen, HEADER * hdr)
+/* Deletes all hooks of type ``type'', or all defined hooks if ``type'' is 0 */
+void mutt_folder_hook (char *path)
 {
-    if (mutt_addr_hook (path, pathlen, M_FCCHOOK, NULL, hdr) != 0) {
-        m_strcpy(path, pathlen, NONULL(MAlias.record));
+    lua_State *L = luaM_getruntime();
+    lua_getglobal(L, "mod_core");             /* push mod_core        1 */
+    lua_getfield(L, -1, "folder_hook");       /* push folder_hook()   2 */
+    if (lua_isfunction(L, -1)) {
+        lua_pushstring(L, LastFolder);
+        lua_pushstring(L, CurrentFolder);
+        if (lua_pcall(L, 2, 0, 0)) {
+            lua_pop(L, 3);
+            return;
+        }
     }
-    mutt_pretty_mailbox (path);
+    lua_pop(L, 2);
 }
 
-static const char *_mutt_string_hook (const char *match, int hook)
+void mutt_default_save (char *path, ssize_t pathlen, HEADER * hdr)
 {
-  hook_t *tmp = Hooks;
-
-  for (; tmp; tmp = tmp->next) {
-    if ((tmp->type & hook)
-    && ((match && regexec(tmp->rx.rx, match, 0, NULL, 0) == 0) ^ tmp->rx.neg))
-      return (tmp->command);
+  char tmp[_POSIX_PATH_MAX];
+  address_t *adr;
+  ENVELOPE *env = hdr->env;
+  int fromMe = mutt_addr_is_user (env->from);
+
+  if (!fromMe && env->reply_to && env->reply_to->mailbox)
+    adr = env->reply_to;
+  else if (!fromMe && env->from && env->from->mailbox)
+    adr = env->from;
+  else if (env->to && env->to->mailbox)
+    adr = env->to;
+  else if (env->cc && env->cc->mailbox)
+    adr = env->cc;
+  else
+    adr = NULL;
+  if (adr) {
+    mutt_safe_path (tmp, sizeof (tmp), adr);
+    snprintf (path, pathlen, "=%s", tmp);
+  } else {
+    *path = 0;
   }
-  return (NULL);
-}
-
-const char *mutt_crypt_hook (address_t * adr)
-{
-  return _mutt_string_hook (adr->mailbox, M_CRYPTHOOK);
 }
diff --git a/init.c b/init.c
index 323d5ac..9b9346e 100644
--- a/init.c
+++ b/init.c
@@ -1767,13 +1767,3 @@ void mutt_init (int skip_sys_rc, string_list_t * commands)
   }
 }
 
-int mutt_get_hook_type (const char *name)
-{
-  struct command_t *c;
-
-  for (c = Commands; c->name; c++)
-    if (c->func == mutt_parse_hook && ascii_strcasecmp (c->name, name) == 0)
-      return c->data;
-  return 0;
-}
-
diff --git a/init.h b/init.h
index 7f6bcb9..feedd18 100644
--- a/init.h
+++ b/init.h
@@ -210,7 +210,7 @@ struct option_t MuttVars[] = {
    ** checking each file to see if it has already been looked at.  If it's
    ** \fIunset\fP, no check for new mail is performed while the mailbox is open.
    */
-  {"collapse_unread", DT_BOOL, OPTCOLLAPSEUNREAD, "yes" },
+  {"collapse_unread", DT_BOOL, OPTCOLLAPSEUNREAD, "no" },
   /*
    ** .pp
    ** When \fIunset\fP, Madmutt will not collapse a thread if it contains any
@@ -2023,24 +2023,9 @@ struct command_t Commands[] = {
     {"bind",                mutt_parse_bind,       0},
     {"color",               mutt_parse_color,      0},
     {"exec",                mutt_parse_exec,       0},
-    {"append-hook",         mutt_parse_hook,       M_APPENDHOOK},
-    {"close-hook",          mutt_parse_hook,       M_CLOSEHOOK},
-    {"crypt-hook",          mutt_parse_hook,       M_CRYPTHOOK},
-    {"fcc-hook",            mutt_parse_hook,       M_FCCHOOK},
-    {"fcc-save-hook",       mutt_parse_hook,       M_FCCHOOK|M_SAVEHOOK},
-    {"folder-hook",         mutt_parse_hook,       M_FOLDERHOOK},
-    {"mbox-hook",           mutt_parse_hook,       M_MBOXHOOK},
-    {"message-hook",        mutt_parse_hook,       M_MESSAGEHOOK},
-    {"open-hook",           mutt_parse_hook,       M_OPENHOOK},
-    {"pgp-hook",            mutt_parse_hook,       M_CRYPTHOOK},
-    {"reply-hook",          mutt_parse_hook,       M_REPLYHOOK},
-    {"save-hook",           mutt_parse_hook,       M_SAVEHOOK},
-    {"send2-hook",          mutt_parse_hook,       M_SEND2HOOK},
-    {"send-hook",           mutt_parse_hook,       M_SENDHOOK},
     {"macro",               mutt_parse_macro,      0},
     {"push",                mutt_parse_push,       0},
     {"uncolor",             mutt_parse_uncolor,    0},
-    {"unhook",              mutt_parse_unhook,     0},
     {"alias",               parse_alias,           0},
     {"attachments",         parse_attachments,     0 },
     {"my_hdr",              parse_my_hdr,          0},
diff --git a/lib-mime/rfc2047.c b/lib-mime/rfc2047.c
index 1d42403..a2629a9 100644
--- a/lib-mime/rfc2047.c
+++ b/lib-mime/rfc2047.c
@@ -69,9 +69,9 @@ convert_string(const char *from, const char *f, ssize_t flen,
 
     obl = 4 * flen + 1;
     ob = buf = p_new(char, obl);
-    n = my_iconv(cd, &f, &flen, &ob, &obl);
+    n = mutt_iconv(cd, &f, &flen, &ob, &obl);
 
-    if (n < 0 || my_iconv(cd, 0, 0, &ob, &obl) < 0) {
+    if (n < 0 || mutt_iconv(cd, 0, 0, &ob, &obl) < 0) {
         int e = errno;
         iconv_close(cd);
         errno = e;
@@ -266,14 +266,14 @@ static size_t try_block(const char *d, ssize_t dlen,
 
         ob = buf1;
 
-        if (my_iconv(cd, &ib, &ibl, &ob, &obl) < 0
-        ||  my_iconv(cd, 0, 0, &ob, &obl) < 0)
+        if (mutt_iconv(cd, &ib, &ibl, &ob, &obl) < 0
+        ||  mutt_iconv(cd, 0, 0, &ob, &obl) < 0)
         {
             assert (errno == E2BIG && ib > d);
             iconv_close(cd);
             return (ib - d == dlen) ? dlen : ib - d + 1;
         }
-        iconv_close (cd);
+        iconv_close(cd);
     } else {
         if (dlen > obl)
             return obl + 1;
@@ -331,10 +331,10 @@ encode_block(char *s, char *d, ssize_t dlen,
         cd = mutt_iconv_open(tocode, fromcode, 0);
         assert (cd != MUTT_ICONV_ERROR);
         ib = d, ibl = dlen, ob = buf1, obl = sizeof(buf1) - m_strlen(tocode);
-        n1 = my_iconv(cd, &ib, &ibl, &ob, &obl);
-        n2 = my_iconv(cd, 0, 0, &ob, &obl);
+        n1 = mutt_iconv(cd, &ib, &ibl, &ob, &obl);
+        n2 = mutt_iconv(cd, 0, 0, &ob, &obl);
         assert (n1 >= 0 && n2 >= 0);
-        iconv_close (cd);
+        iconv_close(cd);
         return (*encoder)(s, buf1, ob - buf1, tocode);
     } else {
         return (*encoder)(s, d, dlen, tocode);
diff --git a/lib-mx/compress.c b/lib-mx/compress.c
index 1b6d4f0..01e4a07 100644
--- a/lib-mx/compress.c
+++ b/lib-mx/compress.c
@@ -64,9 +64,24 @@ static int is_new (const char *path)
 
 static const char *find_compress_hook (int type, const char *path)
 {
-  const char *c = mutt_find_hook (type, path);
-
-  return (!c || !*c) ? NULL : c;
+  int len = strlen(path);
+  if (len > 3 && !strcmp(path + len - 3, ".gz")) {
+      switch (type) {
+        case M_OPENHOOK:   return "gzip -cd %f > %t";
+        case M_CLOSEHOOK:  return "gzip -cd %t > %f";
+        case M_APPENDHOOK: return "gzip -cd %t >> %f";
+        default: return NULL;
+      }
+  }
+  if (len > 4 && !strcmp(path + len - 4, ".bz2")) {
+      switch (type) {
+        case M_OPENHOOK:   return "bzip2 -cd %f > %t";
+        case M_CLOSEHOOK:  return "bzip2 -cd %t > %f";
+        case M_APPENDHOOK: return "bzip2 -cd %t >> %f";
+        default: return NULL;
+      }
+  }
+  return NULL;
 }
 
 int mutt_can_read_compressed (const char *path)
diff --git a/lib-mx/hcache.c b/lib-mx/hcache.c
index a82921b..01db5bd 100644
--- a/lib-mx/hcache.c
+++ b/lib-mx/hcache.c
@@ -476,7 +476,7 @@ void mutt_hcache_delete(hcache_t *db, const char *filename,
     char path[_POSIX_PATH_MAX];
 
     if (!db)
-        return -1;
+        return;
 
     snprintf(path, sizeof(path), "%s%s", db->folder, filename);
 
diff --git a/lib-mx/mx.c b/lib-mx/mx.c
index baae76f..b41a079 100644
--- a/lib-mx/mx.c
+++ b/lib-mx/mx.c
@@ -518,16 +518,8 @@ static int _mx_close_mailbox (CONTEXT * ctx, int *index_hint)
   }
 
   if (read_msgs && quadoption (OPT_MOVE) != M_NO) {
-    char *p;
-
-    if ((p = mutt_find_hook (M_MBOXHOOK, ctx->path))) {
-      isSpool = 1;
-      m_strcpy(mbox, sizeof(mbox), p);
-    }
-    else {
-      m_strcpy(mbox, sizeof(mbox), NONULL(Inbox));
-      isSpool = mutt_is_spool (ctx->path) && !mutt_is_spool (mbox);
-    }
+    m_strcpy(mbox, sizeof(mbox), NONULL(Inbox));
+    isSpool = mutt_is_spool (ctx->path) && !mutt_is_spool (mbox);
     mutt_expand_path (mbox, sizeof (mbox));
 
     if (isSpool) {
diff --git a/protos.h b/protos.h
index 560a1b2..dec0ccf 100644
--- a/protos.h
+++ b/protos.h
@@ -38,10 +38,8 @@ int mutt_cmp_header (const HEADER*, const HEADER*);
 ssize_t _mutt_expand_path(char *, ssize_t, const char *, int);
 #define mutt_expand_path(s, n) _mutt_expand_path((s), (n), (s), 0)
 
-char *mutt_find_hook (int, const char *);
 char *mutt_get_body_charset (char *, ssize_t, BODY *);
 const char *mutt_get_name (address_t *);
-const char *mutt_crypt_hook (address_t *);
 char *mutt_make_date (char *, ssize_t);
 
 const char *mutt_fqdn (short);
@@ -73,7 +71,6 @@ void mutt_pipe_message (HEADER *);
 void mutt_print_message (HEADER *);
 void mutt_safe_path (char *s, ssize_t l, address_t * a);
 void mutt_save_path (char *s, ssize_t l, address_t * a);
-void mutt_select_fcc (char *, ssize_t, HEADER *);
 
 void mutt_message_hook (CONTEXT *, HEADER *, int);
 void _mutt_set_flag (CONTEXT *, HEADER *, int, int, int);
@@ -102,7 +99,6 @@ int mutt_fetch_recips (ENVELOPE * out, ENVELOPE * in, int flags);
 int mutt_prepare_template (FILE *, CONTEXT *, HEADER *, HEADER *, short);
 int mutt_resend_message (FILE *, CONTEXT *, HEADER *);
 
-int mutt_get_hook_type (const char *);
 int mutt_get_postponed (CONTEXT *, HEADER *, HEADER **, char *, ssize_t);
 int mutt_invoke_mta (address_t *, address_t *, address_t *, address_t *, const char *,
                      int);
@@ -112,11 +108,9 @@ int mutt_lookup_mime_type (BODY *, const char *);
 int mutt_num_postponed (int);
 int mutt_parse_bind (BUFFER *, BUFFER *, unsigned long, BUFFER *);
 int mutt_parse_exec (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_hook (BUFFER *, BUFFER *, unsigned long, BUFFER *);
 int mutt_parse_macro (BUFFER *, BUFFER *, unsigned long, BUFFER *);
 int mutt_parse_push (BUFFER *, BUFFER *, unsigned long, BUFFER *);
 int mutt_parse_rc_line (const char *, BUFFER *, BUFFER *);
-int mutt_parse_unhook (BUFFER *, BUFFER *, unsigned long, BUFFER *);
 int _mutt_save_message (HEADER *, CONTEXT *, int, int, int);
 int mutt_save_message (HEADER *, int, int, int, int *);
 int mutt_search_command (int, int);
diff --git a/send.c b/send.c
index cd82ede..d077993 100644
--- a/send.c
+++ b/send.c
@@ -1340,7 +1340,8 @@ int ci_send_message (int flags, /* send mode */
       killfrom = 1;             /* no need to check $use_from because if the user specified
                                    a from address it would have already been set by now */
     }
-    mutt_select_fcc (fcc, sizeof (fcc), msg);
+    m_strcpy(fcc, sizeof(fcc), NONULL(MAlias.record));
+    mutt_pretty_mailbox(fcc);
     if (killfrom) {
       address_list_wipe(&msg->env->from);
       killfrom = 0;
diff --git a/sendlib.c b/sendlib.c
index 1f15e17..5e5faf0 100644
--- a/sendlib.c
+++ b/sendlib.c
@@ -566,7 +566,7 @@ static ssize_t convert_file_to (FILE * file, const char *fromcode,
     /* Convert to UTF-8 */
     ib = bufi;
     ob = bufu, obl = sizeof (bufu);
-    n = my_iconv(cd1, ibl ? &ib : 0, &ibl, &ob, &obl);
+    n = mutt_iconv(cd1, ibl ? &ib : 0, &ibl, &ob, &obl);
     if (n == -1 && ((errno != EINVAL && errno != E2BIG) || ib == bufi)) {
       ret = -1;
       break;
@@ -578,7 +578,7 @@ static ssize_t convert_file_to (FILE * file, const char *fromcode,
       if (cd[i] != MUTT_ICONV_ERROR && score[i] != -1) {
         ub = bufu, ubl = ubl1;
         ob = bufo, obl = sizeof (bufo);
-        n = my_iconv(cd[i], (ibl || ubl) ? &ub : 0, &ubl, &ob, &obl);
+        n = mutt_iconv(cd[i], (ibl || ubl) ? &ub : 0, &ubl, &ob, &obl);
         if (n == -1) {
           score[i] = -1;
         }
@@ -627,9 +627,9 @@ static ssize_t convert_file_to (FILE * file, const char *fromcode,
 
   for (i = 0; i < ncodes; i++)
     if (cd[i] != MUTT_ICONV_ERROR)
-      iconv_close (cd[i]);
+      iconv_close(cd[i]);
 
-  iconv_close (cd1);
+  iconv_close(cd1);
   p_delete(&cd);
   p_delete(&infos);
   p_delete(&score);
diff --git a/state.c b/state.c
index f21db7e..12edf41 100644
--- a/state.c
+++ b/state.c
@@ -33,7 +33,7 @@ void mutt_convert_to_state (iconv_t cd, char *bufi, ssize_t * l, STATE * s)
   if (!bufi) {
     if (cd != MUTT_ICONV_ERROR) {
       ob = bufo, obl = sizeof (bufo);
-      my_iconv(cd, 0, 0, &ob, &obl);
+      mutt_iconv(cd, 0, 0, &ob, &obl);
       if (ob != bufo)
         state_prefix_put (bufo, ob - bufo, s);
     }
@@ -51,7 +51,7 @@ void mutt_convert_to_state (iconv_t cd, char *bufi, ssize_t * l, STATE * s)
   ib = bufi, ibl = *l;
   for (;;) {
     ob = bufo, obl = sizeof (bufo);
-    mutt_iconv (cd, &ib, &ibl, &ob, &obl, 0, "?");
+    mutt_iconv (cd, &ib, &ibl, &ob, &obl);
     if (ob == bufo)
       break;
     state_prefix_put (bufo, ob - bufo, s);