NEWS: Encourage nmh-announce subscription. Capitalise `Gmail'.

[nmh] / uip / mhfixmsg.c
diff --git a/uip/mhfixmsg.c b/uip/mhfixmsg.c

index 372dbb9ce8e065764dec20fe692818738b89dd25..eedee6cc6514217ff91867d893a2651ec1f7c162 100644 (file)
--- a/uip/mhfixmsg.c
+++ b/uip/mhfixmsg.c
@@ -1,16 +1,49 @@
-/*
- * mhfixmsg.c -- rewrite a message with various transformations
+/* mhfixmsg.c -- rewrite a message with various transformations
   *
   * This code is Copyright (c) 2002 and 2013, by the authors of nmh.
   * See the COPYRIGHT file in the root directory of the nmh
   * distribution for complete copyright information.
   */
  
   *
   * This code is Copyright (c) 2002 and 2013, by the authors of nmh.
   * See the COPYRIGHT file in the root directory of the nmh
   * distribution for complete copyright information.
   */
  
-#include <h/mh.h>
-#include <h/mime.h>
-#include <h/mhparse.h>
-#include <h/utils.h>
-#include <h/signals.h>
+#include "h/mh.h"
+#include "sbr/m_name.h"
+#include "sbr/m_gmprot.h"
+#include "sbr/m_getfld.h"
+#include "sbr/getarguments.h"
+#include "sbr/concat.h"
+#include "sbr/seq_setprev.h"
+#include "sbr/seq_setcur.h"
+#include "sbr/seq_save.h"
+#include "sbr/smatch.h"
+#include "sbr/fmt_rfc2047.h"
+#include "sbr/cpydata.h"
+#include "sbr/trimcpy.h"
+#include "sbr/m_convert.h"
+#include "sbr/m_backup.h"
+#include "sbr/getfolder.h"
+#include "sbr/folder_read.h"
+#include "sbr/context_save.h"
+#include "sbr/context_replace.h"
+#include "sbr/context_find.h"
+#include "sbr/readconfig.h"
+#include "sbr/ambigsw.h"
+#include "sbr/path.h"
+#include "sbr/print_version.h"
+#include "sbr/print_help.h"
+#include "sbr/error.h"
+#include "h/fmt_scan.h"
+#include "h/mime.h"
+#include "h/mhparse.h"
+#include "h/done.h"
+#include "h/utils.h"
+#include "h/signals.h"
+#include "sbr/m_maildir.h"
+#include "sbr/m_mktemp.h"
+#include "sbr/mime_type.h"
+#include "mhmisc.h"
+#include "mhfree.h"
+#include "mhoutsbr.h"
+#include "mhshowsbr.h"
  #include <fcntl.h>
  
  #define MHFIXMSG_SWITCHES \
  #include <fcntl.h>
  
  #define MHFIXMSG_SWITCHES \
@@ -55,24 +88,6 @@ int debugsw; /* Needed by mhparse.c. */
  
  #define quitser pipeser
  
  
  #define quitser pipeser
  
-/* mhparse.c */
-extern int skip_mp_cte_check;                 /* flag to InitMultiPart */
-extern int suppress_bogus_mp_content_warning; /* flag to InitMultiPart */
-extern int bogus_mp_content;                  /* flag from InitMultiPart */
-/* flags to/from parse_header_attrs */
-extern int suppress_extraneous_trailing_semicolon_warning;
-extern int extraneous_trailing_semicolon;
-
-/* mhoutsbr.c */
-int output_message (CT, char *);
-
-/* mhmisc.c */
-void flush_errors (void);
-
-/* mhfree.c */
-extern CT *cts;
-void freects_done (int) NORETURN;
-
  /*
   * static prototypes
   */
  /*
   * static prototypes
   */
@@ -89,9 +104,10 @@ typedef struct fix_transformations {
      char *textcharset;
  } fix_transformations;
  
      char *textcharset;
  } fix_transformations;
  
-int mhfixmsgsbr (CT *, const fix_transformations *, char *);
+static int mhfixmsgsbr (CT *, char *, const fix_transformations *,
+    FILE **, char *, FILE **);
  static int fix_boundary (CT *, int *);
  static int fix_boundary (CT *, int *);
-static int copy_input_to_output (const char *, const char *);
+static int copy_input_to_output (const char *, FILE *, const char *, FILE *);
  static int get_multipart_boundary (CT, char **);
  static int replace_boundary (CT, char *, char *);
  static int fix_types (CT, svector_t, int *);
  static int get_multipart_boundary (CT, char **);
  static int replace_boundary (CT, char *, char *);
  static int fix_types (CT, svector_t, int *);
@@ -117,31 +133,33 @@ static int should_decode(const char *, const char *, const char *);
  static int content_encoding (CT, const char **);
  static int strip_crs (CT, int *);
  static void update_cte (CT);
  static int content_encoding (CT, const char **);
  static int strip_crs (CT, int *);
  static void update_cte (CT);
-static int least_restrictive_encoding (CT);
+static int least_restrictive_encoding (CT) PURE;
  static int less_restrictive (int, int);
  static int convert_charsets (CT, char *, int *);
  static int fix_always (CT, int *);
  static int fix_filename_param (char *, char *, PM *, PM *);
  static int fix_filename_encoding (CT);
  static int less_restrictive (int, int);
  static int convert_charsets (CT, char *, int *);
  static int fix_always (CT, int *);
  static int fix_filename_param (char *, char *, PM *, PM *);
  static int fix_filename_encoding (CT);
-static int write_content (CT, const char *, char *, int, int);
+static int write_content (CT, const char *, char *, FILE *, int, int);
  static void set_text_ctparams(CT, char *, int);
  static int remove_file (const char *);
  static void set_text_ctparams(CT, char *, int);
  static int remove_file (const char *);
-static void report (char *, char *, char *, char *, ...);
+static void report (char *, char *, char *, char *, ...)
+    CHECK_PRINTF(4, 5);
  static void pipeser (int);
  
  
  int
  static void pipeser (int);
  
  
  int
-main (int argc, char **argv) {
+main (int argc, char **argv)
+{
      int msgnum;
      char *cp, *file = NULL, *folder = NULL;
      int msgnum;
      char *cp, *file = NULL, *folder = NULL;
-    char *maildir, buf[100], *outfile = NULL;
+    char *maildir = NULL, buf[100], *outfile = NULL;
      char **argp, **arguments;
      struct msgs_array msgs = { 0, 0, NULL };
      struct msgs *mp = NULL;
      CT *ctp;
      char **argp, **arguments;
      struct msgs_array msgs = { 0, 0, NULL };
      struct msgs *mp = NULL;
      CT *ctp;
-    FILE *fp;
-    int using_stdin = 0;
-    int chgflag = 1;
+    FILE *fp, *infp = NULL, *outfp = NULL;
+    bool using_stdin = false;
+    bool chgflag = true;
      int status = OK;
      fix_transformations fx;
      fx.reformat = fx.fixcompositecte = fx.fixboundary = 1;
      int status = OK;
      fix_transformations fx;
      fx.reformat = fx.fixcompositecte = fx.fixboundary = 1;
@@ -152,9 +170,7 @@ main (int argc, char **argv) {
      fx.lf_line_endings = 0;
      fx.textcharset = NULL;
  
      fx.lf_line_endings = 0;
      fx.textcharset = NULL;
  
-    if (nmh_init(argv[0], 2)) { return 1; }
-
-    done = freects_done;
+    if (nmh_init(argv[0], true, false)) { return 1; }
  
      arguments = getarguments (invo_name, argc, argv, 1);
      argp = arguments;
  
      arguments = getarguments (invo_name, argc, argv, 1);
      argp = arguments;
@@ -169,7 +185,7 @@ main (int argc, char **argv) {
                  ambigsw (cp, switches);
                  done (1);
              case UNKWNSW:
                  ambigsw (cp, switches);
                  done (1);
              case UNKWNSW:
-                adios (NULL, "-%s unknown", cp);
+                die("-%s unknown", cp);
  
              case HELPSW:
                  snprintf (buf, sizeof buf, "%s [+folder] [msgs] [switches]",
  
              case HELPSW:
                  snprintf (buf, sizeof buf, "%s [+folder] [msgs] [switches]",
@@ -182,7 +198,7 @@ main (int argc, char **argv) {
  
              case DECODETEXTSW:
                  if (! (cp = *argp++)  ||  *cp == '-') {
  
              case DECODETEXTSW:
                  if (! (cp = *argp++)  ||  *cp == '-') {
-                    adios (NULL, "missing argument to %s", argp[-2]);
+                    die("missing argument to %s", argp[-2]);
                  }
                  if (! strcasecmp (cp, "8bit")) {
                      fx.decodetext = CE_8BIT;
                  }
                  if (! strcasecmp (cp, "8bit")) {
                      fx.decodetext = CE_8BIT;
@@ -191,7 +207,7 @@ main (int argc, char **argv) {
                  } else if (! strcasecmp (cp, "binary")) {
                      fx.decodetext = CE_BINARY;
                  } else {
                  } else if (! strcasecmp (cp, "binary")) {
                      fx.decodetext = CE_BINARY;
                  } else {
-                    adios (NULL, "invalid argument to %s", argp[-2]);
+                    die("invalid argument to %s", argp[-2]);
                  }
                  continue;
              case NDECODETEXTSW:
                  }
                  continue;
              case NDECODETEXTSW:
@@ -199,7 +215,7 @@ main (int argc, char **argv) {
                  continue;
              case DECODETYPESW:
                  if (! (cp = *argp++)  ||  *cp == '-') {
                  continue;
              case DECODETYPESW:
                  if (! (cp = *argp++)  ||  *cp == '-') {
-                    adios (NULL, "missing argument to %s", argp[-2]);
+                    die("missing argument to %s", argp[-2]);
                  }
                  fx.decodetypes = cp;
                  continue;
                  }
                  fx.decodetypes = cp;
                  continue;
@@ -211,7 +227,7 @@ main (int argc, char **argv) {
                  continue;
              case TEXTCHARSETSW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
                  continue;
              case TEXTCHARSETSW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
-                    adios (NULL, "missing argument to %s", argp[-2]);
+                    die("missing argument to %s", argp[-2]);
                  }
                  fx.textcharset = cp;
                  continue;
                  }
                  fx.textcharset = cp;
                  continue;
@@ -232,14 +248,13 @@ main (int argc, char **argv) {
                  continue;
              case FIXTYPESW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
                  continue;
              case FIXTYPESW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
-                    adios (NULL, "missing argument to %s", argp[-2]);
+                    die("missing argument to %s", argp[-2]);
                  }
                  if (! strncasecmp (cp, "multipart/", 10)  ||
                  }
                  if (! strncasecmp (cp, "multipart/", 10)  ||
-                    ! strncasecmp (cp, "message/", 8)) {
-                    adios (NULL, "-fixtype %s not allowed", cp);
-                } else if (! strchr (cp, '/')) {
-                    adios (NULL, "-fixtype requires type/subtype");
-                }
+                    ! strncasecmp (cp, "message/", 8))
+                    die("-fixtype %s not allowed", cp);
+                if (! strchr (cp, '/'))
+                    die("-fixtype requires type/subtype");
                  if (fx.fixtypes == NULL) { fx.fixtypes = svector_create (10); }
                  svector_push_back (fx.fixtypes, cp);
                  continue;
                  if (fx.fixtypes == NULL) { fx.fixtypes = svector_create (10); }
                  svector_push_back (fx.fixtypes, cp);
                  continue;
@@ -257,29 +272,29 @@ main (int argc, char **argv) {
                  continue;
              case FILESW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
                  continue;
              case FILESW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
-                    adios (NULL, "missing argument to %s", argp[-2]);
+                    die("missing argument to %s", argp[-2]);
                  }
                  }
-                file = *cp == '-'  ?  add (cp, NULL)  :  path (cp, TFILE);
+                file = *cp == '-'  ?  mh_xstrdup (cp)  :  path (cp, TFILE);
                  continue;
              case OUTFILESW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
                  continue;
              case OUTFILESW:
                  if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
-                    adios (NULL, "missing argument to %s", argp[-2]);
+                    die("missing argument to %s", argp[-2]);
                  }
                  }
-                outfile = *cp == '-'  ?  add (cp, NULL)  :  path (cp, TFILE);
+                outfile = *cp == '-'  ?  mh_xstrdup (cp)  :  path (cp, TFILE);
                  continue;
              case RPROCSW:
                  if (!(rmmproc = *argp++) || *rmmproc == '-') {
                  continue;
              case RPROCSW:
                  if (!(rmmproc = *argp++) || *rmmproc == '-') {
-                    adios (NULL, "missing argument to %s", argp[-2]);
+                    die("missing argument to %s", argp[-2]);
                  }
                  continue;
              case NRPRCSW:
                  rmmproc = NULL;
                  continue;
              case CHGSW:
                  }
                  continue;
              case NRPRCSW:
                  rmmproc = NULL;
                  continue;
              case CHGSW:
-                chgflag = 1;
+                chgflag = true;
                  continue;
              case NCHGSW:
                  continue;
              case NCHGSW:
-                chgflag = 0;
+                chgflag = false;
                  continue;
              case VERBSW:
                  verbosw = 1;
                  continue;
              case VERBSW:
                  verbosw = 1;
@@ -290,15 +305,13 @@ main (int argc, char **argv) {
              }
          }
          if (*cp == '+' || *cp == '@') {
              }
          }
          if (*cp == '+' || *cp == '@') {
-            if (folder) {
-                adios (NULL, "only one folder at a time!");
-            } else {
-                folder = pluspath (cp);
-            }
+            if (folder)
+                die("only one folder at a time!");
+            folder = pluspath (cp);
          } else {
              if (*cp == '/') {
                  /* Interpret a full path as a filename, not a message. */
          } else {
              if (*cp == '/') {
                  /* Interpret a full path as a filename, not a message. */
-                file = add (cp, NULL);
+                file = mh_xstrdup (cp);
              } else {
                  app_msgarg (&msgs, cp);
              }
              } else {
                  app_msgarg (&msgs, cp);
              }
@@ -312,19 +325,29 @@ main (int argc, char **argv) {
       * Read the standard profile setup
       */
      if ((fp = fopen (cp = etcpath ("mhn.defaults"), "r"))) {
       * Read the standard profile setup
       */
      if ((fp = fopen (cp = etcpath ("mhn.defaults"), "r"))) {
-        readconfig ((struct node **) 0, fp, cp, 0);
+        readconfig(NULL, fp, cp, 0);
          fclose (fp);
      }
  
          fclose (fp);
      }
  
-    suppress_bogus_mp_content_warning = skip_mp_cte_check = 1;
-    suppress_extraneous_trailing_semicolon_warning = 1;
+    suppress_bogus_mp_content_warning = skip_mp_cte_check = true;
+    suppress_extraneous_trailing_semicolon_warning = true;
  
      if (! context_find ("path")) {
          free (path ("./", TFOLDER));
      }
  
      if (file && msgs.size) {
  
      if (! context_find ("path")) {
          free (path ("./", TFOLDER));
      }
  
      if (file && msgs.size) {
-        adios (NULL, "cannot specify msg and file at same time!");
+        die("cannot specify msg and file at same time!");
+    }
+
+    if (outfile) {
+        /* Open the outfile now, so we don't have to risk opening it
+           after running out of fds. */
+        if (strcmp (outfile, "-") == 0) {
+            outfp = stdout;
+        } else if ((outfp = fopen (outfile, "w")) == NULL) {
+            adios (outfile, "unable to open for writing");
+        }
      }
  
      /*
      }
  
      /*
@@ -341,20 +364,20 @@ main (int argc, char **argv) {
              int fd;
              char *cp;
  
              int fd;
              char *cp;
  
-            using_stdin = 1;
+            using_stdin = true;
  
              if ((cp = m_mktemp2 (NULL, invo_name, &fd, NULL)) == NULL) {
  
              if ((cp = m_mktemp2 (NULL, invo_name, &fd, NULL)) == NULL) {
-                adios (NULL, "unable to create temporary file in %s",
+                die("unable to create temporary file in %s",
                         get_temp_dir());
              } else {
                  free (file);
                         get_temp_dir());
              } else {
                  free (file);
-                file = add (cp, NULL);
+                file = mh_xstrdup (cp);
                  cpydata (STDIN_FILENO, fd, "-", file);
              }
  
              if (close (fd)) {
                  (void) m_unlink (file);
                  cpydata (STDIN_FILENO, fd, "-", file);
              }
  
              if (close (fd)) {
                  (void) m_unlink (file);
-                adios (NULL, "failed to write temporary file");
+                die("failed to write temporary file");
              }
          }
  
              }
          }
  
@@ -365,17 +388,26 @@ main (int argc, char **argv) {
              set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings);
              *ctp++ = ct;
          } else {
              set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings);
              *ctp++ = ct;
          } else {
-            advise (NULL, "unable to parse message from file %s", file);
+            inform("unable to parse message from file %s", file);
              status = NOTOK;
  
              status = NOTOK;
  
-            /* If there's an outfile, pass the input message unchanged, so the message won't
-               get dropped from a pipeline. */
+            /* If there's an outfile, pass the input message unchanged, so the
+               message won't get dropped from a pipeline. */
              if (outfile) {
              if (outfile) {
-                /* Something went wrong.  Output might be expected, such as if this were run
-                   as a filter.  Just copy the input to the output. */
-                if (copy_input_to_output (file, outfile) != OK) {
-                    advise (NULL, "unable to copy message to %s, it might be lost\n", outfile);
+                /* Something went wrong.  Output might be expected, such as if
+                   this were run as a filter.  Just copy the input to the
+                   output. */
+                if ((infp = fopen (file, "r")) == NULL) {
+                    adios (file, "unable to open for reading");
+                }
+
+                if (copy_input_to_output (file, infp, outfile, outfp) != OK) {
+                    inform("unable to copy message to %s, "
+                            "it might be lost\n", outfile);
                  }
                  }
+
+                fclose (infp);
+                infp = NULL;
              }
          }
      } else {
              }
          }
      } else {
@@ -390,20 +422,22 @@ main (int argc, char **argv) {
          if (! folder) {
              folder = getfolder (1);
          }
          if (! folder) {
              folder = getfolder (1);
          }
-        maildir = m_maildir (folder);
+        maildir = mh_xstrdup(m_maildir (folder));
  
  
+        /* chdir so that error messages, esp. from MIME parser, just
+           refer to the message and not its path. */
          if (chdir (maildir) == NOTOK) {
              adios (maildir, "unable to change directory to");
          }
  
          /* read folder and create message structure */
          if (! (mp = folder_read (folder, 1))) {
          if (chdir (maildir) == NOTOK) {
              adios (maildir, "unable to change directory to");
          }
  
          /* read folder and create message structure */
          if (! (mp = folder_read (folder, 1))) {
-            adios (NULL, "unable to read folder %s", folder);
+            die("unable to read folder %s", folder);
          }
  
          /* check for empty folder */
          if (mp->nummsg == 0) {
          }
  
          /* check for empty folder */
          if (mp->nummsg == 0) {
-            adios (NULL, "no messages in %s", folder);
+            die("no messages in %s", folder);
          }
  
          /* parse all the message ranges/sequences and set SELECTED */
          }
  
          /* parse all the message ranges/sequences and set SELECTED */
@@ -418,26 +452,42 @@ main (int argc, char **argv) {
  
          for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
              if (is_selected(mp, msgnum)) {
  
          for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
              if (is_selected(mp, msgnum)) {
-                char *msgnam;
+                char *msgnam = m_name (msgnum);
  
  
-                msgnam = m_name (msgnum);
                  if ((ct = parse_mime (msgnam))) {
                      set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings);
                      *ctp++ = ct;
                  } else {
                  if ((ct = parse_mime (msgnam))) {
                      set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings);
                      *ctp++ = ct;
                  } else {
-                    advise (NULL, "unable to parse message %s", msgnam);
+                    inform("unable to parse message %s", msgnam);
                      status = NOTOK;
  
                      status = NOTOK;
  
-                    /* If there's an outfile, pass the input message unchanged, so the message won't
-                       get dropped from a pipeline. */
+                    /* If there's an outfile, pass the input message
+                       unchanged, so the message won't get dropped from a
+                       pipeline. */
                      if (outfile) {
                      if (outfile) {
-                        /* Something went wrong.  Output might be expected, such as if this were run
-                           as a filter.  Just copy the input to the output. */
-                        const char *input_filename = path (msgnam, TFILE);
+                        /* Something went wrong.  Output might be expected,
+                           such as if this were run as a filter.  Just copy
+                           the input to the output. */
+                        /* Can't use path() here because 1) it might have been
+                           called before and it caches the pwd, and 2) we call
+                           chdir() after that. */
+                        char *input_filename =
+                            concat (maildir, "/", msgnam, NULL);
+
+                        if ((infp = fopen (input_filename, "r")) == NULL) {
+                            adios (input_filename,
+                                   "unable to open for reading");
+                        }
  
  
-                        if (copy_input_to_output (input_filename, outfile) != OK) {
-                            advise (NULL, "unable to copy message to %s, it might be lost\n", outfile);
+                        if (copy_input_to_output (input_filename, infp,
+                                                  outfile, outfp) != OK) {
+                            inform("unable to copy message to %s, "
+                                "it might be lost\n", outfile);
                          }
                          }
+
+                        fclose (infp);
+                        infp = NULL;
+                        free (input_filename);
                      }
                  }
              }
                      }
                  }
              }
@@ -453,7 +503,11 @@ main (int argc, char **argv) {
  
      if (*cts) {
          for (ctp = cts; *ctp; ++ctp) {
  
      if (*cts) {
          for (ctp = cts; *ctp; ++ctp) {
-            status += mhfixmsgsbr (ctp, &fx, outfile);
+            status =
+                mhfixmsgsbr (ctp, maildir, &fx, &infp, outfile, &outfp) == OK
+                ? 0
+                : 1;
+            free_content (*ctp);
  
              if (using_stdin) {
                  (void) m_unlink (file);
  
              if (using_stdin) {
                  (void) m_unlink (file);
@@ -468,14 +522,18 @@ main (int argc, char **argv) {
          status = 1;
      }
  
          status = 1;
      }
  
+    free(maildir);
+    free (cts);
+
      if (fx.fixtypes != NULL) { svector_free (fx.fixtypes); }
      if (fx.fixtypes != NULL) { svector_free (fx.fixtypes); }
+    if (infp) { fclose (infp); }    /* even if stdin */
+    if (outfp) { fclose (outfp); }  /* even if stdout */
      free (outfile);
      free (file);
      free (folder);
      free (arguments);
  
      free (outfile);
      free (file);
      free (folder);
      free (arguments);
  
-    /* done is freects_done, which will clean up all of cts. */
-    done (status);
+    done (status == OK ? 0 : 1);
      return NOTOK;
  }
  
      return NOTOK;
  }
  
@@ -483,29 +541,42 @@ main (int argc, char **argv) {
  /*
   * Apply transformations to one message.
   */
  /*
   * Apply transformations to one message.
   */
-int
-mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) {
+static int
+mhfixmsgsbr (CT *ctp, char *maildir, const fix_transformations *fx,
+             FILE **infp, char *outfile, FILE **outfp)
+{
      /* Store input filename in case one of the transformations, i.e.,
         fix_boundary(), rewrites to a tmp file. */
      /* Store input filename in case one of the transformations, i.e.,
         fix_boundary(), rewrites to a tmp file. */
-    char *input_filename = add ((*ctp)->c_file, NULL);
-    int modify_inplace = 0;
+    char *input_filename = maildir
+        ?  concat (maildir, "/", (*ctp)->c_file, NULL)
+        :  mh_xstrdup ((*ctp)->c_file);
+    bool modify_inplace = false;
      int message_mods = 0;
      int status = OK;
  
      int message_mods = 0;
      int status = OK;
  
+    /* Though the input file won't need to be opened if everything goes
+       well, do it here just in case there's a failure, and that failure is
+       running out of file descriptors. */
+    if ((*infp = fopen (input_filename, "r")) == NULL) {
+        adios (input_filename, "unable to open for reading");
+    }
+
      if (outfile == NULL) {
      if (outfile == NULL) {
-        modify_inplace = 1;
+        modify_inplace = true;
  
          if ((*ctp)->c_file) {
              char *tempfile;
  
          if ((*ctp)->c_file) {
              char *tempfile;
-            if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) {
-                adios (NULL, "unable to create temporary file in %s",
+            /* outfp will be closed by the caller */
+            if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, outfp)) ==
+                NULL) {
+                die("unable to create temporary file in %s",
                         get_temp_dir());
              }
                         get_temp_dir());
              }
-            outfile = add (tempfile, NULL);
+            outfile = mh_xstrdup (tempfile);
          } else {
          } else {
-            adios (NULL, "missing both input and output filenames\n");
+            die("missing both input and output filenames\n");
          }
          }
-    }
+    } /* else *outfp was defined by caller */
  
      reverse_alternative_parts (*ctp);
      status = fix_always (*ctp, &message_mods);
  
      reverse_alternative_parts (*ctp);
      status = fix_always (*ctp, &message_mods);
@@ -547,14 +618,16 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) {
       * Write the content to a file
       */
      if (status == OK) {
       * Write the content to a file
       */
      if (status == OK) {
-        status = write_content (*ctp, input_filename, outfile, modify_inplace,
-                                message_mods);
+        status = write_content (*ctp, input_filename, outfile, *outfp,
+                                modify_inplace, message_mods);
      } else if (! modify_inplace) {
          /* Something went wrong.  Output might be expected, such
             as if this were run as a filter.  Just copy the input
             to the output. */
      } else if (! modify_inplace) {
          /* Something went wrong.  Output might be expected, such
             as if this were run as a filter.  Just copy the input
             to the output. */
-        if (copy_input_to_output (input_filename, outfile) != OK) {
-            advise (NULL, "unable to copy message to %s, it might be lost\n", outfile);
+        if (copy_input_to_output (input_filename, *infp, outfile,
+                                  *outfp) != OK) {
+            inform("unable to copy message to %s, it might be lost\n",
+                    outfile);
          }
      }
  
          }
      }
  
@@ -564,6 +637,8 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) {
          outfile = NULL;
      }
  
          outfile = NULL;
      }
  
+    fclose (*infp);
+    *infp = NULL;
      free (input_filename);
  
      return status;
      free (input_filename);
  
      return status;
@@ -575,11 +650,11 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) {
   * might be running as part of a pipeline.
   */
  static int
   * might be running as part of a pipeline.
   */
  static int
-copy_input_to_output (const char *input_filename, const char *output_filename) {
-    int in = open (input_filename, O_RDONLY);
-    int out = strcmp (output_filename, "-")
-        ?  open (output_filename, O_WRONLY | O_CREAT, m_gmprot ())
-        :  STDOUT_FILENO;
+copy_input_to_output (const char *input_filename, FILE *infp,
+                      const char *output_filename, FILE *outfp)
+{
+    int in = fileno (infp);
+    int out = fileno (outfp);
      int status = OK;
  
      if (in != -1  &&  out != -1) {
      int status = OK;
  
      if (in != -1  &&  out != -1) {
@@ -588,9 +663,6 @@ copy_input_to_output (const char *input_filename, const char *output_filename) {
          status = NOTOK;
      }
  
          status = NOTOK;
      }
  
-    close (out);
-    close (in);
-
      return status;
  }
  
      return status;
  }
  
@@ -599,7 +671,8 @@ copy_input_to_output (const char *input_filename, const char *output_filename) {
   * Fix mismatched outer level boundary.
   */
  static int
   * Fix mismatched outer level boundary.
   */
  static int
-fix_boundary (CT *ct, int *message_mods) {
+fix_boundary (CT *ct, int *message_mods)
+{
      struct multipart *mp;
      int status = OK;
  
      struct multipart *mp;
      int status = OK;
  
@@ -624,7 +697,7 @@ fix_boundary (CT *ct, int *message_mods) {
  
                  if ((fixed = m_mktemp2 (NULL, invo_name, NULL, &(*ct)->c_fp))) {
                      if (replace_boundary (*ct, fixed, part_boundary) == OK) {
  
                  if ((fixed = m_mktemp2 (NULL, invo_name, NULL, &(*ct)->c_fp))) {
                      if (replace_boundary (*ct, fixed, part_boundary) == OK) {
-                        char *filename = add ((*ct)->c_file, NULL);
+                        char *filename = mh_xstrdup ((*ct)->c_file);
                          CT fixed_ct;
  
                          free_content (*ct);
                          CT fixed_ct;
  
                          free_content (*ct);
@@ -639,16 +712,16 @@ fix_boundary (CT *ct, int *message_mods) {
                              }
                          } else {
                              *ct = NULL;
                              }
                          } else {
                              *ct = NULL;
-                            advise (NULL, "unable to parse fixed part");
+                            inform("unable to parse fixed part");
                              status = NOTOK;
                          }
                          free (filename);
                      } else {
                              status = NOTOK;
                          }
                          free (filename);
                      } else {
-                        advise (NULL, "unable to replace broken boundary");
+                        inform("unable to replace broken boundary");
                          status = NOTOK;
                      }
                  } else {
                          status = NOTOK;
                      }
                  } else {
-                    advise (NULL, "unable to create temporary file in %s",
+                    inform("unable to create temporary file in %s",
                              get_temp_dir());
                      status = NOTOK;
                  }
                              get_temp_dir());
                      status = NOTOK;
                  }
@@ -675,8 +748,9 @@ fix_boundary (CT *ct, int *message_mods) {
   * Find boundary at end of multipart.
   */
  static int
   * Find boundary at end of multipart.
   */
  static int
-get_multipart_boundary (CT ct, char **part_boundary) {
-    char buffer[BUFSIZ];
+get_multipart_boundary (CT ct, char **part_boundary)
+{
+    char buffer[NMH_BUFSIZ];
      char *end_boundary = NULL;
      off_t begin = (off_t) ct->c_end > (off_t) (ct->c_begin + sizeof buffer)
          ?  (off_t) (ct->c_end - sizeof buffer)
      char *end_boundary = NULL;
      off_t begin = (off_t) ct->c_end > (off_t) (ct->c_begin + sizeof buffer)
          ?  (off_t) (ct->c_end - sizeof buffer)
@@ -684,10 +758,10 @@ get_multipart_boundary (CT ct, char **part_boundary) {
      size_t bytes_read;
      int status = OK;
  
      size_t bytes_read;
      int status = OK;
  
-    /* This will fail if the boundary spans fread() calls.  BUFSIZ should
+    /* This will fail if the boundary spans fread() calls.  NMH_BUFSIZ should
         be big enough, even if it's just 1024, to make that unlikely. */
  
         be big enough, even if it's just 1024, to make that unlikely. */
  
-    /* free_content() will close ct->c_fp. */
+    /* free_content() will close ct->c_fp if bogus MP boundary is fixed. */
      if (! ct->c_fp  &&  (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
          advise (ct->c_file, "unable to open for reading");
          return NOTOK;
      if (! ct->c_fp  &&  (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
          advise (ct->c_file, "unable to open for reading");
          return NOTOK;
@@ -707,18 +781,16 @@ get_multipart_boundary (CT ct, char **part_boundary) {
                  if ((end = rfind_str (buffer, cp - buffer, "\n"))) {
                      if (strlen (end) > 3  &&  *end++ == '\n'  &&
                          *end++ == '-'  &&  *end++ == '-') {
                  if ((end = rfind_str (buffer, cp - buffer, "\n"))) {
                      if (strlen (end) > 3  &&  *end++ == '\n'  &&
                          *end++ == '-'  &&  *end++ == '-') {
-                        end_boundary = add (end, NULL);
+                        end_boundary = mh_xstrdup (end);
                          break;
                      }
                  }
              }
          }
  
                          break;
                      }
                  }
              }
          }
  
-        if (! end_boundary  &&  begin > (off_t) (ct->c_begin + sizeof buffer)) {
-            begin -= sizeof buffer;
-        } else {
+        if (end_boundary  ||  begin <= (off_t) (ct->c_begin + sizeof buffer))
              break;
              break;
-        }
+        begin -= sizeof buffer;
      }
  
      /* Get boundary at beginning of multipart. */
      }
  
      /* Get boundary at beginning of multipart. */
@@ -744,6 +816,11 @@ get_multipart_boundary (CT ct, char **part_boundary) {
          status = NOTOK;
      }
  
          status = NOTOK;
      }
  
+    if (ct->c_fp) {
+        fclose (ct->c_fp);
+        ct->c_fp = NULL;
+    }
+
      if (status == OK) {
          *part_boundary = end_boundary;
      } else {
      if (status == OK) {
          *part_boundary = end_boundary;
      } else {
@@ -759,16 +836,17 @@ get_multipart_boundary (CT ct, char **part_boundary) {
   * Open and copy ct->c_file to file, replacing the multipart boundary.
   */
  static int
   * Open and copy ct->c_file to file, replacing the multipart boundary.
   */
  static int
-replace_boundary (CT ct, char *file, char *boundary) {
+replace_boundary (CT ct, char *file, char *boundary)
+{
      FILE *fpin, *fpout;
      int compnum, state;
      FILE *fpin, *fpout;
      int compnum, state;
-    char buf[BUFSIZ], name[NAMESZ];
+    char buf[NMH_BUFSIZ], name[NAMESZ];
      char *np, *vp;
      char *np, *vp;
-    m_getfld_state_t gstate = 0;
+    m_getfld_state_t gstate;
      int status = OK;
  
      if (ct->c_file == NULL) {
      int status = OK;
  
      if (ct->c_file == NULL) {
-        advise (NULL, "missing input filename");
+        inform("missing input filename");
          return NOTOK;
      }
  
          return NOTOK;
      }
  
@@ -783,22 +861,23 @@ replace_boundary (CT ct, char *file, char *boundary) {
          return NOTOK;
      }
  
          return NOTOK;
      }
  
+    gstate = m_getfld_state_init(fpin);
      for (compnum = 1;;) {
          int bufsz = (int) sizeof buf;
  
      for (compnum = 1;;) {
          int bufsz = (int) sizeof buf;
  
-        switch (state = m_getfld (&gstate, name, buf, &bufsz, fpin)) {
+        switch (state = m_getfld2(&gstate, name, buf, &bufsz)) {
          case FLD:
          case FLDPLUS:
              compnum++;
  
              /* get copies of the buffers */
          case FLD:
          case FLDPLUS:
              compnum++;
  
              /* get copies of the buffers */
-            np = add (name, NULL);
-            vp = add (buf, NULL);
+            np = mh_xstrdup (name);
+            vp = mh_xstrdup (buf);
  
              /* if necessary, get rest of field */
              while (state == FLDPLUS) {
                  bufsz = sizeof buf;
  
              /* if necessary, get rest of field */
              while (state == FLDPLUS) {
                  bufsz = sizeof buf;
-                state = m_getfld (&gstate, name, buf, &bufsz, fpin);
+                state = m_getfld2(&gstate, name, buf, &bufsz);
                  vp = add (buf, vp);     /* add to previous value */
              }
  
                  vp = add (buf, vp);     /* add to previous value */
              }
  
@@ -813,15 +892,13 @@ replace_boundary (CT ct, char *file, char *boundary) {
  
                 new_ctline = concat(" ", ct->c_ctinfo.ci_type, "/",
                                     ct->c_ctinfo.ci_subtype, NULL);
  
                 new_ctline = concat(" ", ct->c_ctinfo.ci_type, "/",
                                     ct->c_ctinfo.ci_subtype, NULL);
-               new_params = output_params(strlen(TYPE_FIELD) +
+               new_params = output_params(LEN(TYPE_FIELD) +
                                            strlen(new_ctline) + 1,
                                            ct->c_ctinfo.ci_first_pm, NULL, 0);
                  fprintf (fpout, "%s:%s%s\n", np, new_ctline,
                                            strlen(new_ctline) + 1,
                                            ct->c_ctinfo.ci_first_pm, NULL, 0);
                  fprintf (fpout, "%s:%s%s\n", np, new_ctline,
-                        new_params ? new_params : "");
+                        FENDNULL(new_params));
                 free(new_ctline);
                 free(new_ctline);
-               if (new_params) {
-                   free(new_params);
-                }
+                free(new_params);
              }
  
              free (vp);
              }
  
              free (vp);
@@ -842,12 +919,12 @@ replace_boundary (CT ct, char *file, char *boundary) {
  
          case LENERR:
          case FMTERR:
  
          case LENERR:
          case FMTERR:
-            advise (NULL, "message format error in component #%d", compnum);
+            inform("message format error in component #%d", compnum);
              status = NOTOK;
              break;
  
          default:
              status = NOTOK;
              break;
  
          default:
-            advise (NULL, "getfld() returned %d", state);
+            inform("getfld() returned %d", state);
              status = NOTOK;
              break;
          }
              status = NOTOK;
              break;
          }
@@ -867,7 +944,8 @@ replace_boundary (CT ct, char *file, char *boundary) {
   * Fix Content-Type header to reflect the content of its part.
   */
  static int
   * Fix Content-Type header to reflect the content of its part.
   */
  static int
-fix_types (CT ct, svector_t fixtypes, int *message_mods) {
+fix_types (CT ct, svector_t fixtypes, int *message_mods)
+{
      int status = OK;
  
      switch (ct->c_type) {
      int status = OK;
  
      switch (ct->c_type) {
@@ -929,7 +1007,7 @@ fix_types (CT ct, svector_t fixtypes, int *message_mods) {
                              *cp = '\0';
                              ct_subtype = mh_xstrdup(++cp);
                          } else {
                              *cp = '\0';
                              ct_subtype = mh_xstrdup(++cp);
                          } else {
-                            advise (NULL, "missing / in MIME type of %s %s",
+                            inform("missing / in MIME type of %s %s",
                                      ct->c_file, ct->c_partno);
                              free (ct_type);
                              return NOTOK;
                                      ct->c_file, ct->c_partno);
                              free (ct_type);
                              return NOTOK;
@@ -944,7 +1022,7 @@ fix_types (CT ct, svector_t fixtypes, int *message_mods) {
                          ct->c_ctinfo.ci_subtype = ct_subtype;
                          if (! replace_substring (&ct->c_ctline, type,
                                                   ct_type_subtype)) {
                          ct->c_ctinfo.ci_subtype = ct_subtype;
                          if (! replace_substring (&ct->c_ctline, type,
                                                   ct_type_subtype)) {
-                            advise (NULL, "did not find %s in %s",
+                            inform("did not find %s in %s",
                                      type, ct->c_ctline);
                          }
  
                                      type, ct->c_ctline);
                          }
  
@@ -961,10 +1039,8 @@ fix_types (CT ct, svector_t fixtypes, int *message_mods) {
                                                  type, ct_type_subtype);
                                      }
                                      break;
                                                  type, ct_type_subtype);
                                      }
                                      break;
-                                } else {
-                                    advise (NULL, "did not find %s in %s",
-                                            type, hf->value);
                                  }
                                  }
+                                inform("did not find %s in %s", type, hf->value);
                              }
                          }
                      }
                              }
                          }
                      }
@@ -983,7 +1059,8 @@ fix_types (CT ct, svector_t fixtypes, int *message_mods) {
   * Replace a substring, allocating space to hold the new one.
   */
  char *
   * Replace a substring, allocating space to hold the new one.
   */
  char *
-replace_substring (char **str, const char *old, const char *new) {
+replace_substring (char **str, const char *old, const char *new)
+{
      char *cp;
  
      if ((cp = strstr (*str, old))) {
      char *cp;
  
      if ((cp = strstr (*str, old))) {
@@ -1012,9 +1089,10 @@ replace_substring (char **str, const char *old, const char *new) {
   * Remove a name=value parameter, given just its name, from a header value.
   */
  char *
   * Remove a name=value parameter, given just its name, from a header value.
   */
  char *
-remove_parameter (char *str, const char *name) {
+remove_parameter (char *str, const char *name)
+{
      /* It looks to me, based on the BNF in RFC 2045, than there can't
      /* It looks to me, based on the BNF in RFC 2045, than there can't
-       be whitespace betwwen the parameter name and the "=", or
+       be whitespace between the parameter name and the "=", or
         between the "=" and the parameter value. */
      char *param_name = concat (name, "=", NULL);
      char *cp;
         between the "=" and the parameter value. */
      char *param_name = concat (name, "=", NULL);
      char *cp;
@@ -1061,7 +1139,8 @@ remove_parameter (char *str, const char *name) {
   * 8 bit.
   */
  static int
   * 8 bit.
   */
  static int
-fix_composite_cte (CT ct, int *message_mods) {
+fix_composite_cte (CT ct, int *message_mods)
+{
      int status = OK;
  
      if (ct->c_type == CT_MESSAGE  ||  ct->c_type == CT_MULTIPART) {
      int status = OK;
  
      if (ct->c_type == CT_MESSAGE  ||  ct->c_type == CT_MULTIPART) {
@@ -1071,17 +1150,17 @@ fix_composite_cte (CT ct, int *message_mods) {
  
              for (hf = ct->c_first_hf; hf; hf = hf->next) {
                  char *name = hf->name;
  
              for (hf = ct->c_first_hf; hf; hf = hf->next) {
                  char *name = hf->name;
-                for (; *name && isspace ((unsigned char) *name); ++name) {
+                for (; isspace((unsigned char)*name); ++name) {
                      continue;
                  }
  
                  if (! strncasecmp (name, ENCODING_FIELD,
                      continue;
                  }
  
                  if (! strncasecmp (name, ENCODING_FIELD,
-                                   strlen (ENCODING_FIELD))) {
+                                   LEN(ENCODING_FIELD))) {
                      char *prefix = "Nmh-REPLACED-INVALID-";
                      HF h;
  
                      NEW(h);
                      char *prefix = "Nmh-REPLACED-INVALID-";
                      HF h;
  
                      NEW(h);
-                    h->name = add (hf->name, NULL);
+                    h->name = mh_xstrdup (hf->name);
                      h->hf_encoding = hf->hf_encoding;
                      h->next = hf->next;
                      hf->next = h;
                      h->hf_encoding = hf->hf_encoding;
                      h->next = hf->next;
                      hf->next = h;
@@ -1099,7 +1178,7 @@ fix_composite_cte (CT ct, int *message_mods) {
                          free (encoding);
                      }
  
                          free (encoding);
                      }
  
-                    h->value = add (" 8bit\n", NULL);
+                    h->value = mh_xstrdup (" 8bit\n");
  
                      /* Don't need to warn for multiple C-T-E header
                         fields, parse_mime() already does that.  But
  
                      /* Don't need to warn for multiple C-T-E header
                         fields, parse_mime() already does that.  But
@@ -1133,13 +1212,14 @@ fix_composite_cte (CT ct, int *message_mods) {
   * Set content encoding.
   */
  static int
   * Set content encoding.
   */
  static int
-set_ce (CT ct, int encoding) {
+set_ce (CT ct, int encoding)
+{
      const char *ce = ce_str (encoding);
      const struct str2init *ctinit = get_ce_method (ce);
  
      if (ctinit) {
          char *cte = concat (" ", ce, "\n", NULL);
      const char *ce = ce_str (encoding);
      const struct str2init *ctinit = get_ce_method (ce);
  
      if (ctinit) {
          char *cte = concat (" ", ce, "\n", NULL);
-        int found_cte = 0;
+        bool found_cte = false;
          HF hf;
          /* Decoded contents might be in ct->c_cefile.ce_file, if the
             caller is decode_text_parts ().  Save because we'll
          HF hf;
          /* Decoded contents might be in ct->c_cefile.ce_file, if the
             caller is decode_text_parts ().  Save because we'll
@@ -1166,18 +1246,18 @@ set_ce (CT ct, int encoding) {
          /* Update/add Content-Transfer-Encoding header field. */
          for (hf = ct->c_first_hf; hf; hf = hf->next) {
              if (! strcasecmp (ENCODING_FIELD, hf->name)) {
          /* Update/add Content-Transfer-Encoding header field. */
          for (hf = ct->c_first_hf; hf; hf = hf->next) {
              if (! strcasecmp (ENCODING_FIELD, hf->name)) {
-                found_cte = 1;
+                found_cte = true;
                  free (hf->value);
                  hf->value = cte;
              }
          }
          if (! found_cte) {
                  free (hf->value);
                  hf->value = cte;
              }
          }
          if (! found_cte) {
-            add_header (ct, add (ENCODING_FIELD, NULL), cte);
+            add_header (ct, mh_xstrdup (ENCODING_FIELD), cte);
          }
  
          /* Update c_celine.  It's used only by mhlist -debug. */
          free (ct->c_celine);
          }
  
          /* Update c_celine.  It's used only by mhlist -debug. */
          free (ct->c_celine);
-        ct->c_celine = add (cte, NULL);
+        ct->c_celine = mh_xstrdup (cte);
  
          return OK;
      }
  
          return OK;
      }
@@ -1190,7 +1270,8 @@ set_ce (CT ct, int encoding) {
   * Make sure each text part has a corresponding text/plain part.
   */
  static int
   * Make sure each text part has a corresponding text/plain part.
   */
  static int
-ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
+ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain)
+{
      int status = OK;
  
      switch ((*ct)->c_type) {
      int status = OK;
  
      switch ((*ct)->c_type) {
@@ -1277,12 +1358,12 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
                          HF hf;
  
                          parent->c_subtype = MULTI_ALTERNATE;
                          HF hf;
  
                          parent->c_subtype = MULTI_ALTERNATE;
+                        free (parent->c_ctinfo.ci_subtype);
                          parent->c_ctinfo.ci_subtype = mh_xstrdup("alternative");
                          if (! replace_substring (&parent->c_ctline, "/related",
                                                   "/alternative")) {
                          parent->c_ctinfo.ci_subtype = mh_xstrdup("alternative");
                          if (! replace_substring (&parent->c_ctline, "/related",
                                                   "/alternative")) {
-                            advise (NULL,
-                                    "did not find multipart/related in %s",
-                                    parent->c_ctline);
+                            inform("did not find multipart/related in %s",
+                                parent->c_ctline);
                          }
  
                          /* Update Content-Type header field. */
                          }
  
                          /* Update Content-Type header field. */
@@ -1301,11 +1382,9 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
                                         multipart/alternative. */
                                      remove_parameter (hf->value, "type");
                                      break;
                                         multipart/alternative. */
                                      remove_parameter (hf->value, "type");
                                      break;
-                                } else {
-                                    advise (NULL, "did not find multipart/"
-                                                  "related in header %s",
-                                            hf->value);
                                  }
                                  }
+                                inform("did not find multipart/"
+                                    "related in header %s", hf->value);
                              }
                          }
                      } else {
                              }
                          }
                      } else {
@@ -1353,10 +1432,11 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
   */
  static int
  find_textplain_sibling (CT parent, int replacetextplain,
   */
  static int
  find_textplain_sibling (CT parent, int replacetextplain,
-                        int *new_subpart_number) {
+                        int *new_subpart_number)
+{
      struct multipart *mp = (struct multipart *) parent->c_ctparams;
      struct part *part, *prev;
      struct multipart *mp = (struct multipart *) parent->c_ctparams;
      struct part *part, *prev;
-    int has_text_plain = 0;
+    bool has_text_plain = false;
  
      for (prev = part = mp->mp_parts; part; part = part->mp_next) {
          ++*new_subpart_number;
  
      for (prev = part = mp->mp_parts; part; part = part->mp_next) {
          ++*new_subpart_number;
@@ -1379,7 +1459,7 @@ find_textplain_sibling (CT parent, int replacetextplain,
                  free_content (old_part->mp_part);
                  free (old_part);
              } else {
                  free_content (old_part->mp_part);
                  free (old_part);
              } else {
-                has_text_plain = 1;
+                has_text_plain = true;
              }
              break;
          }
              }
              break;
          }
@@ -1394,7 +1474,8 @@ find_textplain_sibling (CT parent, int replacetextplain,
   * Insert a new text/plain part.
   */
  static int
   * Insert a new text/plain part.
   */
  static int
-insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent) {
+insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent)
+{
      struct multipart *mp = (struct multipart *) parent->c_ctparams;
      struct part *new_part;
  
      struct multipart *mp = (struct multipart *) parent->c_ctparams;
      struct part *new_part;
  
@@ -1423,7 +1504,8 @@ insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent) {
   * Create a text/plain part to go along with non-plain sibling part.
   */
  static CT
   * Create a text/plain part to go along with non-plain sibling part.
   */
  static CT
-build_text_plain_part (CT encoded_part) {
+build_text_plain_part (CT encoded_part)
+{
      CT tp_part = divide_part (encoded_part);
      char *tmp_plain_file = NULL;
  
      CT tp_part = divide_part (encoded_part);
      char *tmp_plain_file = NULL;
  
@@ -1434,11 +1516,12 @@ build_text_plain_part (CT encoded_part) {
             be unlinked by free_content (). */
          char *tempfile;
  
             be unlinked by free_content (). */
          char *tempfile;
  
+        /* This m_mktemp2() call closes the temp file. */
          if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) {
          if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) {
-            advise (NULL, "unable to create temporary file in %s",
+            inform("unable to create temporary file in %s",
                      get_temp_dir());
          } else {
                      get_temp_dir());
          } else {
-            tmp_plain_file = add (tempfile, NULL);
+            tmp_plain_file = mh_xstrdup (tempfile);
              if (reformat_part (tp_part, tmp_plain_file,
                                 tp_part->c_ctinfo.ci_type,
                                 tp_part->c_ctinfo.ci_subtype,
              if (reformat_part (tp_part, tmp_plain_file,
                                 tp_part->c_ctinfo.ci_type,
                                 tp_part->c_ctinfo.ci_subtype,
@@ -1460,7 +1543,8 @@ build_text_plain_part (CT encoded_part) {
   * Slip new text/plain part into a new multipart/alternative.
   */
  static int
   * Slip new text/plain part into a new multipart/alternative.
   */
  static int
-insert_into_new_mp_alt (CT *ct, int *message_mods) {
+insert_into_new_mp_alt (CT *ct, int *message_mods)
+{
      CT tp_part = build_text_plain_part (*ct);
      int status = OK;
  
      CT tp_part = build_text_plain_part (*ct);
      int status = OK;
  
@@ -1500,13 +1584,14 @@ insert_into_new_mp_alt (CT *ct, int *message_mods) {
   * Clone a MIME part.
   */
  static CT
   * Clone a MIME part.
   */
  static CT
-divide_part (CT ct) {
+divide_part (CT ct)
+{
      CT new_part;
  
      NEW0(new_part);
      /* Just copy over what is needed for decoding.  c_vrsn and
         c_celine aren't necessary. */
      CT new_part;
  
      NEW0(new_part);
      /* Just copy over what is needed for decoding.  c_vrsn and
         c_celine aren't necessary. */
-    new_part->c_file = add (ct->c_file, NULL);
+    new_part->c_file = mh_xstrdup (ct->c_file);
      new_part->c_begin = ct->c_begin;
      new_part->c_end = ct->c_end;
      copy_ctinfo (&new_part->c_ctinfo, &ct->c_ctinfo);
      new_part->c_begin = ct->c_begin;
      new_part->c_end = ct->c_end;
      copy_ctinfo (&new_part->c_ctinfo, &ct->c_ctinfo);
@@ -1520,7 +1605,7 @@ divide_part (CT ct) {
  
      /* c_ctline is used by reformat__part(), so it can preserve
         anything after the type/subtype. */
  
      /* c_ctline is used by reformat__part(), so it can preserve
         anything after the type/subtype. */
-    new_part->c_ctline = add (ct->c_ctline, NULL);
+    new_part->c_ctline = mh_xstrdup (ct->c_ctline);
  
      return new_part;
  }
  
      return new_part;
  }
@@ -1530,11 +1615,12 @@ divide_part (CT ct) {
   * Copy the content info from one part to another.
   */
  static void
   * Copy the content info from one part to another.
   */
  static void
-copy_ctinfo (CI dest, CI src) {
+copy_ctinfo (CI dest, CI src)
+{
      PM s_pm, d_pm;
  
      PM s_pm, d_pm;
  
-    dest->ci_type = src->ci_type ? add (src->ci_type, NULL) : NULL;
-    dest->ci_subtype = src->ci_subtype ? add (src->ci_subtype, NULL) : NULL;
+    dest->ci_type = src->ci_type ? mh_xstrdup (src->ci_type) : NULL;
+    dest->ci_subtype = src->ci_subtype ? mh_xstrdup (src->ci_subtype) : NULL;
  
      for (s_pm = src->ci_first_pm; s_pm; s_pm = s_pm->pm_next) {
         d_pm = add_param(&dest->ci_first_pm, &dest->ci_last_pm, s_pm->pm_name,
  
      for (s_pm = src->ci_first_pm; s_pm; s_pm = s_pm->pm_next) {
         d_pm = add_param(&dest->ci_first_pm, &dest->ci_last_pm, s_pm->pm_name,
@@ -1547,8 +1633,8 @@ copy_ctinfo (CI dest, CI src) {
          }
      }
  
          }
      }
  
-    dest->ci_comment = src->ci_comment ? add (src->ci_comment, NULL) : NULL;
-    dest->ci_magic = src->ci_magic ? add (src->ci_magic, NULL) : NULL;
+    dest->ci_comment = src->ci_comment ? mh_xstrdup (src->ci_comment) : NULL;
+    dest->ci_magic = src->ci_magic ? mh_xstrdup (src->ci_magic) : NULL;
  }
  
  
  }
  
  
@@ -1556,21 +1642,26 @@ copy_ctinfo (CI dest, CI src) {
   * Decode content.
   */
  static int
   * Decode content.
   */
  static int
-decode_part (CT ct) {
+decode_part (CT ct)
+{
      char *tmp_decoded;
      int status;
      char *tmp_decoded;
      int status;
+    FILE *file;
      char *tempfile;
  
      char *tempfile;
  
-    if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) {
-        adios (NULL, "unable to create temporary file in %s", get_temp_dir());
+    if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, &file)) == NULL) {
+        die("unable to create temporary file in %s", get_temp_dir());
      }
      }
-    tmp_decoded = add (tempfile, NULL);
+    tmp_decoded = mh_xstrdup (tempfile);
      /* The following call will load ct->c_cefile.ce_file with the tmp
         filename of the decoded content.  tmp_decoded will contain the
         encoded output, get rid of that. */
      /* The following call will load ct->c_cefile.ce_file with the tmp
         filename of the decoded content.  tmp_decoded will contain the
         encoded output, get rid of that. */
-    status = output_message (ct, tmp_decoded);
+    status = output_message_fp (ct, file, tmp_decoded);
      (void) m_unlink (tmp_decoded);
      free (tmp_decoded);
      (void) m_unlink (tmp_decoded);
      free (tmp_decoded);
+    if (fclose (file)) {
+        inform("unable to close temporary file %s, continuing...", tempfile);
+    }
  
      return status;
  }
  
      return status;
  }
@@ -1582,7 +1673,8 @@ decode_part (CT ct) {
   * be in the future for other than text types.
   */
  static int
   * be in the future for other than text types.
   */
  static int
-reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) {
+reformat_part (CT ct, char *file, char *type, char *subtype, int c_type)
+{
      int output_subtype, output_encoding;
      const char *reason = NULL;
      char *cp, *cf;
      int output_subtype, output_encoding;
      const char *reason = NULL;
      char *cp, *cf;
@@ -1596,16 +1688,16 @@ reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) {
      /* Check for invo_name-format-type/subtype. */
      if ((cf = context_find_by_type ("format", type, subtype)) == NULL) {
          if (verbosw) {
      /* Check for invo_name-format-type/subtype. */
      if ((cf = context_find_by_type ("format", type, subtype)) == NULL) {
          if (verbosw) {
-            advise (NULL, "Don't know how to convert %s, there is no "
+            inform("Don't know how to convert %s, there is no "
                      "%s-format-%s/%s profile entry",
                      ct->c_file, invo_name, type, subtype);
          }
          return NOTOK;
      }
      if (strchr (cf, '>')) {
                      "%s-format-%s/%s profile entry",
                      ct->c_file, invo_name, type, subtype);
          }
          return NOTOK;
      }
      if (strchr (cf, '>')) {
-        advise (NULL, "'>' prohibited in \"%s\",\nplease fix your "
+        inform("'>' prohibited in \"%s\",\nplease fix your "
                  "%s-format-%s/%s profile entry", cf, invo_name, type,
                  "%s-format-%s/%s profile entry", cf, invo_name, type,
-                subtype ? subtype : "");
+                FENDNULL(subtype));
  
          return NOTOK;
      }
  
          return NOTOK;
      }
@@ -1631,7 +1723,8 @@ reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) {
      }
  
      output_encoding = content_encoding (ct, &reason);
      }
  
      output_encoding = content_encoding (ct, &reason);
-    if (set_ct_type (ct, c_type, output_subtype, output_encoding) == OK) {
+    if (status == OK  &&
+        set_ct_type (ct, c_type, output_subtype, output_encoding) == OK) {
          ct->c_cefile.ce_file = file;
          ct->c_cefile.ce_unlink = 1;
      } else {
          ct->c_cefile.ce_file = file;
          ct->c_cefile.ce_unlink = 1;
      } else {
@@ -1647,7 +1740,8 @@ reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) {
   * Fill in a multipart/alternative part.
   */
  static CT
   * Fill in a multipart/alternative part.
   */
  static CT
-build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
+build_multipart_alt (CT first_alt, CT new_part, int type, int subtype)
+{
      char *boundary_prefix = "----=_nmh-multipart";
      char *boundary = concat (boundary_prefix, first_alt->c_partno, NULL);
      char *boundary_indicator = "; boundary=";
      char *boundary_prefix = "----=_nmh-multipart";
      char *boundary = concat (boundary_prefix, first_alt->c_partno, NULL);
      char *boundary_indicator = "; boundary=";
@@ -1672,7 +1766,7 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
         c_showproc, c_termproc, c_storeproc, c_storage, c_folder
      */
  
         c_showproc, c_termproc, c_storeproc, c_storage, c_folder
      */
  
-    ct->c_file = add (first_alt->c_file, NULL);
+    ct->c_file = mh_xstrdup (first_alt->c_file);
      ct->c_type = type;
      ct->c_subtype = subtype;
  
      ct->c_type = type;
      ct->c_subtype = subtype;
  
@@ -1694,20 +1788,19 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
                  if ((found_boundary =
                       boundary_in_content (&new_part->c_cefile.ce_fp,
                                            new_part->c_cefile.ce_file,
                  if ((found_boundary =
                       boundary_in_content (&new_part->c_cefile.ce_fp,
                                            new_part->c_cefile.ce_file,
-                                          boundary)) == -1) {
-                    free (ct);
-                    return NULL;
+                                          boundary)) == NOTOK) {
+                    goto return_null;
                  }
              }
  
              /* Ensure that the boundary doesn't appear in the encoded
                 content. */
              if (! found_boundary  &&  new_part->c_file) {
                  }
              }
  
              /* Ensure that the boundary doesn't appear in the encoded
                 content. */
              if (! found_boundary  &&  new_part->c_file) {
-                if ((found_boundary = boundary_in_content (&new_part->c_fp,
-                                                           new_part->c_file,
-                                                           boundary)) == -1) {
-                    free (ct);
-                    return NULL;
+                if ((found_boundary =
+                     boundary_in_content (&new_part->c_fp,
+                                          new_part->c_file,
+                                          boundary)) == NOTOK) {
+                    goto return_null;
                  }
              }
  
                  }
              }
  
@@ -1720,15 +1813,14 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
                  snprintf (buffer2, sizeof buffer2, "%d", serial);
                  boundary =
                      concat (boundary_prefix,
                  snprintf (buffer2, sizeof buffer2, "%d", serial);
                  boundary =
                      concat (boundary_prefix,
-                            first_alt->c_partno ? first_alt->c_partno : "",
+                            FENDNULL(first_alt->c_partno),
                              "-", buffer2,  NULL);
              }
          }
  
          if (found_boundary) {
                              "-", buffer2,  NULL);
              }
          }
  
          if (found_boundary) {
-            advise (NULL, "giving up trying to find a unique boundary");
-            free (ct);
-            return NULL;
+            inform("giving up trying to find a unique boundary");
+            goto return_null;
          }
      }
  
          }
      }
  
@@ -1737,23 +1829,23 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
  
      /* Load c_first_hf and c_last_hf. */
      transfer_noncontent_headers (first_alt, ct);
  
      /* Load c_first_hf and c_last_hf. */
      transfer_noncontent_headers (first_alt, ct);
-    add_header (ct, add (TYPE_FIELD, NULL), concat (name, "\n", NULL));
+    add_header (ct, mh_xstrdup (TYPE_FIELD), concat (name, "\n", NULL));
      free (name);
  
      /* Load c_partno. */
      if (first_alt->c_partno) {
      free (name);
  
      /* Load c_partno. */
      if (first_alt->c_partno) {
-        ct->c_partno = add (first_alt->c_partno, NULL);
+        ct->c_partno = mh_xstrdup (first_alt->c_partno);
          free (first_alt->c_partno);
          first_alt->c_partno = concat (ct->c_partno, ".1", NULL);
          new_part->c_partno = concat (ct->c_partno, ".2", NULL);
      } else {
          free (first_alt->c_partno);
          first_alt->c_partno = concat (ct->c_partno, ".1", NULL);
          new_part->c_partno = concat (ct->c_partno, ".2", NULL);
      } else {
-        first_alt->c_partno = add ("1", NULL);
-        new_part->c_partno = add ("2", NULL);
+        first_alt->c_partno = mh_xstrdup ("1");
+        new_part->c_partno = mh_xstrdup ("2");
      }
  
      if (ctinit) {
      }
  
      if (ctinit) {
-        ct->c_ctinfo.ci_type = add (typename, NULL);
-        ct->c_ctinfo.ci_subtype = add (subtypename, NULL);
+        ct->c_ctinfo.ci_type = mh_xstrdup (typename);
+        ct->c_ctinfo.ci_subtype = mh_xstrdup (subtypename);
      }
  
      add_param(&ct->c_ctinfo.ci_first_pm, &ct->c_ctinfo.ci_last_pm,
      }
  
      add_param(&ct->c_ctinfo.ci_first_pm, &ct->c_ctinfo.ci_last_pm,
@@ -1773,6 +1865,11 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
      free (boundary);
  
      return ct;
      free (boundary);
  
      return ct;
+
+return_null:
+    free_content(ct);
+    free(boundary);
+    return NULL;
  }
  
  
  }
  
  
@@ -1780,10 +1877,11 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
   * Check that the boundary does not appear in the content.
   */
  static int
   * Check that the boundary does not appear in the content.
   */
  static int
-boundary_in_content (FILE **fp, char *file, const char *boundary) {
-    char buffer[BUFSIZ];
+boundary_in_content (FILE **fp, char *file, const char *boundary)
+{
+    char buffer[NMH_BUFSIZ];
      size_t bytes_read;
      size_t bytes_read;
-    int found_boundary = 0;
+    bool found_boundary = false;
  
      /* free_content() will close *fp if we fopen it here. */
      if (! *fp  &&  (*fp = fopen (file, "r")) == NULL) {
  
      /* free_content() will close *fp if we fopen it here. */
      if (! *fp  &&  (*fp = fopen (file, "r")) == NULL) {
@@ -1794,7 +1892,7 @@ boundary_in_content (FILE **fp, char *file, const char *boundary) {
      fseeko (*fp, 0L, SEEK_SET);
      while ((bytes_read = fread (buffer, 1, sizeof buffer, *fp)) > 0) {
          if (find_str (buffer, bytes_read, boundary)) {
      fseeko (*fp, 0L, SEEK_SET);
      while ((bytes_read = fread (buffer, 1, sizeof buffer, *fp)) > 0) {
          if (find_str (buffer, bytes_read, boundary)) {
-            found_boundary = 1;
+            found_boundary = true;
              break;
          }
      }
              break;
          }
      }
@@ -1807,14 +1905,15 @@ boundary_in_content (FILE **fp, char *file, const char *boundary) {
   * Remove all non-Content headers.
   */
  static void
   * Remove all non-Content headers.
   */
  static void
-transfer_noncontent_headers (CT old, CT new) {
+transfer_noncontent_headers (CT old, CT new)
+{
      HF hp, hp_prev;
  
      hp_prev = hp = old->c_first_hf;
      while (hp) {
          HF next = hp->next;
  
      HF hp, hp_prev;
  
      hp_prev = hp = old->c_first_hf;
      while (hp) {
          HF next = hp->next;
  
-        if (strncasecmp (XXX_FIELD_PRF, hp->name, strlen (XXX_FIELD_PRF))) {
+        if (strncasecmp (XXX_FIELD_PRF, hp->name, LEN(XXX_FIELD_PRF))) {
              if (hp == old->c_last_hf) {
                  if (hp == old->c_first_hf) {
                      old->c_last_hf =  old->c_first_hf = NULL;
              if (hp == old->c_last_hf) {
                  if (hp == old->c_first_hf) {
                      old->c_last_hf =  old->c_first_hf = NULL;
@@ -1851,14 +1950,15 @@ transfer_noncontent_headers (CT old, CT new) {
   * Set content type.
   */
  static int
   * Set content type.
   */
  static int
-set_ct_type (CT ct, int type, int subtype, int encoding) {
+set_ct_type (CT ct, int type, int subtype, int encoding)
+{
      char *typename = ct_type_str (type);
      char *subtypename = ct_subtype_str (type, subtype);
      /* E.g, " text/plain" */
      char *type_subtypename = concat (" ", typename, "/", subtypename, NULL);
      /* E.g, " text/plain\n" */
      char *name_plus_nl = concat (type_subtypename, "\n", NULL);
      char *typename = ct_type_str (type);
      char *subtypename = ct_subtype_str (type, subtype);
      /* E.g, " text/plain" */
      char *type_subtypename = concat (" ", typename, "/", subtypename, NULL);
      /* E.g, " text/plain\n" */
      char *name_plus_nl = concat (type_subtypename, "\n", NULL);
-    int found_content_type = 0;
+    bool found_content_type = false;
      HF hf;
      const char *cp = NULL;
      char *ctline;
      HF hf;
      const char *cp = NULL;
      char *ctline;
@@ -1867,18 +1967,18 @@ set_ct_type (CT ct, int type, int subtype, int encoding) {
      /* Update/add Content-Type header field. */
      for (hf = ct->c_first_hf; hf; hf = hf->next) {
          if (! strcasecmp (TYPE_FIELD, hf->name)) {
      /* Update/add Content-Type header field. */
      for (hf = ct->c_first_hf; hf; hf = hf->next) {
          if (! strcasecmp (TYPE_FIELD, hf->name)) {
-            found_content_type = 1;
+            found_content_type = true;
              free (hf->value);
              hf->value = (cp = strchr (ct->c_ctline, ';'))
                  ?  concat (type_subtypename, cp, "\n", NULL)
              free (hf->value);
              hf->value = (cp = strchr (ct->c_ctline, ';'))
                  ?  concat (type_subtypename, cp, "\n", NULL)
-                :  add (name_plus_nl, NULL);
+                :  mh_xstrdup (name_plus_nl);
          }
      }
      if (! found_content_type) {
          }
      }
      if (! found_content_type) {
-        add_header (ct, add (TYPE_FIELD, NULL),
+        add_header (ct, mh_xstrdup (TYPE_FIELD),
                      (cp = strchr (ct->c_ctline, ';'))
                      ?  concat (type_subtypename, cp, "\n", NULL)
                      (cp = strchr (ct->c_ctline, ';'))
                      ?  concat (type_subtypename, cp, "\n", NULL)
-                    :  add (name_plus_nl, NULL));
+                    :  mh_xstrdup (name_plus_nl));
      }
  
      /* Some of these might not be used, but set them anyway. */
      }
  
      /* Some of these might not be used, but set them anyway. */
@@ -1889,9 +1989,9 @@ set_ct_type (CT ct, int type, int subtype, int encoding) {
      ct->c_ctline = ctline;
      /* Leave other ctinfo members as they were. */
      free (ct->c_ctinfo.ci_type);
      ct->c_ctline = ctline;
      /* Leave other ctinfo members as they were. */
      free (ct->c_ctinfo.ci_type);
-    ct->c_ctinfo.ci_type = add (typename, NULL);
+    ct->c_ctinfo.ci_type = mh_xstrdup (typename);
      free (ct->c_ctinfo.ci_subtype);
      free (ct->c_ctinfo.ci_subtype);
-    ct->c_ctinfo.ci_subtype = add (subtypename, NULL);
+    ct->c_ctinfo.ci_subtype = mh_xstrdup (subtypename);
      ct->c_type = type;
      ct->c_subtype = subtype;
  
      ct->c_type = type;
      ct->c_subtype = subtype;
  
@@ -1912,7 +2012,8 @@ set_ct_type (CT ct, int type, int subtype, int encoding) {
   */
  static int
  decode_text_parts (CT ct, int encoding, const char *decodetypes,
   */
  static int
  decode_text_parts (CT ct, int encoding, const char *decodetypes,
-                   int *message_mods) {
+                   int *message_mods)
+{
      int status = OK;
      int lf_line_endings = 0;
  
      int status = OK;
      int lf_line_endings = 0;
  
@@ -1963,8 +2064,7 @@ decode_text_parts (CT ct, int encoding, const char *decodetypes,
                          report (NULL, ct->c_partno, ct->c_file,
                                  "will not decode%s because it is binary (%s)",
                                  ct->c_partno  ?  ""
                          report (NULL, ct->c_partno, ct->c_file,
                                  "will not decode%s because it is binary (%s)",
                                  ct->c_partno  ?  ""
-                                              :  ct->c_ctline  ?  ct->c_ctline
-                                                               :  "",
+                                              :  (FENDNULL(ct->c_ctline)),
                                  reason);
                      }
                      (void) m_unlink (ct->c_cefile.ce_file);
                                  reason);
                      }
                      (void) m_unlink (ct->c_cefile.ce_file);
@@ -1978,8 +2078,7 @@ decode_text_parts (CT ct, int encoding, const char *decodetypes,
                          report (NULL, ct->c_partno, ct->c_file,
                                  "will not decode%s because it is 8bit",
                                  ct->c_partno  ?  ""
                          report (NULL, ct->c_partno, ct->c_file,
                                  "will not decode%s because it is 8bit",
                                  ct->c_partno  ?  ""
-                                              :  ct->c_ctline  ?  ct->c_ctline
-                                                               :  "");
+                                              :  (FENDNULL(ct->c_ctline)));
                      }
                      (void) m_unlink (ct->c_cefile.ce_file);
                      free (ct->c_cefile.ce_file);
                      }
                      (void) m_unlink (ct->c_cefile.ce_file);
                      free (ct->c_cefile.ce_file);
@@ -1998,7 +2097,7 @@ decode_text_parts (CT ct, int encoding, const char *decodetypes,
                          ++*message_mods;
                          if (verbosw) {
                              report (NULL, ct->c_partno, ct->c_file, "decode%s",
                          ++*message_mods;
                          if (verbosw) {
                              report (NULL, ct->c_partno, ct->c_file, "decode%s",
-                                    ct->c_ctline ? ct->c_ctline : "");
+                                    FENDNULL(ct->c_ctline));
                          }
                          if (lf_line_endings) {
                              strip_crs (ct, message_mods);
                          }
                          if (lf_line_endings) {
                              strip_crs (ct, message_mods);
@@ -2034,23 +2133,24 @@ decode_text_parts (CT ct, int encoding, const char *decodetypes,
   * decodetypes (which came from the -decodetypes switch).
   */
  static int
   * decodetypes (which came from the -decodetypes switch).
   */
  static int
-should_decode(const char *decodetypes, const char *type, const char *subtype) {
+should_decode(const char *decodetypes, const char *type, const char *subtype)
+{
      /* Quick search for matching type[/subtype] in decodetypes:  bracket
         decodetypes with commas, then search for ,type, and ,type/subtype, in
         it. */
  
      /* Quick search for matching type[/subtype] in decodetypes:  bracket
         decodetypes with commas, then search for ,type, and ,type/subtype, in
         it. */
  
-    int found_match = 0;
+    bool found_match = false;
      char *delimited_decodetypes = concat(",", decodetypes, ",", NULL);
      char *delimited_type = concat(",", type, ",", NULL);
  
      if (nmh_strcasestr(delimited_decodetypes, delimited_type)) {
      char *delimited_decodetypes = concat(",", decodetypes, ",", NULL);
      char *delimited_type = concat(",", type, ",", NULL);
  
      if (nmh_strcasestr(delimited_decodetypes, delimited_type)) {
-        found_match = 1;
+        found_match = true;
      } else if (subtype != NULL) {
          char *delimited_type_subtype =
              concat(",", type, "/", subtype, ",", NULL);
  
          if (nmh_strcasestr(delimited_decodetypes, delimited_type_subtype)) {
      } else if (subtype != NULL) {
          char *delimited_type_subtype =
              concat(",", type, "/", subtype, ",", NULL);
  
          if (nmh_strcasestr(delimited_decodetypes, delimited_type_subtype)) {
-            found_match = 1;
+            found_match = true;
          }
          free(delimited_type_subtype);
      }
          }
          free(delimited_type_subtype);
      }
@@ -2069,13 +2169,14 @@ should_decode(const char *decodetypes, const char *type, const char *subtype) {
   *  to a string explaining why.
   */
  static int
   *  to a string explaining why.
   */
  static int
-content_encoding (CT ct, const char **reason) {
+content_encoding (CT ct, const char **reason)
+{
      CE ce = &ct->c_cefile;
      int encoding = CE_7BIT;
  
      if (ce->ce_file) {
          size_t line_len = 0;
      CE ce = &ct->c_cefile;
      int encoding = CE_7BIT;
  
      if (ce->ce_file) {
          size_t line_len = 0;
-        char buffer[BUFSIZ];
+        char buffer[NMH_BUFSIZ];
          size_t inbytes;
  
          if (! ce->ce_fp  &&  (ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
          size_t inbytes;
  
          if (! ce->ce_fp  &&  (ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
@@ -2105,13 +2206,14 @@ content_encoding (CT ct, const char **reason) {
                          *reason = "";
                      }
                      break;
                          *reason = "";
                      }
                      break;
-                } else if (*cp == '\n') {
+                }
+                if (*cp == '\n') {
                      line_len = 0;
                  } else if (! isascii ((unsigned char) *cp)) {
                      encoding = CE_8BIT;
                  }
  
                      line_len = 0;
                  } else if (! isascii ((unsigned char) *cp)) {
                      encoding = CE_8BIT;
                  }
  
-                last_char_was_cr = *cp == '\r'  ?  1  :  0;
+                last_char_was_cr = *cp == '\r';
              }
          }
  
              }
          }
  
@@ -2127,7 +2229,8 @@ content_encoding (CT ct, const char **reason) {
   * Strip carriage returns from content.
   */
  static int
   * Strip carriage returns from content.
   */
  static int
-strip_crs (CT ct, int *message_mods) {
+strip_crs (CT ct, int *message_mods)
+{
      char *charset = content_charset (ct);
      int status = OK;
  
      char *charset = content_charset (ct);
      int status = OK;
  
@@ -2144,8 +2247,8 @@ strip_crs (CT ct, int *message_mods) {
          FILE **fp = NULL;
          size_t begin;
          size_t end;
          FILE **fp = NULL;
          size_t begin;
          size_t end;
-        int has_crs = 0;
-        int opened_input_file = 0;
+        bool has_crs = false;
+        bool opened_input_file = false;
  
          if (ct->c_cefile.ce_file) {
              file = &ct->c_cefile.ce_file;
  
          if (ct->c_cefile.ce_file) {
              file = &ct->c_cefile.ce_file;
@@ -2164,13 +2267,13 @@ strip_crs (CT ct, int *message_mods) {
                      advise (*file, "unable to open for reading");
                      status = NOTOK;
                  } else {
                      advise (*file, "unable to open for reading");
                      status = NOTOK;
                  } else {
-                    opened_input_file = 1;
+                    opened_input_file = true;
                  }
              }
          }
  
          if (fp  &&  *fp) {
                  }
              }
          }
  
          if (fp  &&  *fp) {
-            char buffer[BUFSIZ];
+            char buffer[NMH_BUFSIZ];
              size_t bytes_read;
              size_t bytes_to_read =
                  end > 0 && end > begin  ?  end - begin  :  sizeof buffer;
              size_t bytes_read;
              size_t bytes_to_read =
                  end > 0 && end > begin  ?  end - begin  :  sizeof buffer;
@@ -2184,17 +2287,17 @@ strip_crs (CT ct, int *message_mods) {
                     modify the content. */
                  char *cp;
                  size_t i;
                     modify the content. */
                  char *cp;
                  size_t i;
-                int last_char_was_cr = 0;
+                bool last_char_was_cr = false;
  
                  if (end > 0) { bytes_to_read -= bytes_read; }
  
                  for (i = 0, cp = buffer; i < bytes_read; ++i, ++cp) {
                      if (*cp == '\n'  &&  last_char_was_cr) {
  
                  if (end > 0) { bytes_to_read -= bytes_read; }
  
                  for (i = 0, cp = buffer; i < bytes_read; ++i, ++cp) {
                      if (*cp == '\n'  &&  last_char_was_cr) {
-                        has_crs = 1;
+                        has_crs = true;
                          break;
                      }
  
                          break;
                      }
  
-                    last_char_was_cr = *cp == '\r'  ?  1  :  0;
+                    last_char_was_cr = *cp == '\r';
                  }
              }
  
                  }
              }
  
@@ -2204,10 +2307,10 @@ strip_crs (CT ct, int *message_mods) {
                  char *tempfile = m_mktemp2 (NULL, invo_name, &fd, NULL);
  
                  if (tempfile == NULL) {
                  char *tempfile = m_mktemp2 (NULL, invo_name, &fd, NULL);
  
                  if (tempfile == NULL) {
-                    adios (NULL, "unable to create temporary file in %s",
+                    die("unable to create temporary file in %s",
                             get_temp_dir());
                  }
                             get_temp_dir());
                  }
-                stripped_content_file = add (tempfile, NULL);
+                stripped_content_file = mh_xstrdup (tempfile);
  
                  /* Strip each CR before a LF from the content. */
                  fseeko (*fp, begin, SEEK_SET);
  
                  /* Strip each CR before a LF from the content. */
                  fseeko (*fp, begin, SEEK_SET);
@@ -2215,11 +2318,11 @@ strip_crs (CT ct, int *message_mods) {
                         0) {
                      char *cp;
                      size_t i;
                         0) {
                      char *cp;
                      size_t i;
-                    int last_char_was_cr = 0;
+                    bool last_char_was_cr = false;
  
                      for (i = 0, cp = buffer; i < bytes_read; ++i, ++cp) {
                          if (*cp == '\r') {
  
                      for (i = 0, cp = buffer; i < bytes_read; ++i, ++cp) {
                          if (*cp == '\r') {
-                            last_char_was_cr = 1;
+                            last_char_was_cr = true;
                          } else if (last_char_was_cr) {
                              if (*cp != '\n') {
                                  if (write (fd, "\r", 1) < 0) {
                          } else if (last_char_was_cr) {
                              if (*cp != '\n') {
                                  if (write (fd, "\r", 1) < 0) {
@@ -2229,29 +2332,28 @@ strip_crs (CT ct, int *message_mods) {
                              if (write (fd, cp, 1) < 0) {
                                  advise (tempfile, "write");
                              }
                              if (write (fd, cp, 1) < 0) {
                                  advise (tempfile, "write");
                              }
-                            last_char_was_cr = 0;
+                            last_char_was_cr = false;
                          } else {
                              if (write (fd, cp, 1) < 0) {
                                  advise (tempfile, "write");
                              }
                          } else {
                              if (write (fd, cp, 1) < 0) {
                                  advise (tempfile, "write");
                              }
-                            last_char_was_cr = 0;
+                            last_char_was_cr = false;
                          }
                      }
                  }
  
                  if (close (fd)) {
                          }
                      }
                  }
  
                  if (close (fd)) {
-                    admonish (NULL, "unable to write temporary file %s",
+                    inform("unable to write temporary file %s, continuing...",
                                stripped_content_file);
                      (void) m_unlink (stripped_content_file);
                                stripped_content_file);
                      (void) m_unlink (stripped_content_file);
+                    free(stripped_content_file);
                      status = NOTOK;
                  } else {
                      /* Replace the decoded file with the converted one. */
                      status = NOTOK;
                  } else {
                      /* Replace the decoded file with the converted one. */
-                    if (ct->c_cefile.ce_file) {
-                        if (ct->c_cefile.ce_unlink) {
-                            (void) m_unlink (ct->c_cefile.ce_file);
-                        }
-                        free (ct->c_cefile.ce_file);
-                    }
+                    if (ct->c_cefile.ce_file && ct->c_cefile.ce_unlink)
+                        (void) m_unlink (ct->c_cefile.ce_file);
+
+                    free(ct->c_cefile.ce_file);
                      ct->c_cefile.ce_file = stripped_content_file;
                      ct->c_cefile.ce_unlink = 1;
  
                      ct->c_cefile.ce_file = stripped_content_file;
                      ct->c_cefile.ce_unlink = 1;
  
@@ -2282,25 +2384,26 @@ strip_crs (CT ct, int *message_mods) {
   * of the part C-T-E's.
   */
  static void
   * of the part C-T-E's.
   */
  static void
-update_cte (CT ct) {
+update_cte (CT ct)
+{
      const int least_restrictive_enc = least_restrictive_encoding (ct);
  
      if (least_restrictive_enc != CE_UNKNOWN  &&
          least_restrictive_enc != CE_7BIT) {
          char *cte = concat (" ", ce_str (least_restrictive_enc), "\n", NULL);
          HF hf;
      const int least_restrictive_enc = least_restrictive_encoding (ct);
  
      if (least_restrictive_enc != CE_UNKNOWN  &&
          least_restrictive_enc != CE_7BIT) {
          char *cte = concat (" ", ce_str (least_restrictive_enc), "\n", NULL);
          HF hf;
-        int found_cte = 0;
+        bool found_cte = false;
  
          /* Update/add Content-Transfer-Encoding header field. */
          for (hf = ct->c_first_hf; hf; hf = hf->next) {
              if (! strcasecmp (ENCODING_FIELD, hf->name)) {
  
          /* Update/add Content-Transfer-Encoding header field. */
          for (hf = ct->c_first_hf; hf; hf = hf->next) {
              if (! strcasecmp (ENCODING_FIELD, hf->name)) {
-                found_cte = 1;
+                found_cte = true;
                  free (hf->value);
                  hf->value = cte;
              }
          }
          if (! found_cte) {
                  free (hf->value);
                  hf->value = cte;
              }
          }
          if (! found_cte) {
-            add_header (ct, add (ENCODING_FIELD, NULL), cte);
+            add_header (ct, mh_xstrdup (ENCODING_FIELD), cte);
          }
      }
  }
          }
      }
  }
@@ -2311,7 +2414,8 @@ update_cte (CT ct) {
   * within a message.
   */
  static int
   * within a message.
   */
  static int
-least_restrictive_encoding (CT ct) {
+least_restrictive_encoding (CT ct)
+{
      int encoding = CE_UNKNOWN;
  
      switch (ct->c_type) {
      int encoding = CE_UNKNOWN;
  
      switch (ct->c_type) {
@@ -2359,7 +2463,8 @@ least_restrictive_encoding (CT ct) {
   *   CE_8BIT is less restrictive than CE_7BIT.
   */
  static int
   *   CE_8BIT is less restrictive than CE_7BIT.
   */
  static int
-less_restrictive (int encoding, int second_encoding) {
+less_restrictive (int encoding, int second_encoding)
+{
      switch (second_encoding) {
      case CE_BINARY:
          return encoding != CE_BINARY;
      switch (second_encoding) {
      case CE_BINARY:
          return encoding != CE_BINARY;
@@ -2378,7 +2483,8 @@ less_restrictive (int encoding, int second_encoding) {
   * Convert character set of each part.
   */
  static int
   * Convert character set of each part.
   */
  static int
-convert_charsets (CT ct, char *dest_charset, int *message_mods) {
+convert_charsets (CT ct, char *dest_charset, int *message_mods)
+{
      int status = OK;
  
      switch (ct->c_type) {
      int status = OK;
  
      switch (ct->c_type) {
@@ -2443,7 +2549,8 @@ convert_charsets (CT ct, char *dest_charset, int *message_mods) {
   *    headers, respectively.
   */
  static int
   *    headers, respectively.
   */
  static int
-fix_always (CT ct, int *message_mods) {
+fix_always (CT ct, int *message_mods)
+{
      int status = OK;
  
      switch (ct->c_type) {
      int status = OK;
  
      switch (ct->c_type) {
@@ -2525,22 +2632,20 @@ fix_always (CT ct, int *message_mods) {
   * Factor out common code for loops in fix_filename_encoding().
   */
  static int
   * Factor out common code for loops in fix_filename_encoding().
   */
  static int
-fix_filename_param (char *name, char *value, PM *first_pm, PM *last_pm) {
-    size_t value_len;
-    int fixed = 0;
+fix_filename_param (char *name, char *value, PM *first_pm, PM *last_pm)
+{
+    bool fixed = false;
  
  
-    if (((value_len = strlen (value)) > 0)  &&
-        strncmp (value, "=?", 2) == 0  &&
-        strncmp (&value[value_len - 2], "?=", 2) == 0) {
+    if (has_prefix(value, "=?") && has_suffix(value, "?=")) {
          /* Looks like an RFC 2047 encoded parameter. */
          char decoded[PATH_MAX + 1];
  
          if (decode_rfc2047 (value, decoded, sizeof decoded)) {
              /* Encode using RFC 2231. */
              replace_param (first_pm, last_pm, name, decoded, 0);
          /* Looks like an RFC 2047 encoded parameter. */
          char decoded[PATH_MAX + 1];
  
          if (decode_rfc2047 (value, decoded, sizeof decoded)) {
              /* Encode using RFC 2231. */
              replace_param (first_pm, last_pm, name, decoded, 0);
-            fixed = 1;
+            fixed = true;
          } else {
          } else {
-            advise (NULL, "failed to decode %s parameter %s", name, value);
+            inform("failed to decode %s parameter %s", name, value);
          }
      }
  
          }
      }
  
@@ -2554,7 +2659,8 @@ fix_filename_param (char *name, char *value, PM *first_pm, PM *last_pm) {
   * headers, respectively.
   */
  static int
   * headers, respectively.
   */
  static int
-fix_filename_encoding (CT ct) {
+fix_filename_encoding (CT ct)
+{
      PM pm;
      HF hf;
      int fixed = 0;
      PM pm;
      HF hf;
      int fixed = 0;
@@ -2602,10 +2708,10 @@ fix_filename_encoding (CT ct) {
                  const char *const new_params = concat (params, "\n", NULL);
  
                  replace_substring (&hf->value, semicolon_loc, new_params);
                  const char *const new_params = concat (params, "\n", NULL);
  
                  replace_substring (&hf->value, semicolon_loc, new_params);
-                free ((char *) new_params);
-                free ((char *) params);
+                free((void *)new_params); /* Cast away const.  Sigh. */
+                free((void *)params);
              } else {
              } else {
-                advise (NULL, "did not find semicolon in %s:%s\n",
+                inform("did not find semicolon in %s:%s\n",
                          hf->name, hf->value);
              }
          }
                          hf->name, hf->value);
              }
          }
@@ -2619,16 +2725,17 @@ fix_filename_encoding (CT ct) {
   * Output content in input file to output file.
   */
  static int
   * Output content in input file to output file.
   */
  static int
-write_content (CT ct, const char *input_filename, char *outfile, int modify_inplace,
-               int message_mods) {
+write_content (CT ct, const char *input_filename, char *outfile, FILE *outfp,
+               int modify_inplace, int message_mods)
+{
      int status = OK;
  
      if (modify_inplace) {
          if (message_mods > 0) {
      int status = OK;
  
      if (modify_inplace) {
          if (message_mods > 0) {
-            if ((status = output_message (ct, outfile)) == OK) {
+            if ((status = output_message_fp (ct, outfp, outfile)) == OK) {
                  char *infile = input_filename
                  char *infile = input_filename
-                    ?  add (input_filename, NULL)
-                    :  add (ct->c_file ? ct->c_file : "-", NULL);
+                    ?  mh_xstrdup (input_filename)
+                    :  mh_xstrdup (ct->c_file ? ct->c_file : "-");
  
                  if (remove_file (infile) == OK) {
                      if (rename (outfile, infile)) {
  
                  if (remove_file (infile) == OK) {
                      if (rename (outfile, infile)) {
@@ -2641,7 +2748,7 @@ write_content (CT ct, const char *input_filename, char *outfile, int modify_inpl
                          int i = -1;
  
                          if (old != -1  &&  new != -1) {
                          int i = -1;
  
                          if (old != -1  &&  new != -1) {
-                            char buffer[BUFSIZ];
+                            char buffer[NMH_BUFSIZ];
  
                              while ((i = read (old, buffer, sizeof buffer)) >
                                     0) {
  
                              while ((i = read (old, buffer, sizeof buffer)) >
                                     0) {
@@ -2660,15 +2767,15 @@ write_content (CT ct, const char *input_filename, char *outfile, int modify_inpl
                                 expand filename to absolute path. */
                              int file = ct->c_file  &&  ct->c_file[0] == '/';
  
                                 expand filename to absolute path. */
                              int file = ct->c_file  &&  ct->c_file[0] == '/';
  
-                            admonish (NULL, "unable to rename %s %s to %s",
+                            inform("unable to rename %s %s to %s, continuing...",
                                        file ? "file" : "message", outfile,
                                        infile);
                              status = NOTOK;
                          }
                      }
                  } else {
                                        file ? "file" : "message", outfile,
                                        infile);
                              status = NOTOK;
                          }
                      }
                  } else {
-                    admonish (NULL, "unable to remove input file %s, "
-                              "not modifying it", infile);
+                    inform("unable to remove input file %s, "
+                        "not modifying it, continuing...", infile);
                      (void) m_unlink (outfile);
                      status = NOTOK;
                  }
                      (void) m_unlink (outfile);
                      status = NOTOK;
                  }
@@ -2684,7 +2791,7 @@ write_content (CT ct, const char *input_filename, char *outfile, int modify_inpl
      } else {
          /* Output is going to some file.  Produce it whether or not
             there were modifications. */
      } else {
          /* Output is going to some file.  Produce it whether or not
             there were modifications. */
-        status = output_message (ct, outfile);
+        status = output_message_fp (ct, outfp, outfile);
      }
  
      flush_errors ();
      }
  
      flush_errors ();
@@ -2697,7 +2804,8 @@ write_content (CT ct, const char *input_filename, char *outfile, int modify_inpl
   * function to do it.  It touches the parts the decodetypes identifies.
   */
  static void
   * function to do it.  It touches the parts the decodetypes identifies.
   */
  static void
-set_text_ctparams(CT ct, char *decodetypes, int lf_line_endings) {
+set_text_ctparams(CT ct, char *decodetypes, int lf_line_endings)
+{
      switch (ct->c_type) {
      case CT_MULTIPART: {
          struct multipart *m = (struct multipart *) ct->c_ctparams;
      switch (ct->c_type) {
      case CT_MULTIPART: {
          struct multipart *m = (struct multipart *) ct->c_ctparams;
@@ -2733,7 +2841,8 @@ set_text_ctparams(CT ct, char *decodetypes, int lf_line_endings) {
   * use the standard MH backup file.
   */
  static int
   * use the standard MH backup file.
   */
  static int
-remove_file (const char *file) {
+remove_file (const char *file)
+{
      if (rmmproc) {
          char *rmm_command = concat (rmmproc, " ", file, NULL);
          int status = system (rmm_command);
      if (rmmproc) {
          char *rmm_command = concat (rmmproc, " ", file, NULL);
          int status = system (rmm_command);
@@ -2752,14 +2861,15 @@ remove_file (const char *file) {
   * Output formatted message to user.
   */
  static void
   * Output formatted message to user.
   */
  static void
-report (char *what, char *partno, char *filename, char *message, ...) {
+report (char *what, char *partno, char *filename, char *message, ...)
+{
      va_list args;
      char *fmt;
  
      if (verbosw) {
          va_start (args, message);
          fmt = concat (filename, partno ? " part " : ", ",
      va_list args;
      char *fmt;
  
      if (verbosw) {
          va_start (args, message);
          fmt = concat (filename, partno ? " part " : ", ",
-                      partno ? partno : "", partno ? ", " : "", message, NULL);
+                      FENDNULL(partno), partno ? ", " : "", message, NULL);
  
          advertise (what, NULL, fmt, args);
  
  
          advertise (what, NULL, fmt, args);