Further pop_mx_ng work
[apps/madmutt.git] / handler.c
index 9a90f6f..f75fab1 100644 (file)
--- a/handler.c
+++ b/handler.c
  * please see the file GPL in the top level source directory.
  */
 
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include <lib-lib/lib-lib.h>
 
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <ctype.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
+#include <lib-mime/mime.h>
+#include <lib-mime/rfc3676.h>
+
+#include <lib-ui/lib-ui.h>
+
+#include <lib-sys/unix.h>
 
 #include "mutt.h"
-#include "mutt_curses.h"
-#include "rfc1524.h"
+#include "recvattach.h"
+#include "handler.h"
 #include "keymap.h"
-#include "mime.h"
 #include "copy.h"
 #include "charset.h"
-#include "mutt_crypt.h"
-#include "lib.h"
-
+#include "crypt.h"
+#include "state.h"
+#include "attach.h"
 
-#define BUFI_SIZE 1000
-#define BUFO_SIZE 2000
-
-
-typedef void handler_f (BODY *, STATE *);
+typedef int handler_f (BODY *, STATE *);
 typedef handler_f *handler_t;
 
-int Index_hex[128] = {
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
-  -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-};
-
-int Index_64[128] = {
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
-  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-  -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
-};
-
-static void state_prefix_put (const char *d, size_t dlen, STATE * s)
-{
-  if (s->prefix)
-    while (dlen--)
-      state_prefix_putc (*d++, s);
-  else
-    fwrite (d, dlen, 1, s->fpout);
-}
-
-void mutt_convert_to_state (iconv_t cd, char *bufi, size_t * l, STATE * s)
-{
-  char bufo[BUFO_SIZE];
-  ICONV_CONST char *ib;
-  char *ob;
-  size_t ibl, obl;
-
-  if (!bufi) {
-    if (cd != (iconv_t) (-1)) {
-      ob = bufo, obl = sizeof (bufo);
-      iconv (cd, 0, 0, &ob, &obl);
-      if (ob != bufo)
-        state_prefix_put (bufo, ob - bufo, s);
-    }
-    if (Quotebuf[0] != '\0')
-      state_prefix_putc ('\n', s);
-    return;
-  }
-
-  if (cd == (iconv_t) (-1)) {
-    state_prefix_put (bufi, *l, s);
-    *l = 0;
-    return;
-  }
-
-  ib = bufi, ibl = *l;
-  for (;;) {
-    ob = bufo, obl = sizeof (bufo);
-    mutt_iconv (cd, &ib, &ibl, &ob, &obl, 0, "?");
-    if (ob == bufo)
-      break;
-    state_prefix_put (bufo, ob - bufo, s);
-  }
-  memmove (bufi, ib, ibl);
-  *l = ibl;
-}
-
-void mutt_decode_xbit (STATE * s, long len, int istext, iconv_t cd)
+static void mutt_decode_xbit (STATE * s, long len, int istext, iconv_t cd)
 {
   int c, ch;
   char bufi[BUFI_SIZE];
-  size_t l = 0;
+  ssize_t l = 0;
 
   if (istext) {
     state_set_prefix (s);
@@ -155,7 +80,7 @@ static int qp_decode_triple (char *s, char *d)
   return -1;
 }
 
-static void qp_decode_line (char *dest, char *src, size_t * l, int last)
+static void qp_decode_line (char *dest, char *src, ssize_t * l, int last)
 {
   char *d, *s;
   char c;
@@ -212,13 +137,13 @@ static void qp_decode_line (char *dest, char *src, size_t * l, int last)
  * 
  */
 
-void mutt_decode_quoted (STATE * s, long len, int istext, iconv_t cd)
+static void mutt_decode_quoted (STATE * s, long len, int istext, iconv_t cd)
 {
-  char line[STRING];
-  char decline[2 * STRING];
-  size_t l = 0;
-  size_t linelen;               /* number of input bytes in `line' */
-  size_t l3;
+  char line[10 * STRING];
+  char decline[20 * STRING];
+  ssize_t l = 0;
+  ssize_t linelen;               /* number of input bytes in `line' */
+  ssize_t l3;
 
   int last;                     /* store the last character in the input line */
 
@@ -238,7 +163,7 @@ void mutt_decode_quoted (STATE * s, long len, int istext, iconv_t cd)
     if (fgets (line, MIN ((ssize_t) sizeof (line), len + 1), s->fpin) == NULL)
       break;
 
-    linelen = strlen (line);
+    linelen = m_strlen(line);
     len -= linelen;
 
     /*
@@ -257,6 +182,7 @@ void mutt_decode_quoted (STATE * s, long len, int istext, iconv_t cd)
     /* decode and do character set conversion */
     qp_decode_line (decline + l, line, &l3, last);
     l += l3;
+    assert (l < sizeof(decline));
     mutt_convert_to_state (cd, decline, &l, s);
   }
 
@@ -264,101 +190,18 @@ void mutt_decode_quoted (STATE * s, long len, int istext, iconv_t cd)
   state_reset_prefix (s);
 }
 
-void mutt_decode_base64 (STATE * s, long len, int istext, iconv_t cd)
-{
-  char buf[5];
-  int c1, c2, c3, c4, ch, cr = 0, i;
-  char bufi[BUFI_SIZE];
-  size_t l = 0;
-
-  buf[4] = 0;
-
-  if (istext)
-    state_set_prefix (s);
-
-  while (len > 0) {
-    for (i = 0; i < 4 && len > 0; len--) {
-      if ((ch = fgetc (s->fpin)) == EOF)
-        break;
-      if (ch >= 0 && ch < 128 && (base64val (ch) != -1 || ch == '='))
-        buf[i++] = ch;
-    }
-    if (i != 4) {
-      dprint (2, (debugfile, "%s:%d [mutt_decode_base64()]: "
-                  "didn't get a multiple of 4 chars.\n", __FILE__, __LINE__));
-      break;
-    }
-
-    c1 = base64val (buf[0]);
-    c2 = base64val (buf[1]);
-    ch = (c1 << 2) | (c2 >> 4);
-
-    if (cr && ch != '\n')
-      bufi[l++] = '\r';
-
-    cr = 0;
-
-    if (istext && ch == '\r')
-      cr = 1;
-    else
-      bufi[l++] = ch;
-
-    if (buf[2] == '=')
-      break;
-    c3 = base64val (buf[2]);
-    ch = ((c2 & 0xf) << 4) | (c3 >> 2);
-
-    if (cr && ch != '\n')
-      bufi[l++] = '\r';
-
-    cr = 0;
-
-    if (istext && ch == '\r')
-      cr = 1;
-    else
-      bufi[l++] = ch;
-
-    if (buf[3] == '=')
-      break;
-    c4 = base64val (buf[3]);
-    ch = ((c3 & 0x3) << 6) | c4;
-
-    if (cr && ch != '\n')
-      bufi[l++] = '\r';
-    cr = 0;
-
-    if (istext && ch == '\r')
-      cr = 1;
-    else
-      bufi[l++] = ch;
-
-    if (l + 8 >= sizeof (bufi))
-      mutt_convert_to_state (cd, bufi, &l, s);
-  }
-
-  if (cr)
-    bufi[l++] = '\r';
-
-  mutt_convert_to_state (cd, bufi, &l, s);
-  mutt_convert_to_state (cd, 0, 0, s);
-
-  state_reset_prefix (s);
-}
-
-unsigned char decode_byte (char ch)
+static unsigned char decode_byte(int ch)
 {
-  if (ch == 96)
-    return 0;
-  return ch - 32;
+    return ch == 96 ? 0 : ch - 32;
 }
 
-void mutt_decode_uuencoded (STATE * s, long len, int istext, iconv_t cd)
+static void mutt_decode_uuencoded (STATE * s, long len, int istext, iconv_t cd)
 {
-  char tmps[SHORT_STRING];
+  char tmps[STRING];
   char linelen, c, l, out;
   char *pt;
   char bufi[BUFI_SIZE];
-  size_t k = 0;
+  ssize_t k = 0;
 
   if (istext)
     state_set_prefix (s);
@@ -366,24 +209,24 @@ void mutt_decode_uuencoded (STATE * s, long len, int istext, iconv_t cd)
   while (len > 0) {
     if ((fgets (tmps, sizeof (tmps), s->fpin)) == NULL)
       return;
-    len -= mutt_strlen (tmps);
-    if ((!mutt_strncmp (tmps, "begin", 5)) && ISSPACE (tmps[5]))
+    len -= m_strlen(tmps);
+    if ((!m_strncmp(tmps, "begin", 5)) && ISSPACE (tmps[5]))
       break;
   }
   while (len > 0) {
     if ((fgets (tmps, sizeof (tmps), s->fpin)) == NULL)
       return;
-    len -= mutt_strlen (tmps);
-    if (!mutt_strncmp (tmps, "end", 3))
+    len -= m_strlen(tmps);
+    if (!m_strncmp(tmps, "end", 3))
       break;
     pt = tmps;
-    linelen = decode_byte (*pt);
+    linelen = decode_byte(*pt);
     pt++;
     for (c = 0; c < linelen;) {
       for (l = 2; l <= 6; l += 2) {
-        out = decode_byte (*pt) << l;
+        out = decode_byte(*pt) << l;
         pt++;
-        out |= (decode_byte (*pt) >> (6 - l));
+        out |= (decode_byte(*pt) >> (6 - l));
         bufi[k++] = out;
         c++;
         if (c == linelen)
@@ -415,37 +258,36 @@ static struct {
   const char *tag_name;
   int index;
 } EnrichedTags[] = {
-  {
-  "param", RICH_PARAM}, {
-  "bold", RICH_BOLD}, {
-  "italic", RICH_ITALIC}, {
-  "underline", RICH_UNDERLINE}, {
-  "nofill", RICH_NOFILL}, {
-  "excerpt", RICH_EXCERPT}, {
-  "indent", RICH_INDENT}, {
-  "indentright", RICH_INDENT_RIGHT}, {
-  "center", RICH_CENTER}, {
-  "flushleft", RICH_FLUSHLEFT}, {
-  "flushright", RICH_FLUSHRIGHT}, {
-  "flushboth", RICH_FLUSHLEFT}, {
-  "color", RICH_COLOR}, {
-  "x-color", RICH_COLOR}, {
-  NULL, -1}
+  {"param", RICH_PARAM},
+  {"bold", RICH_BOLD},
+  {"italic", RICH_ITALIC},
+  {"underline", RICH_UNDERLINE},
+  {"nofill", RICH_NOFILL},
+  {"excerpt", RICH_EXCERPT},
+  {"indent", RICH_INDENT},
+  {"indentright", RICH_INDENT_RIGHT},
+  {"center", RICH_CENTER},
+  {"flushleft", RICH_FLUSHLEFT},
+  {"flushright", RICH_FLUSHRIGHT},
+  {"flushboth", RICH_FLUSHLEFT},
+  {"color", RICH_COLOR},
+  {"x-color", RICH_COLOR},
+  {NULL, -1}
 };
 
 struct enriched_state {
   char *buffer;
   char *line;
   char *param;
-  size_t buff_len;
-  size_t line_len;
-  size_t line_used;
-  size_t line_max;
-  size_t indent_len;
-  size_t word_len;
-  size_t buff_used;
-  size_t param_used;
-  size_t param_len;
+  ssize_t buff_len;
+  ssize_t line_len;
+  ssize_t line_used;
+  ssize_t line_max;
+  ssize_t indent_len;
+  ssize_t word_len;
+  ssize_t buff_used;
+  ssize_t param_used;
+  ssize_t param_len;
   int tag_level[RICH_LAST_TAG];
   int WrapMargin;
   STATE *s;
@@ -459,7 +301,7 @@ static void enriched_wrap (struct enriched_state *stte)
   if (stte->line_len) {
     if (stte->tag_level[RICH_CENTER] || stte->tag_level[RICH_FLUSHRIGHT]) {
       /* Strip trailing white space */
-      size_t y = stte->line_used - 1;
+      ssize_t y = stte->line_used - 1;
 
       while (y && ISSPACE (stte->line[y])) {
         stte->line[y] = '\0';
@@ -474,7 +316,7 @@ static void enriched_wrap (struct enriched_state *stte)
         while (stte->line[y] && ISSPACE (stte->line[y]))
           y++;
         if (y) {
-          size_t z;
+          ssize_t z;
 
           for (z = y; z <= stte->line_used; z++) {
             stte->line[z - y] = stte->line[z];
@@ -514,7 +356,7 @@ static void enriched_wrap (struct enriched_state *stte)
   stte->indent_len = 0;
   if (stte->s->prefix) {
     state_puts (stte->s->prefix, stte->s);
-    stte->indent_len += mutt_strlen (stte->s->prefix);
+    stte->indent_len += m_strlen(stte->s->prefix);
   }
 
   if (stte->tag_level[RICH_EXCERPT]) {
@@ -522,11 +364,11 @@ static void enriched_wrap (struct enriched_state *stte)
     while (x) {
       if (stte->s->prefix) {
         state_puts (stte->s->prefix, stte->s);
-        stte->indent_len += mutt_strlen (stte->s->prefix);
+        stte->indent_len += m_strlen(stte->s->prefix);
       }
       else {
         state_puts ("> ", stte->s);
-        stte->indent_len += mutt_strlen ("> ");
+        stte->indent_len += m_strlen("> ");
       }
       x--;
     }
@@ -556,9 +398,9 @@ static void enriched_flush (struct enriched_state *stte, int wrap)
     stte->line_used += stte->buff_used;
     if (stte->line_used > stte->line_max) {
       stte->line_max = stte->line_used;
-      safe_realloc (&stte->line, stte->line_max + 1);
+      p_realloc(&stte->line, stte->line_max + 1);
     }
-    strcat (stte->line, stte->buffer);  /* __STRCAT_CHECKED__ */
+    m_strcat(stte->line, stte->line_max + 1, stte->buffer);
     stte->line_len += stte->word_len;
     stte->word_len = 0;
     stte->buff_used = 0;
@@ -573,7 +415,7 @@ static void enriched_putc (int c, struct enriched_state *stte)
   if (stte->tag_level[RICH_PARAM]) {
     if (stte->tag_level[RICH_COLOR]) {
       if (stte->param_used + 1 >= stte->param_len)
-        safe_realloc (&stte->param, (stte->param_len += STRING));
+        p_realloc(&stte->param, (stte->param_len += STRING));
 
       stte->param[stte->param_used++] = c;
     }
@@ -583,7 +425,7 @@ static void enriched_putc (int c, struct enriched_state *stte)
   /* see if more space is needed (plus extra for possible rich characters) */
   if (stte->buff_len < stte->buff_used + 3) {
     stte->buff_len += LONG_STRING;
-    safe_realloc (&stte->buffer, stte->buff_len + 1);
+    p_realloc(&stte->buffer, stte->buff_len + 1);
   }
 
   if ((!stte->tag_level[RICH_NOFILL] && ISSPACE (c)) || c == '\0') {
@@ -616,26 +458,25 @@ static void enriched_putc (int c, struct enriched_state *stte)
       else {
         stte->buffer[stte->buff_used++] = c;
       }
-    }
-    else {
+    } else {
       stte->buffer[stte->buff_used++] = c;
     }
     stte->word_len++;
   }
 }
 
-static void enriched_puts (char *s, struct enriched_state *stte)
+static void enriched_puts (const char *s, struct enriched_state *stte)
 {
-  char *c;
+  const char *p;
 
-  if (stte->buff_len < stte->buff_used + mutt_strlen (s)) {
+  if (stte->buff_len < stte->buff_used + m_strlen(s)) {
     stte->buff_len += LONG_STRING;
-    safe_realloc (&stte->buffer, stte->buff_len + 1);
+    p_realloc(&stte->buffer, stte->buff_len + 1);
   }
-  c = s;
-  while (*c) {
-    stte->buffer[stte->buff_used++] = *c;
-    c++;
+
+  p = s;
+  while (*p) {
+    stte->buffer[stte->buff_used++] = *p++;
   }
 }
 
@@ -706,7 +547,7 @@ static void enriched_set_flags (const char *tag, struct enriched_state *stte)
   }
 }
 
-void text_enriched_handler (BODY * a, STATE * s)
+static int text_enriched_handler (BODY * a, STATE * s)
 {
   enum {
     TEXT, LANGLE, TAG, BOGUS_TAG, NEWLINE, ST_EOF, DONE
@@ -718,21 +559,20 @@ void text_enriched_handler (BODY * a, STATE * s)
   int tag_len = 0;
   char tag[LONG_STRING + 1];
 
-  memset (&stte, 0, sizeof (stte));
+  p_clear(&stte, 1);
   stte.s = s;
-  stte.WrapMargin =
-    ((s->flags & M_DISPLAY) ? (COLS - 4) : ((COLS - 4) <
-                                            72) ? (COLS - 4) : 72);
+  stte.WrapMargin = ((s->flags & M_DISPLAY) ? (getmaxx(main_w) - 4) :
+                     ((getmaxx(main_w) - 4) < 72) ? (getmaxx(main_w) - 4) : 72);
   stte.line_max = stte.WrapMargin * 4;
-  stte.line = (char *) safe_calloc (1, stte.line_max + 1);
-  stte.param = (char *) safe_calloc (1, STRING);
+  stte.line = p_new(char, stte.line_max + 1);
+  stte.param = p_new(char, STRING);
 
   stte.param_len = STRING;
   stte.param_used = 0;
 
   if (s->prefix) {
     state_puts (s->prefix, s);
-    stte.indent_len += mutt_strlen (s->prefix);
+    stte.indent_len += m_strlen(s->prefix);
   }
 
   while (state != DONE) {
@@ -816,481 +656,26 @@ void text_enriched_handler (BODY * a, STATE * s)
 
   state_putc ('\n', s);         /* add a final newline */
 
-  FREE (&(stte.buffer));
-  FREE (&(stte.line));
-  FREE (&(stte.param));
-}
-
-/*
- * An implementation of RFC 2646.
- *
- * NOTE: This still has to be made UTF-8 aware.
- *
- */
-
-#define FLOWED_MAX 77
-
-#if 0
-static int flowed_maybe_quoted (char *cont)
-{
-  return regexec ((regex_t *) QuoteRegexp.rx, cont, 0, NULL, 0) == 0;
-}
-
-static void flowed_quote (STATE * s, int level)
-{
-  int i;
-
-  if (s->prefix) {
-    if (option (OPTTEXTFLOWED))
-      level++;
-    else
-      state_puts (s->prefix, s);
-  }
-
-  for (i = 0; i < level; i++)
-    state_putc ('>', s);
-}
-
-static void flowed_stuff (STATE * s, char *cont, int level)
-{
-  if (!option (OPTTEXTFLOWED) && !(s->flags & M_DISPLAY))
-    return;
-
-  if (s->flags & M_DISPLAY) {
-    /* 
-     * Hack: If we are in the beginning of the line and there is 
-     * some text on the line which looks like it's quoted, turn off 
-     * ANSI colors, so quote coloring doesn't affect this line. 
-     */
-    if (*cont && !level && !mutt_strcmp (Pager, "builtin")
-        && flowed_maybe_quoted (cont))
-      state_puts ("\033[0m", s);
-  }
-  else if ((!(s->flags & M_PRINTING)) && ((*cont == ' ') || (*cont == '>')
-                                          || (!level
-                                              && !mutt_strncmp (cont, "From ",
-                                                                5))))
-    state_putc (' ', s);
-}
-
-static char *flowed_skip_indent (char *prefix, char *cont)
-{
-  for (; *cont == ' ' || *cont == '\t'; cont++)
-    *prefix++ = *cont;
-  *prefix = '\0';
-  return cont;
-}
-
-static int flowed_visual_strlen (char *l, int i)
-{
-  int j;
-
-  for (j = 0; *l; l++) {
-    if (*l == '\t')
-      j += 8 - ((i + j) % 8);
-    else
-      j++;
-  }
-
-  return j;
-}
-
-static void text_plain_flowed_handler (BODY * a, STATE * s)
-{
-  char line[LONG_STRING];
-  char indent[LONG_STRING];
-
-  int quoted = -1;
-  int last_quoted;
-  int full = 1;
-  int last_full;
-  int col = 0, tmpcol;
-
-  int i_add = 0;
-  int add = 0;
-  int soft = 0;
-  int l, rl;
-
-  int flowed_max;
-  int bytes = a->length;
-  int actually_wrap = 0;
-
-  char *cont = NULL;
-  char *tail = NULL;
-  char *lc = NULL;
-  char *t;
-
-  *indent = '\0';
-
-  if (s->prefix)
-    add = 1;
-
-  /*
-     if ((flowed_max = FLOWED_MAX) > COLS - 3)
-     flowed_max = COLS - 3;
-     if (flowed_max > COLS - WrapMargin)
-     flowed_max = COLS - WrapMargin;
-     if (flowed_max <= 0)
-     flowed_max = COLS;
-   */
-  flowed_max = COLS - WrapMargin;
-  if (flowed_max <= 0)
-    flowed_max = COLS;
-
-  fprintf (stderr, "flowed_max = %d\n", flowed_max);
-
-  while (bytes > 0 && fgets (line, sizeof (line), s->fpin)) {
-    bytes -= strlen (line);
-    tail = NULL;
-
-    last_full = full;
-
-    /* 
-     * If the last line wasn't fully read, this is the
-     * tail of some line. 
-     */
-    actually_wrap = !last_full;
-
-    if ((t = strrchr (line, '\r')) || (t = strrchr (line, '\n'))) {
-      *t = '\0';
-      full = 1;
-    }
-    else if ((t = strrchr (line, ' ')) || (t = strrchr (line, '\t'))) {
-      /* 
-       * Bad: We have a line of more than LONG_STRING characters.
-       * (Which SHOULD NOT happen, since lines SHOULD be <= 79
-       * characters long.)
-       * 
-       * Try to simulate a soft line break at a word boundary.
-       * Handle the rest of the line next time.
-       * 
-       * Give up when we have a single word which is longer than
-       * LONG_STRING characters.  It will just be split into parts,
-       * with a hard line break in between. 
-       */
-
-      full = 0;
-      l = strlen (t + 1);
-      t[0] = ' ';
-      t[1] = '\0';
-
-      if (l) {
-        fseek (s->fpin, -l, SEEK_CUR);
-        bytes += l;
-      }
-    }
-    else
-      full = 0;
-
-    last_quoted = quoted;
-
-    if (last_full) {
-      /* 
-       * We are in the beginning of a new line. Determine quote level
-       * and indentation prefix 
-       */
-      for (quoted = 0; line[quoted] == '>'; quoted++);
-
-      cont = line + quoted;
-
-      /* undo space stuffing */
-      if (*cont == ' ')
-        cont++;
-
-      /* If there is an indentation, record it. */
-      cont = flowed_skip_indent (indent, cont);
-      i_add = flowed_visual_strlen (indent, quoted + add);
-    }
-    else {
-      /* 
-       * This is just the tail of some over-long line. Keep
-       * indentation and quote levels.  Don't unstuff.
-       */
-      cont = line;
-    }
-
-    /* If we have a change in quoting depth, wrap. */
-
-    if (col && last_quoted != quoted && last_quoted >= 0) {
-      state_putc ('\n', s);
-      col = 0;
-    }
-
-    do {
-      if (tail)
-        cont = tail;
-
-      SKIPWS (cont);
-
-      tail = NULL;
-      soft = 0;
-
-      /* try to find a point for word wrapping */
-
-    retry_wrap:
-      l = flowed_visual_strlen (cont, quoted + i_add + add + col);
-      rl = mutt_strlen (cont);
-      if (quoted + i_add + add + col + l > flowed_max) {
-        actually_wrap = 1;
-
-        for (tmpcol = quoted + i_add + add + col, t = cont;
-             *t && tmpcol < flowed_max; t++) {
-          if (*t == ' ' || *t == '\t')
-            tail = t;
-          if (*t == '\t')
-            tmpcol = (tmpcol & ~7) + 8;
-          else
-            tmpcol++;
-        }
-
-        if (tail) {
-          *tail++ = '\0';
-          soft = 2;
-        }
-      }
-
-      /* We seem to be desperate.  Get me a new line, and retry. */
-      if (!tail && (quoted + add + col + i_add + l > flowed_max) && col) {
-        state_putc ('\n', s);
-        col = 0;
-        goto retry_wrap;
-      }
-
-      /* Detect soft line breaks. */
-      if (!soft && ascii_strcmp (cont, "-- ")) {
-        lc = strrchr (cont, ' ');
-        if (lc && lc[1] == '\0')
-          soft = 1;
-      }
-
-      /* 
-       * If we are in the beginning of an output line, do quoting
-       * and stuffing. 
-       * 
-       * We have to temporarily assemble the line since display
-       * stuffing (i.e., turning off quote coloring) may depend on
-       * the line's actual content.  You never know what people put
-       * into their regular expressions. 
-       */
-      if (!col) {
-        char tmp[LONG_STRING];
-
-        snprintf (tmp, sizeof (tmp), "%s%s", indent, cont);
-
-        flowed_quote (s, quoted);
-        flowed_stuff (s, tmp, quoted + add);
-
-        state_puts (indent, s);
-      }
-
-      /* output the text */
-      state_puts (cont, s);
-      col += flowed_visual_strlen (cont, quoted + i_add + add + col);
-
-      /* possibly indicate a soft line break */
-      if (soft == 2) {
-        state_putc (' ', s);
-        col++;
-      }
-
-      /* 
-       * Wrap if this display line corresponds to a 
-       * text line. Don't wrap if we changed the line.
-       */
-      if (!soft || (!actually_wrap && full)) {
-        state_putc ('\n', s);
-        col = 0;
-      }
-    }
-    while (tail);
-  }
-
-  if (col)
-    state_putc ('\n', s);
+  p_delete(&(stte.buffer));
+  p_delete(&(stte.line));
+  p_delete(&(stte.param));
 
+  return 0;
 }
-#endif
-
-static int get_quote_level (char *line)
-{
-  int quoted;
-
-  for (quoted = 0; line[quoted] == '>'; quoted++);
-  return quoted;
-}
-
-static void print_flowed_line (char *line, STATE * s, int ql)
-{
-  int width;
-  char *pos, *oldpos;
-  int len = strlen (line);
-  int i;
-
-  if (MaxLineLength > 0) {
-    width = MaxLineLength - WrapMargin - ql - 1;
-    if (option (OPTSTUFFQUOTED))
-      --width;
-    if (width < 0)
-      width = MaxLineLength;
-  }
-  else {
-    if (option (OPTMBOXPANE))
-      width = COLS - SidebarWidth - WrapMargin - ql - 1;
-    else
-      width = COLS - WrapMargin - ql - 1;
-
-    if (option (OPTSTUFFQUOTED))
-      --width;
-    if (width < 0)
-      width = COLS;
-  }
-
-  /* fprintf(stderr,"print_flowed_line will print `%s' with ql = %d\n",line,ql); */
-
-  if (strlen (line) == 0) {
-    if (option (OPTQUOTEEMPTY)) {
-      if (s->prefix)
-        state_puts(s->prefix,s);
-      for (i=0;i<ql;++i) state_putc('>',s);
-      if (option(OPTSTUFFQUOTED))
-        state_putc(' ',s);
-    }
-    state_putc('\n',s);
-    return;
-  }
-
-  pos = line + ql + width;
-  oldpos = line + ql;
-  if (ql > 0 && ISBLANK (*oldpos))
-    ++oldpos;
-
-  /* fprintf(stderr,"oldpos = %p line+len = %p\n",oldpos,line+len); */
-
-  for (; oldpos < line + len; pos += width) {
-    /* fprintf(stderr,"outer for loop\n"); */
-    if (pos < line + len) {     /* only search a new position when we're not over the end of the string w/ pos */
-      /* fprintf(stderr,"if 1\n"); */
-      if (*pos == ' ') {
-        /* fprintf(stderr,"if 2: good luck! found a space\n"); */
-        *pos = '\0';
-        ++pos;
-      }
-      else {
-        /* fprintf(stderr,"if 2: else\n"); */
-        char *save = pos;
-
-        while (pos >= oldpos && !isspace (*pos)) {
-          /* fprintf(stderr,"pos(%p) > oldpos(%p)\n",pos,oldpos); */
-          --pos;
-        }
-        if (pos < oldpos) {
-          /* fprintf(stderr,"wow, no space found, searching the other direction\n"); */
-          pos = save;
-          while (pos < line + len && *pos && !isspace (*pos)) {
-            /* fprintf(stderr,"pos(%p) < line+len(%p)\n",pos,line+len); */
-            ++pos;
-          }
-          /* fprintf(stderr,"found a space pos = %p\n",pos); */
-        }
-        *pos = '\0';
-        ++pos;
-      }
-    }
-    else {
-      /* fprintf(stderr,"if 1 else\n"); */
-    }
-    if (s->prefix)
-      state_puts (s->prefix, s);
-    for (i = 0; i < ql; ++i)
-      state_putc ('>', s);
-    if (option (OPTSTUFFQUOTED) && (ql > 0 || s->prefix))
-      state_putc (' ', s);
-    state_puts (oldpos, s);
-    /* fprintf(stderr,"print_flowed_line: `%s'\n",oldpos); */
-    if (pos < line + len)
-      state_putc (' ', s);
-    state_putc ('\n', s);
-    oldpos = pos;
-  }
-  /*state_puts(line,s);
-     state_putc('\n',s); */
-}
-
-static void text_plain_flowed_handler (BODY * a, STATE * s)
-{
-  int bytes = a->length;
-  char buf[LONG_STRING];
-  char *curline = strdup ("");
-  char *t;
-  unsigned int curline_len = 1;
-  unsigned int quotelevel = 0, newql = 0;
-  int append_next_line = 0;
-  int first_line = 1;
-
-  while (bytes > 0 && fgets (buf, sizeof (buf), s->fpin)) {
-
-    /* fprintf(stderr,"read `%s'",buf); */
-    bytes -= strlen (buf);
-
-    newql = get_quote_level (buf);
-
-    if ((t = strrchr (buf, '\n')) || (t = strrchr (buf, '\r'))) {
-      *t = '\0';
-      if (strlen (curline) > 0 && curline[strlen (curline) - 1] == ' '
-          && newql == quotelevel
-          && strcmp (curline + quotelevel, "-- ") != 0) {
-        if (buf[newql] == ' ')
-          curline[strlen (curline) - 1] = '\0';
-
-        curline = realloc (curline, curline_len + strlen (buf));
-        if (curline_len == 1)
-          *curline = '\0';
-        curline_len += strlen (buf);
-        safe_strncat (curline, curline_len, buf + newql,
-                      strlen (buf + newql));
-      }
-      else {
-        if (first_line) {
-          first_line = 0;
-        }
-        else {
-          print_flowed_line (curline, s, quotelevel);
-        }
-        FREE (&curline);
-        curline_len = 1;
-        curline = realloc (curline, curline_len + strlen (buf));
-        if (curline_len == 1)
-          *curline = '\0';
-        curline_len += strlen (buf);
-        safe_strncat (curline, curline_len, buf, strlen (buf));
-        quotelevel = newql;
-      }
-    }
-    else {
-      append_next_line = 1;
-      /* @todo: add handling of very long lines */
-    }
-  }
-  if (curline) {
-    print_flowed_line (curline, s, quotelevel);
-    FREE (&curline);
-  }
-}
-
-
 
 #define TXTHTML     1
 #define TXTPLAIN    2
 #define TXTENRICHED 3
 
-static void alternative_handler (BODY * a, STATE * s)
+static int alternative_handler (BODY * a, STATE * s)
 {
   BODY *choice = NULL;
   BODY *b;
-  LIST *t;
+  string_list_t *t;
   char buf[STRING];
   int type = 0;
   int mustfree = 0;
+  int rc = 0;
 
   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
       a->encoding == ENCUUENCODED) {
@@ -1298,14 +683,12 @@ static void alternative_handler (BODY * a, STATE * s)
 
     mustfree = 1;
     fstat (fileno (s->fpin), &st);
-    b = mutt_new_body ();
+    b = body_new();
     b->length = (long) st.st_size;
-    b->parts = mutt_parse_multipart (s->fpin,
-                                     mutt_get_parameter ("boundary",
-                                                         a->parameter),
-                                     (long) st.st_size,
-                                     ascii_strcasecmp ("digest",
-                                                       a->subtype) == 0);
+    b->parts = mutt_parse_multipart(s->fpin,
+                                    parameter_getval(a->parameter, "boundary"),
+                                    (long)st.st_size,
+                                    mime_which_token(a->subtype, -1) == MIME_DIGEST);
   }
   else
     b = a;
@@ -1326,7 +709,7 @@ static void alternative_handler (BODY * a, STATE * s)
     }
     else {
       wild = 1;
-      btlen = mutt_strlen (t->data);
+      btlen = m_strlen(t->data);
     }
 
     if (a && a->parts)
@@ -1356,12 +739,12 @@ static void alternative_handler (BODY * a, STATE * s)
     while (b) {
       snprintf (buf, sizeof (buf), "%s/%s", TYPE (b), b->subtype);
       if (mutt_is_autoview (b, buf)) {
-        rfc1524_entry *entry = rfc1524_new_entry ();
+        rfc1524_entry *entry = rfc1524_entry_new();
 
         if (rfc1524_mailcap_lookup (b, buf, entry, M_AUTOVIEW)) {
           choice = b;
         }
-        rfc1524_free_entry (&entry);
+        rfc1524_entry_delete(&entry);
       }
       b = b->next;
     }
@@ -1375,18 +758,27 @@ static void alternative_handler (BODY * a, STATE * s)
       b = a;
     while (b) {
       if (b->type == TYPETEXT) {
-        if (!ascii_strcasecmp ("plain", b->subtype) && type <= TXTPLAIN) {
-          choice = b;
-          type = TXTPLAIN;
-        }
-        else if (!ascii_strcasecmp ("enriched", b->subtype)
-                 && type <= TXTENRICHED) {
-          choice = b;
-          type = TXTENRICHED;
-        }
-        else if (!ascii_strcasecmp ("html", b->subtype) && type <= TXTHTML) {
-          choice = b;
-          type = TXTHTML;
+        switch (mime_which_token(b->subtype, -1)) {
+          case MIME_PLAIN:
+            if (type <= TXTPLAIN) {
+              choice = b;
+              type = TXTPLAIN;
+            }
+            break;
+          case MIME_ENRICHED:
+            if (type <= TXTENRICHED) {
+              choice = b;
+              type = TXTENRICHED;
+            }
+            break;
+          case MIME_HTML:
+            if (type <= TXTHTML) {
+              choice = b;
+              type = TXTHTML;
+            }
+            break;
+          default:
+            break;
         }
       }
       b = b->next;
@@ -1408,7 +800,7 @@ static void alternative_handler (BODY * a, STATE * s)
 
   if (choice) {
     if (s->flags & M_DISPLAY && !option (OPTWEED)) {
-      fseek (s->fpin, choice->hdr_offset, 0);
+      fseeko (s->fpin, choice->hdr_offset, 0);
       mutt_copy_bytes (s->fpin, s->fpout,
                        choice->offset - choice->hdr_offset);
     }
@@ -1417,27 +809,29 @@ static void alternative_handler (BODY * a, STATE * s)
   else if (s->flags & M_DISPLAY) {
     /* didn't find anything that we could display! */
     state_mark_attach (s);
-    state_puts (_
-                ("[-- Error:  Could not display any parts of Multipart/Alternative! --]\n"),
-                s);
+    state_puts (_("[-- Error:  Could not display any parts of Multipart/Alternative! --]\n"), s);
+    rc = -1;
   }
 
   if (mustfree)
-    mutt_free_body (&a);
+    body_list_wipe(&a);
+
+  return rc;
 }
 
 /* handles message/rfc822 body parts */
-void message_handler (BODY * a, STATE * s)
+static int message_handler (BODY * a, STATE * s)
 {
   struct stat st;
   BODY *b;
-  long off_start;
+  off_t off_start;
+  int rc = 0;
 
-  off_start = ftell (s->fpin);
+  off_start = ftello (s->fpin);
   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
       a->encoding == ENCUUENCODED) {
     fstat (fileno (s->fpin), &st);
-    b = mutt_new_body ();
+    b = body_new();
     b->length = (long) st.st_size;
     b->parts = mutt_parse_messageRFC822 (s->fpin, b);
   }
@@ -1456,12 +850,14 @@ void message_handler (BODY * a, STATE * s)
       state_puts (s->prefix, s);
     state_putc ('\n', s);
 
-    mutt_body_handler (b->parts, s);
+    rc = mutt_body_handler (b->parts, s);
   }
 
   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
       a->encoding == ENCUUENCODED)
-    mutt_free_body (&b);
+    body_list_wipe(&b);
+
+  return rc;
 }
 
 /* returns 1 if decoding the attachment will produce output */
@@ -1471,57 +867,53 @@ int mutt_can_decode (BODY * a)
 
   snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
   if (mutt_is_autoview (a, type))
-    return (rfc1524_mailcap_lookup (a, type, NULL, M_AUTOVIEW));
+    return rfc1524_mailcap_lookup (a, type, NULL, M_AUTOVIEW);
   else if (a->type == TYPETEXT)
-    return (1);
+    return 1;
   else if (a->type == TYPEMESSAGE)
-    return (1);
+    return 1;
   else if (a->type == TYPEMULTIPART) {
     BODY *p;
+    int tok = mime_which_token(a->subtype, -1);
 
-    if (WithCrypto) {
-      if (ascii_strcasecmp (a->subtype, "signed") == 0 ||
-          ascii_strcasecmp (a->subtype, "encrypted") == 0)
-        return (1);
-    }
+    if (tok == MIME_SIGNED || tok == MIME_ENCRYPTED)
+      return 1;
 
     for (p = a->parts; p; p = p->next) {
       if (mutt_can_decode (p))
-        return (1);
+        return 1;
     }
-
   }
-  else if (WithCrypto && a->type == TYPEAPPLICATION) {
-    if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (a))
-      return (1);
-    if ((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime (a))
-      return (1);
+  else if (a->type == TYPEAPPLICATION) {
+    if (mutt_is_application_pgp(a))
+      return 1;
+    if (mutt_is_application_smime (a))
+      return 1;
   }
 
-  return (0);
+  return 0;
 }
 
-void multipart_handler (BODY * a, STATE * s)
+static int multipart_handler (BODY * a, STATE * s)
 {
   BODY *b, *p;
   char length[5];
   struct stat st;
   int count;
+  int rc = 0;
 
   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
       a->encoding == ENCUUENCODED) {
     fstat (fileno (s->fpin), &st);
-    b = mutt_new_body ();
+    b = body_new();
     b->length = (long) st.st_size;
-    b->parts = mutt_parse_multipart (s->fpin,
-                                     mutt_get_parameter ("boundary",
-                                                         a->parameter),
-                                     (long) st.st_size,
-                                     ascii_strcasecmp ("digest",
-                                                       a->subtype) == 0);
-  }
-  else
+    b->parts = mutt_parse_multipart(s->fpin,
+                                    parameter_getval(a->parameter, "boundary"),
+                                    (long)st.st_size,
+                                    mime_which_token(a->subtype, -1) == MIME_DIGEST);
+  } else {
     b = a;
+  }
 
   for (p = b->parts, count = 1; p; p = p->next, count++) {
     if (s->flags & M_DISPLAY) {
@@ -1540,7 +932,7 @@ void multipart_handler (BODY * a, STATE * s)
       state_printf (s, _("[-- Type: %s/%s, Encoding: %s, Size: %s --]\n"),
                     TYPE (p), p->subtype, ENCODING (p->encoding), length);
       if (!option (OPTWEED)) {
-        fseek (s->fpin, p->hdr_offset, 0);
+        fseeko (s->fpin, p->hdr_offset, 0);
         mutt_copy_bytes (s->fpin, s->fpout, p->offset - p->hdr_offset);
       }
       else
@@ -1554,21 +946,22 @@ void multipart_handler (BODY * a, STATE * s)
         state_printf (s, "%s: \n", p->form_name);
 
     }
-    mutt_body_handler (p, s);
+    rc = mutt_body_handler (p, s);
     state_putc ('\n', s);
-    if ((s->flags & M_REPLYING)
-        && (option (OPTINCLUDEONLYFIRST)) && (s->flags & M_FIRSTDONE))
+    if (rc)
       break;
   }
 
   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
       a->encoding == ENCUUENCODED)
-    mutt_free_body (&b);
+    body_list_wipe(&b);
+
+  return rc;
 }
 
-void autoview_handler (BODY * a, STATE * s)
+static int autoview_handler (BODY * a, STATE * s)
 {
-  rfc1524_entry *entry = rfc1524_new_entry ();
+  rfc1524_entry *entry = rfc1524_entry_new();
   char buffer[LONG_STRING];
   char type[STRING];
   char command[LONG_STRING];
@@ -1579,18 +972,19 @@ void autoview_handler (BODY * a, STATE * s)
   FILE *fperr = NULL;
   int piped = FALSE;
   pid_t thepid;
+  int rc = 0;
 
   snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
   rfc1524_mailcap_lookup (a, type, entry, M_AUTOVIEW);
 
-  fname = safe_strdup (a->filename);
+  fname = m_strdup(a->filename);
   mutt_sanitize_filename (fname, 1);
   rfc1524_expand_filename (entry->nametemplate, fname, tempfile,
                            sizeof (tempfile));
-  FREE (&fname);
+  p_delete(&fname);
 
   if (entry->command) {
-    strfcpy (command, entry->command, sizeof (command));
+    m_strcpy(command, sizeof(command), entry->command);
 
     /* rfc1524_expand_command returns 0 if the file is required */
     piped =
@@ -1604,17 +998,16 @@ void autoview_handler (BODY * a, STATE * s)
 
     if ((fpin = safe_fopen (tempfile, "w+")) == NULL) {
       mutt_perror ("fopen");
-      rfc1524_free_entry (&entry);
-      return;
+      rfc1524_entry_delete(&entry);
+      return -1;
     }
 
     mutt_copy_bytes (s->fpin, fpin, a->length);
 
     if (!piped) {
-      safe_fclose (&fpin);
+      m_fclose(&fpin);
       thepid = mutt_create_filter (command, NULL, &fpout, &fperr);
-    }
-    else {
+    } else {
       unlink (tempfile);
       fflush (fpin);
       rewind (fpin);
@@ -1623,12 +1016,13 @@ void autoview_handler (BODY * a, STATE * s)
     }
 
     if (thepid < 0) {
-      mutt_perror _("Can't create filter");
+      mutt_perror (_("Can't create filter"));
 
       if (s->flags & M_DISPLAY) {
         state_mark_attach (s);
         state_printf (s, _("[-- Can't run %s. --]\n"), command);
       }
+      rc = -1;
       goto bail;
     }
 
@@ -1651,8 +1045,7 @@ void autoview_handler (BODY * a, STATE * s)
           state_puts (buffer, s);
         }
       }
-    }
-    else {
+    } else {
       mutt_copy_stream (fpout, s->fpout);
       /* Check for stderr messages */
       if (fgets (buffer, sizeof (buffer), fperr)) {
@@ -1667,45 +1060,44 @@ void autoview_handler (BODY * a, STATE * s)
     }
 
   bail:
-    safe_fclose (&fpout);
-    safe_fclose (&fperr);
+    m_fclose(&fpout);
+    m_fclose(&fperr);
 
     mutt_wait_filter (thepid);
     if (piped)
-      safe_fclose (&fpin);
+      m_fclose(&fpin);
     else
       mutt_unlink (tempfile);
 
     if (s->flags & M_DISPLAY)
       mutt_clear_error ();
   }
-  rfc1524_free_entry (&entry);
+  rfc1524_entry_delete(&entry);
+  return rc;
 }
 
-static void external_body_handler (BODY * b, STATE * s)
+static int external_body_handler (BODY * b, STATE * s)
 {
   const char *access_type;
   const char *expiration;
   time_t expire;
 
-  access_type = mutt_get_parameter ("access-type", b->parameter);
+  access_type = parameter_getval(b->parameter, "access-type");
   if (!access_type) {
     if (s->flags & M_DISPLAY) {
       state_mark_attach (s);
-      state_puts (_
-                  ("[-- Error: message/external-body has no access-type parameter --]\n"),
-                  s);
+      state_puts (_("[-- Error: message/external-body has no access-type parameter --]\n"), s);
     }
-    return;
+    return -1;
   }
 
-  expiration = mutt_get_parameter ("expiration", b->parameter);
+  expiration = parameter_getval(b->parameter, "expiration");
   if (expiration)
     expire = mutt_parse_date (expiration, NULL);
   else
     expire = -1;
 
-  if (!ascii_strcasecmp (access_type, "x-mutt-deleted")) {
+  if (mime_which_token(access_type, -1) == MIME_X_MUTT_DELETED) {
     if (s->flags & (M_DISPLAY | M_PRINTING)) {
       char *length;
       char pretty_size[10];
@@ -1713,7 +1105,7 @@ static void external_body_handler (BODY * b, STATE * s)
       state_mark_attach (s);
       state_printf (s, _("[-- This %s/%s attachment "),
                     TYPE (b->parts), b->parts->subtype);
-      length = mutt_get_parameter ("length", b->parameter);
+      length = parameter_getval(b->parameter, "length");
       if (length) {
         mutt_pretty_size (pretty_size, sizeof (pretty_size),
                           strtol (length, NULL, 10));
@@ -1730,7 +1122,7 @@ static void external_body_handler (BODY * b, STATE * s)
         state_printf (s, _("[-- name: %s --]\n"), b->parts->filename);
       }
 
-      mutt_copy_hdr (s->fpin, s->fpout, ftell (s->fpin), b->parts->offset,
+      mutt_copy_hdr (s->fpin, s->fpout, ftello (s->fpin), b->parts->offset,
                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
                      CH_DECODE, NULL);
     }
@@ -1743,12 +1135,11 @@ static void external_body_handler (BODY * b, STATE * s)
       state_attach_puts (_("[-- and the indicated external source has --]\n"
                            "[-- expired. --]\n"), s);
 
-      mutt_copy_hdr (s->fpin, s->fpout, ftell (s->fpin), b->parts->offset,
+      mutt_copy_hdr (s->fpin, s->fpout, ftello (s->fpin), b->parts->offset,
                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
                      CH_DECODE, NULL);
     }
-  }
-  else {
+  } else {
     if (s->flags & M_DISPLAY) {
       state_mark_attach (s);
       state_printf (s,
@@ -1759,56 +1150,139 @@ static void external_body_handler (BODY * b, STATE * s)
                     _
                     ("[-- and the indicated access-type %s is unsupported --]\n"),
                     access_type);
-      mutt_copy_hdr (s->fpin, s->fpout, ftell (s->fpin), b->parts->offset,
+      mutt_copy_hdr (s->fpin, s->fpout, ftello (s->fpin), b->parts->offset,
                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
                      CH_DECODE, NULL);
     }
   }
+  return 0;
+}
+
+static void mutt_decode_base64(STATE *s, long len, int istext, iconv_t cd)
+{
+  char buf[5];
+  int c1, c2, c3, c4, ch, cr = 0, i;
+  char bufi[BUFI_SIZE];
+  ssize_t l = 0;
+
+  buf[4] = 0;
+
+  if (istext)
+    state_set_prefix (s);
+
+  while (len > 0) {
+    for (i = 0; i < 4 && len > 0; len--) {
+      if ((ch = fgetc (s->fpin)) == EOF)
+        break;
+      if (base64val(ch) >= 0 || ch == '=')
+        buf[i++] = ch;
+    }
+    if (i != 4) {
+      break;
+    }
+
+    c1 = base64val(buf[0]);
+    c2 = base64val(buf[1]);
+    ch = (c1 << 2) | (c2 >> 4);
+
+    if (cr && ch != '\n')
+      bufi[l++] = '\r';
+
+    cr = 0;
+
+    if (istext && ch == '\r')
+      cr = 1;
+    else
+      bufi[l++] = ch;
+
+    if (buf[2] == '=')
+      break;
+    c3 = base64val(buf[2]);
+    ch = ((c2 & 0xf) << 4) | (c3 >> 2);
+
+    if (cr && ch != '\n')
+      bufi[l++] = '\r';
+
+    cr = 0;
+
+    if (istext && ch == '\r')
+      cr = 1;
+    else
+      bufi[l++] = ch;
+
+    if (buf[3] == '=')
+      break;
+    c4 = base64val(buf[3]);
+    ch = ((c3 & 0x3) << 6) | c4;
+
+    if (cr && ch != '\n')
+      bufi[l++] = '\r';
+    cr = 0;
+
+    if (istext && ch == '\r')
+      cr = 1;
+    else
+      bufi[l++] = ch;
+
+    if (l + 8 >= ssizeof (bufi))
+      mutt_convert_to_state (cd, bufi, &l, s);
+  }
+
+  if (cr)
+    bufi[l++] = '\r';
+
+  mutt_convert_to_state (cd, bufi, &l, s);
+  mutt_convert_to_state (cd, 0, 0, s);
+
+  state_reset_prefix (s);
 }
 
 void mutt_decode_attachment (BODY * b, STATE * s)
 {
   int istext = mutt_is_text_part (b);
-  iconv_t cd = (iconv_t) (-1);
+  iconv_t cd = MUTT_ICONV_ERROR;
 
   Quotebuf[0] = '\0';
 
   if (istext) {
     if (s->flags & M_CHARCONV) {
-      char *charset = mutt_get_parameter ("charset", b->parameter);
+      const char *charset = parameter_getval(b->parameter, "charset");
 
-      if (!option (OPTSTRICTMIME) && !charset)
-        charset = mutt_get_first_charset (AssumedCharset);
-      if (charset && Charset)
-        cd = mutt_iconv_open (Charset, charset, M_ICONV_HOOK_FROM);
-    }
-    else {
+      if (!charset)
+        charset = charset_getfirst(mod_cset.assumed_charset);
+      if (charset && mod_cset.charset)
+        cd = mutt_iconv_open (mod_cset.charset, charset, M_ICONV_HOOK_FROM);
+    } else {
       if (b->file_charset)
-        cd = mutt_iconv_open (Charset, b->file_charset, M_ICONV_HOOK_FROM);
+        cd = mutt_iconv_open (mod_cset.charset, b->file_charset, M_ICONV_HOOK_FROM);
     }
   }
 
-  fseek (s->fpin, b->offset, 0);
+  fseeko (s->fpin, b->offset, 0);
   switch (b->encoding) {
   case ENCQUOTEDPRINTABLE:
-    mutt_decode_quoted (s, b->length, istext, cd);
+    mutt_decode_quoted(s, b->length,
+                       istext || mutt_is_application_pgp(b), cd);
     break;
   case ENCBASE64:
-    mutt_decode_base64 (s, b->length, istext, cd);
+    mutt_decode_base64(s, b->length,
+                       istext || mutt_is_application_pgp(b), cd);
     break;
   case ENCUUENCODED:
-    mutt_decode_uuencoded (s, b->length, istext, cd);
+    mutt_decode_uuencoded(s, b->length,
+                          istext || mutt_is_application_pgp(b), cd);
     break;
   default:
-    mutt_decode_xbit (s, b->length, istext, cd);
+    mutt_decode_xbit(s, b->length,
+                     istext || mutt_is_application_pgp(b), cd);
     break;
   }
 
-  if (cd != (iconv_t) (-1))
+  if (cd != MUTT_ICONV_ERROR)
     iconv_close (cd);
 }
 
-void mutt_body_handler (BODY * b, STATE * s)
+int mutt_body_handler (BODY * b, STATE * s)
 {
   int decode = 0;
   int plaintext = 0;
@@ -1816,57 +1290,58 @@ void mutt_body_handler (BODY * b, STATE * s)
   char tempfile[_POSIX_PATH_MAX];
   handler_t handler = NULL;
   long tmpoffset = 0;
-  size_t tmplength = 0;
+  ssize_t tmplength = 0;
   char type[STRING];
+  int rc = 0;
 
   int oflags = s->flags;
+  int tok = mime_which_token(b->subtype, -1);
 
   /* first determine which handler to use to process this part */
 
   snprintf (type, sizeof (type), "%s/%s", TYPE (b), b->subtype);
   if (mutt_is_autoview (b, type)) {
-    rfc1524_entry *entry = rfc1524_new_entry ();
+    rfc1524_entry *entry = rfc1524_entry_new();
 
     if (rfc1524_mailcap_lookup (b, type, entry, M_AUTOVIEW)) {
       handler = autoview_handler;
       s->flags &= ~M_CHARCONV;
     }
-    rfc1524_free_entry (&entry);
+    rfc1524_entry_delete(&entry);
   }
   else if (b->type == TYPETEXT) {
-    if (ascii_strcasecmp ("plain", b->subtype) == 0) {
+    if (tok == MIME_PLAIN) {
       /* avoid copying this part twice since removing the transfer-encoding is
        * the only operation needed.
        */
-      if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (b))
+      if (mutt_is_application_pgp (b))
         handler = crypt_pgp_application_pgp_handler;
       else
-        if (ascii_strcasecmp
-            ("flowed", mutt_get_parameter ("format", b->parameter)) == 0)
-        handler = text_plain_flowed_handler;
+        if (!ascii_strcasecmp("flowed", parameter_getval(b->parameter, "format")))
+          handler = rfc3676_handler;
       else
         plaintext = 1;
     }
-    else if (ascii_strcasecmp ("enriched", b->subtype) == 0)
+    else if (tok == MIME_ENRICHED)
       handler = text_enriched_handler;
     else                        /* text body type without a handler */
       plaintext = 1;
   }
   else if (b->type == TYPEMESSAGE) {
-    if (mutt_is_message_type (b->type, b->subtype))
+    if (mutt_is_message_type (b))
       handler = message_handler;
-    else if (!ascii_strcasecmp ("delivery-status", b->subtype))
+    else if (tok == MIME_DELIVERY_STATUS)
       plaintext = 1;
-    else if (!ascii_strcasecmp ("external-body", b->subtype))
+    else if (tok == MIME_EXTERNAL_BODY)
       handler = external_body_handler;
   }
   else if (b->type == TYPEMULTIPART) {
     char *p;
 
-    if (ascii_strcasecmp ("alternative", b->subtype) == 0)
+    if (tok == MIME_ALTERNATIVE)
       handler = alternative_handler;
-    else if (WithCrypto && ascii_strcasecmp ("signed", b->subtype) == 0) {
-      p = mutt_get_parameter ("protocol", b->parameter);
+    else if (tok == MIME_SIGNED) {
+      p = parameter_getval(b->parameter, "protocol");
 
       if (!p)
         mutt_error (_("Error: multipart/signed has no protocol."));
@@ -1874,48 +1349,42 @@ void mutt_body_handler (BODY * b, STATE * s)
       else if (s->flags & M_VERIFY)
         handler = mutt_signed_handler;
     }
-    else if ((WithCrypto & APPLICATION_PGP)
-             && mutt_strcasecmp ("encrypted", b->subtype) == 0) {
-      p = mutt_get_parameter ("protocol", b->parameter);
+    else if (tok == MIME_ENCRYPTED) {
+      p = parameter_getval(b->parameter, "protocol");
 
       if (!p)
-        mutt_error (_
-                    ("Error: multipart/encrypted has no protocol parameter!"));
-
-      else if (ascii_strcasecmp ("application/pgp-encrypted", p) == 0)
+        mutt_error(_("Error: multipart/encrypted has no protocol parameter!"));
+      else if (mime_which_token(p, -1) == MIME_APPLICATION_PGP_ENCRYPTED)
         handler = crypt_pgp_encrypted_handler;
     }
 
     if (!handler)
       handler = multipart_handler;
   }
-  else if (WithCrypto && b->type == TYPEAPPLICATION) {
-    if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (b))
+  else if (b->type == TYPEAPPLICATION) {
+    if (mutt_is_application_pgp (b))
       handler = crypt_pgp_application_pgp_handler;
-    if ((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime (b))
+    if (mutt_is_application_smime (b))
       handler = crypt_smime_application_smime_handler;
   }
 
-
   if (plaintext || handler) {
-    fseek (s->fpin, b->offset, 0);
+    fseeko (s->fpin, b->offset, 0);
 
     /* see if we need to decode this part before processing it */
-    if (b->encoding == ENCBASE64 || b->encoding == ENCQUOTEDPRINTABLE || b->encoding == ENCUUENCODED || plaintext || mutt_is_text_part (b)) {   /* text subtypes may
-                                                                                                                                                 * require character
-                                                                                                                                                 * set conversion even
-                                                                                                                                                 * with 8bit encoding.
-                                                                                                                                                 */
+    if (b->encoding == ENCBASE64 || b->encoding == ENCQUOTEDPRINTABLE
+    ||  b->encoding == ENCUUENCODED || plaintext || mutt_is_text_part (b)) {
+        /* text subtypes may require character set conversion even with 8bit
+           encoding.  */
       int origType = b->type;
       char *savePrefix = NULL;
 
       if (!plaintext) {
         /* decode to a tempfile, saving the original destination */
         fp = s->fpout;
-        mutt_mktemp (tempfile);
-        if ((s->fpout = safe_fopen (tempfile, "w")) == NULL) {
+        s->fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(mod_core.tmpdir), NULL);
+        if (!s->fpout) {
           mutt_error _("Unable to open temporary file!");
-
           goto bail;
         }
         /* decoding the attachment changes the size and offset, so save a copy
@@ -1931,16 +1400,16 @@ void mutt_body_handler (BODY * b, STATE * s)
         s->prefix = NULL;
 
         decode = 1;
-      }
-      else
+      } else {
         b->type = TYPETEXT;
+      }
 
       mutt_decode_attachment (b, s);
 
       if (decode) {
-        b->length = ftell (s->fpout);
+        b->length = ftello (s->fpout);
         b->offset = 0;
-        fclose (s->fpout);
+        m_fclose(&s->fpout);
 
         /* restore final destination and substitute the tempfile for input */
         s->fpout = fp;
@@ -1957,18 +1426,17 @@ void mutt_body_handler (BODY * b, STATE * s)
 
     /* process the (decoded) body part */
     if (handler) {
-      handler (b, s);
+      rc = handler (b, s);
 
       if (decode) {
         b->length = tmplength;
         b->offset = tmpoffset;
 
         /* restore the original source stream */
-        fclose (s->fpin);
+        m_fclose(&s->fpin);
         s->fpin = fp;
       }
     }
-    s->flags |= M_FIRSTDONE;
   }
   else if (s->flags & M_DISPLAY) {
     state_mark_attach (s);
@@ -1985,5 +1453,6 @@ void mutt_body_handler (BODY * b, STATE * s)
   }
 
 bail:
-  s->flags = oflags | (s->flags & M_FIRSTDONE);
+  s->flags = oflags;
+  return rc;
 }