lock_file.c: close(2) file descriptor on failure, avoiding leak.

[nmh] / uip / mhlsbr.c

diff --git a/uip/mhlsbr.c b/uip/mhlsbr.c
index 9964fa05280f4637e0fd13898f78ccca9120aca3..df0e24bf101ebf63a44cd49767acebf3a2e55135 100644 (file)
--- a/uip/mhlsbr.c
+++ b/uip/mhlsbr.c
@@ -1,6 +1,4 @@
-
-/*
- * mhlsbr.c -- main routines for nmh message lister
+/* mhlsbr.c -- main routines for nmh message lister

  *
  * This code is Copyright (c) 2002, by the authors of nmh.  See the
  * COPYRIGHT file in the root directory of the nmh distribution for
  *
  * This code is Copyright (c) 2002, by the authors of nmh.  See the
  * COPYRIGHT file in the root directory of the nmh distribution for


@@ -13,11 +11,10 @@
 #include <h/fmt_scan.h>
 #include <h/tws.h>
 #include <h/utils.h>
 #include <h/fmt_scan.h>
 #include <h/tws.h>
 #include <h/utils.h>

+#include "sbr/m_popen.h"

 #include <setjmp.h>
 #include <setjmp.h>

-#include <signal.h>
-#include <errno.h>
-#include <sys/wait.h>

 #include <sys/types.h>
 #include <sys/types.h>

+#include "sbr/terminal.h"

 
 /*
  * MAJOR BUG:
 
 /*
  * MAJOR BUG:


@@ -25,7 +22,7 @@
  * set, then addresses get split wrong (not at the spaces between commas).
  * To fix this correctly, putstr() should know about "atomic" strings that
  * must NOT be broken across lines.  That's too difficult for right now
  * set, then addresses get split wrong (not at the spaces between commas).
  * To fix this correctly, putstr() should know about "atomic" strings that
  * must NOT be broken across lines.  That's too difficult for right now

- * (it turns out that there are a number of degernate cases), so in
+ * (it turns out that there are a number of degenerate cases), so in

  * oneline(), instead of
  *
  *       (*onelp == '\n' && !onelp[1])
  * oneline(), instead of
  *
  *       (*onelp == '\n' && !onelp[1])


@@ -44,55 +41,38 @@
 
 #define        QUOTE   '\\'
 
 
 #define        QUOTE   '\\'
 

-static struct swit mhlswitches[] = {
-#define        BELLSW         0
-    { "bell", 0 },
-#define        NBELLSW        1
-    { "nobell", 0 },
-#define        CLRSW          2
-    { "clear", 0 },
-#define        NCLRSW         3
-    { "noclear", 0 },
-#define        FOLDSW         4
-    { "folder +folder", 0 },
-#define        FORMSW         5
-    { "form formfile", 0 },
-#define        PROGSW         6
-    { "moreproc program", 0 },
-#define        NPROGSW        7
-    { "nomoreproc", 0 },
-#define        LENSW          8
-    { "length lines", 0 },
-#define        WIDTHSW        9
-    { "width columns", 0 },
-#define        SLEEPSW       10
-    { "sleep seconds",  0 },
-#define        BITSTUFFSW    11
-    { "dashstuffing", -12 },   /* interface from forw */
-#define        NBITSTUFFSW   12
-    { "nodashstuffing", -14 }, /* interface from forw */
-#define VERSIONSW     13
-    { "version", 0 },
-#define        HELPSW        14
-    { "help", 0 },
-#define        FORW1SW       15
-    { "forward", -7 },         /* interface from forw */
-#define        FORW2SW       16
-    { "forwall", -7 },         /* interface from forw */
-#define        DGSTSW        17
-    { "digest list", -6 },
-#define VOLUMSW       18
-    { "volume number", -6 },
-#define ISSUESW       19
-    { "issue number", -5 },
-#define NBODYSW       20
-    { "nobody", -6 },
-#define FMTPROCSW     21
-    { "fmtproc program", 0 },
-#define NFMTPROCSW    22
-    { "nofmtproc", 0 },
-    { NULL, 0 }
-};
+#define MHL_SWITCHES \
+    X("bell", 0, BELLSW) \
+    X("nobell", 0, NBELLSW) \
+    X("clear", 0, CLRSW) \
+    X("noclear", 0, NCLRSW) \
+    X("folder +folder", 0, FOLDSW) \
+    X("form formfile", 0, FORMSW) \
+    X("moreproc program", 0, PROGSW) \
+    X("nomoreproc", 0, NPROGSW) \
+    X("length lines", 0, LENSW) \
+    X("width columns", 0, WIDTHSW) \
+    X("sleep seconds", 0, SLEEPSW) \
+    X("dashstuffing", -12, BITSTUFFSW)    /* interface from forw */ \
+    X("nodashstuffing", -14, NBITSTUFFSW) /* interface from forw */ \
+    X("version", 0, VERSIONSW) \
+    X("help", 0, HELPSW) \
+    X("forward", -7, FORW1SW)             /* interface from forw */ \
+    X("forwall", -7, FORW2SW)             /* interface from forw */ \
+    X("digest list", -6, DGSTSW) \
+    X("volume number", -6, VOLUMSW) \
+    X("issue number", -5, ISSUESW) \
+    X("nobody", -6, NBODYSW) \
+    X("fmtproc program", 0, FMTPROCSW) \
+    X("nofmtproc", 0, NFMTPROCSW) \
+
+#define X(sw, minchars, id) id,
+DEFINE_SWITCH_ENUM(MHL);
+#undef X
+
+#define X(sw, minchars, id) { sw, minchars, id },
+DEFINE_SWITCH_ARRAY(MHL, mhlswitches);
+#undef X

 
 #define NOCOMPONENT 0x000001   /* don't show component name         */
 #define UPPERCASE   0x000002   /* display in all upper case         */
 
 #define NOCOMPONENT 0x000001   /* don't show component name         */
 #define UPPERCASE   0x000002   /* display in all upper case         */


@@ -108,15 +88,19 @@ static struct swit mhlswitches[] = {
 #define        DATEFMT     0x000800    /* contains dates                    */
 #define        FORMAT      0x001000    /* parse address/date/RFC-2047 field */
 #define        INIT        0x002000    /* initialize component              */
 #define        DATEFMT     0x000800    /* contains dates                    */
 #define        FORMAT      0x001000    /* parse address/date/RFC-2047 field */
 #define        INIT        0x002000    /* initialize component              */

+#define RTRIM       0x004000   /* trim trailing whitespace          */

 #define        SPLIT       0x010000    /* split headers (don't concatenate) */
 #define        NONEWLINE   0x020000    /* don't write trailing newline      */
 #define NOWRAP      0x040000   /* Don't wrap lines ever             */
 #define FMTFILTER   0x080000   /* Filter through format filter      */
 #define        SPLIT       0x010000    /* split headers (don't concatenate) */
 #define        NONEWLINE   0x020000    /* don't write trailing newline      */
 #define NOWRAP      0x040000   /* Don't wrap lines ever             */
 #define FMTFILTER   0x080000   /* Filter through format filter      */

-#define        LBITS   "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT\021SPLIT\022NONEWLINE\023NOWRAP\024FMTFILTER"
+#define INVISIBLE   0x100000   /* count byte in display columns?    */
+#define FORCE7BIT   0x200000   /* don't display 8-bit bytes         */
+#define        LBITS   "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT\017RTRIM\021SPLIT\022NONEWLINE\023NOWRAP\024FMTFILTER\025INVISIBLE\026FORCE7BIT"

 #define        GFLAGS  (NOCOMPONENT | UPPERCASE | CENTER | LEFTADJUST | COMPRESS | SPLIT | NOWRAP)
 
 /*
 #define        GFLAGS  (NOCOMPONENT | UPPERCASE | CENTER | LEFTADJUST | COMPRESS | SPLIT | NOWRAP)
 
 /*

- * A list of format arguments
+ * A format string to be used as a command-line argument to the body
+ * format filter.

  */
 
 struct arglist {
  */
 
 struct arglist {


@@ -125,21 +109,61 @@ struct arglist {
     struct arglist *a_next;
 };
 
     struct arglist *a_next;
 };
 

+/*
+ * Linked list of command line arguments for the body format filter.  This
+ * USED to be in "struct mcomp", but the format API got cleaned up and even
+ * though it reduced the code we had to do, it make things more complicated
+ * for us.  Specifically:
+ *
+ * - The interface to the hash table has been cleaned up, which means the
+ *   rooting around in the hash table is no longer necessary (yay!).  But
+ *   this ALSO means that we have to make sure that we call our format
+ *   compilation routines before we process the message, because the
+ *   components need to be visible in the hash table so we can save them for
+ *   later.  So we moved them out of "mcomp" and now compile them right before
+ *   header processing starts.
+ * - We also use format strings to handle other components in the mhl
+ *   configuration (using "formatfield" and "decode"), but here life
+ *   gets complicated: they aren't dealt with in the normal way.  Instead
+ *   of referring to a component like {from}, each component is processed
+ *   using the special {text} component.  But these format strings need to be
+ *   compiled BEFORE we compile the format arguments; in the previous
+ *   implementation they were compiled and scanned as the headers were
+ *   read, and that would reset the hash table that we need to populate
+ *   the components used by the body format filter.  So we are compiling
+ *   the formatfield component strings ahead of time and then scanning them
+ *   later.
+ *
+ * Okay, fine ... this was broken before.  But you know what?  Fixing this
+ * the right way will make things easier down the road.
+ *
+ * One side-effect to this change: format strings are now compiled only once
+ * for components specified with "formatfield", but they are compiled for
+ * every message for format arguments.
+ */
+
+static struct arglist *arglist_head;
+static struct arglist *arglist_tail;
+static int filter_nargs = 0;
+
+/*
+ * Flags/options for each component
+ */
+

 struct mcomp {
     char *c_name;              /* component name          */
     char *c_text;              /* component text          */
     char *c_ovtxt;             /* text overflow indicator */
     char *c_nfs;               /* iff FORMAT              */
     struct format *c_fmt;      /*   ..                    */
 struct mcomp {
     char *c_name;              /* component name          */
     char *c_text;              /* component text          */
     char *c_ovtxt;             /* text overflow indicator */
     char *c_nfs;               /* iff FORMAT              */
     struct format *c_fmt;      /*   ..                    */

+    struct comp *c_c_text;     /* Ref to {text} in FORMAT */
+    struct comp *c_c_error;    /* Ref to {error}          */

     int c_offset;              /* left margin indentation */
     int c_ovoff;               /* overflow indentation    */
     int c_width;               /* width of field          */
     int c_cwidth;              /* width of component      */
     int c_length;              /* length in lines         */
     int c_offset;              /* left margin indentation */
     int c_ovoff;               /* overflow indentation    */
     int c_width;               /* width of field          */
     int c_cwidth;              /* width of component      */
     int c_length;              /* length in lines         */

-    long c_flags;
-    struct arglist *c_f_args;  /* Argument list for filter*/
-    struct arglist *c_f_tail;  /* Pointer to tail of list */
-    int c_nargs;               /* Number of arguments     */
+    unsigned long c_flags;

     struct mcomp *c_next;
 };
 
     struct mcomp *c_next;
 };
 


@@ -149,18 +173,16 @@ static struct mcomp *fmthd = NULL;
 static struct mcomp *fmttl = NULL;
 
 static struct mcomp global = {
 static struct mcomp *fmttl = NULL;
 
 static struct mcomp global = {

-    NULL, NULL, NULL, NULL, NULL, 0, -1, 80, -1, 40, BELL, NULL, NULL, 0,
-    NULL
+    NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, -1, 80, -1, 40, BELL, NULL

 };
 
 static struct mcomp holder = {
 };
 
 static struct mcomp holder = {

-    NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, NULL, NULL, 0,
-    NULL
+    NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, NULL

 };
 
 struct pair {
     char *p_name;
 };
 
 struct pair {
     char *p_name;

-    long p_flags;
+    unsigned long p_flags;

 };
 
 static struct pair pairs[] = {
 };
 
 static struct pair pairs[] = {


@@ -183,8 +205,8 @@ static struct pair pairs[] = {
 
 struct triple {
     char *t_name;
 
 struct triple {
     char *t_name;

-    long t_on;
-    long t_off;
+    unsigned long t_on;
+    unsigned long t_off;

 };
 
 static struct triple triples[] = {
 };
 
 static struct triple triples[] = {


@@ -202,6 +224,8 @@ static struct triple triples[] = {
     { "nocompress",    0,           COMPRESS },
     { "split",         SPLIT,       0 },
     { "nosplit",       0,           SPLIT },
     { "nocompress",    0,           COMPRESS },
     { "split",         SPLIT,       0 },
     { "nosplit",       0,           SPLIT },

+    { "rtrim",         RTRIM,       0 },
+    { "nortrim",       0,           RTRIM },

     { "addrfield",     ADDRFMT,     DATEFMT },
     { "bell",          BELL,        0 },
     { "nobell",        0,           BELL },
     { "addrfield",     ADDRFMT,     DATEFMT },
     { "bell",          BELL,        0 },
     { "nobell",        0,           BELL },


@@ -266,7 +290,7 @@ static unsigned int wid;
 
 static char *ovtxt;
 
 
 static char *ovtxt;
 

-static unsigned char *onelp;
+static char *onelp;

 
 static char *parptr;
 
 
 static char *parptr;
 


@@ -280,16 +304,7 @@ static char delim3[] =             /* from forw.c */
     "\n----------------------------------------------------------------------\n\n";
 static char delim4[] = "\n------------------------------\n\n";
 
     "\n----------------------------------------------------------------------\n\n";
 static char delim4[] = "\n------------------------------\n\n";
 

-static FILE *(*mhl_action) () = (FILE *(*) ()) 0;
-
-static struct comp *mhlcomp[128];
-
-/*
- * Redefine a couple of functions.
- * These are undefined later in the code.
- */
-#define        adios mhladios
-#define        done  mhldone
+static FILE *(*mhl_action)(char *);

 
 /*
  * prototypes
 
 /*
  * prototypes


@@ -301,27 +316,24 @@ static int ptos (char *, char **);
 static char *parse (void);
 static void process (char *, char *, int, int);
 static void mhlfile (FILE *, char *, int, int);
 static char *parse (void);
 static void process (char *, char *, int, int);
 static void mhlfile (FILE *, char *, int, int);

-static int mcomp_flags (char *);
-static char *mcomp_add (long, char *, char *);
+static int mcomp_flags (char *) PURE;
+static char *mcomp_add (unsigned long, char *, char *);

 static void mcomp_format (struct mcomp *, struct mcomp *);
 static struct mcomp *add_queue (struct mcomp **, struct mcomp **, char *, char *, int);
 static void free_queue (struct mcomp **, struct mcomp **);
 static void putcomp (struct mcomp *, struct mcomp *, int);
 static void mcomp_format (struct mcomp *, struct mcomp *);
 static struct mcomp *add_queue (struct mcomp **, struct mcomp **, char *, char *, int);
 static void free_queue (struct mcomp **, struct mcomp **);
 static void putcomp (struct mcomp *, struct mcomp *, int);

-static char *oneline (char *, long);
-static void putstr (char *, long);
-static void putch (char, long);
+static char *oneline (char *, unsigned long);
+static void putstr (char *, unsigned long);
+static void putch (char, unsigned long);

 static void intrser (int);
 static void pipeser (int);
 static void quitser (int);
 static void intrser (int);
 static void pipeser (int);
 static void quitser (int);

-static void mhladios (char *, char *, ...);
-static void mhldone (int);
-static void m_popen (char *);
-static void filterbody (struct mcomp *, char *, int, int, FILE *);
-static int compileargs (struct mcomp *, char *);
-static int checkcomp (char *, char *);
-static void addcomp (int, char *, char *);
-static void freecomps (void);
-static void freecomptext (void);
+static void mhladios (char *, char *, ...) CHECK_PRINTF(2, 3) NORETURN;
+static void mhldone (int) NORETURN;
+static void filterbody (struct mcomp *, char *, int, int,
+                        m_getfld_state_t);
+static void compile_formatfield(struct mcomp *);
+static void compile_filterargs (void);

 
 
 int
 
 
 int


@@ -334,11 +346,9 @@ mhl (int argc, char **argv)
     char buf[BUFSIZ], *files[MAXARGS];
     char **argp, **arguments;
 
     char buf[BUFSIZ], *files[MAXARGS];
     char **argp, **arguments;
 

+    /* Need this if called from main() of show(1). */

     invo_name = r1bindex (argv[0], '/');
 
     invo_name = r1bindex (argv[0], '/');
 

-    /* read user profile/context */
-    context_read();
-

     arguments = getarguments (invo_name, argc, argv, 1);
     argp = arguments;
 
     arguments = getarguments (invo_name, argc, argv, 1);
     argp = arguments;
 


@@ -350,17 +360,17 @@ mhl (int argc, char **argv)
            switch (smatch (++cp, mhlswitches)) {
                case AMBIGSW: 
                    ambigsw (cp, mhlswitches);
            switch (smatch (++cp, mhlswitches)) {
                case AMBIGSW: 
                    ambigsw (cp, mhlswitches);

-                   done (1);
+                   mhldone (1);

                case UNKWNSW: 
                case UNKWNSW: 

-                   adios (NULL, "-%s unknown\n", cp);
+                   mhladios (NULL, "-%s unknown\n", cp);

 
                case HELPSW: 
                    snprintf (buf, sizeof(buf), "%s [switches] [files ...]", invo_name);
                    print_help (buf, mhlswitches, 1);
 
                case HELPSW: 
                    snprintf (buf, sizeof(buf), "%s [switches] [files ...]", invo_name);
                    print_help (buf, mhlswitches, 1);

-                   done (0);
+                   mhldone (0);

                case VERSIONSW:
                    print_version(invo_name);
                case VERSIONSW:
                    print_version(invo_name);

-                   done (0);
+                   mhldone (0);

 
                case BELLSW: 
                    bellflg = 1;
 
                case BELLSW: 
                    bellflg = 1;


@@ -378,22 +388,22 @@ mhl (int argc, char **argv)
 
                case FOLDSW: 
                    if (!(folder = *argp++) || *folder == '-')
 
                case FOLDSW: 
                    if (!(folder = *argp++) || *folder == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    continue;
                case FORMSW: 
                    if (!(form = *argp++) || *form == '-')
                    continue;
                case FORMSW: 
                    if (!(form = *argp++) || *form == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    continue;
 
                case SLEEPSW:
                    if (!(cp = *argp++) || *cp == '-')
                    continue;
 
                case SLEEPSW:
                    if (!(cp = *argp++) || *cp == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
-                   sleepsw = atoi (cp);/* ZERO ok! */
+                       mhladios (NULL, "missing argument to %s", argp[-2]);
+                    sleepsw = atoi (cp);/* ZERO ok! */

                    continue;
 
                case PROGSW:
                    if (!(moreproc = *argp++) || *moreproc == '-')
                    continue;
 
                case PROGSW:
                    if (!(moreproc = *argp++) || *moreproc == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    continue;
                case NPROGSW:
                    nomore++;
                    continue;
                case NPROGSW:
                    nomore++;


@@ -401,7 +411,7 @@ mhl (int argc, char **argv)
 
                case FMTPROCSW:
                    if (!(formatproc = *argp++) || *formatproc == '-')
 
                case FMTPROCSW:
                    if (!(formatproc = *argp++) || *formatproc == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    continue;
                case NFMTPROCSW:
                    formatproc = NULL;
                    continue;
                case NFMTPROCSW:
                    formatproc = NULL;


@@ -409,46 +419,47 @@ mhl (int argc, char **argv)
 
                case LENSW: 
                    if (!(cp = *argp++) || *cp == '-')
 
                case LENSW: 
                    if (!(cp = *argp++) || *cp == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    if ((length = atoi (cp)) < 1)
                    if ((length = atoi (cp)) < 1)

-                       adios (NULL, "bad argument %s %s", argp[-2], cp);
+                       mhladios (NULL, "bad argument %s %s", argp[-2], cp);

                    continue;
                case WIDTHSW: 
                    if (!(cp = *argp++) || *cp == '-')
                    continue;
                case WIDTHSW: 
                    if (!(cp = *argp++) || *cp == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    if ((width = atoi (cp)) < 1)
                    if ((width = atoi (cp)) < 1)

-                       adios (NULL, "bad argument %s %s", argp[-2], cp);
+                       mhladios (NULL, "bad argument %s %s", argp[-2], cp);

                    continue;
 
                case DGSTSW: 
                    if (!(digest = *argp++) || *digest == '-')
                    continue;
 
                case DGSTSW: 
                    if (!(digest = *argp++) || *digest == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    continue;
                case ISSUESW:
                    if (!(cp = *argp++) || *cp == '-')
                    continue;
                case ISSUESW:
                    if (!(cp = *argp++) || *cp == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    if ((issue = atoi (cp)) < 1)
                    if ((issue = atoi (cp)) < 1)

-                       adios (NULL, "bad argument %s %s", argp[-2], cp);
+                       mhladios (NULL, "bad argument %s %s", argp[-2], cp);

                    continue;
                case VOLUMSW:
                    if (!(cp = *argp++) || *cp == '-')
                    continue;
                case VOLUMSW:
                    if (!(cp = *argp++) || *cp == '-')

-                       adios (NULL, "missing argument to %s", argp[-2]);
+                       mhladios (NULL, "missing argument to %s", argp[-2]);

                    if ((volume = atoi (cp)) < 1)
                    if ((volume = atoi (cp)) < 1)

-                       adios (NULL, "bad argument %s %s", argp[-2], cp);
+                       mhladios (NULL, "bad argument %s %s", argp[-2], cp);

                    continue;
 
                case FORW2SW: 
                    continue;
 
                case FORW2SW: 

-                   forwall++;  /* fall */
+                   forwall++;
+                   /* FALLTHRU */

                case FORW1SW: 
                    forwflg++;
                    clearflg = -1;/* XXX */
                    continue;
 
                case BITSTUFFSW: 
                case FORW1SW: 
                    forwflg++;
                    clearflg = -1;/* XXX */
                    continue;
 
                case BITSTUFFSW: 

-                   dashstuff = 1;      /* trinary logic */
+                   dashstuff = 1;      /* ternary logic */

                    continue;
                case NBITSTUFFSW: 
                    continue;
                case NBITSTUFFSW: 

-                   dashstuff = -1;     /* trinary logic */
+                   dashstuff = -1;     /* ternary logic */

                    continue;
 
                case NBODYSW: 
                    continue;
 
                case NBODYSW: 


@@ -463,13 +474,13 @@ mhl (int argc, char **argv)
        folder = getenv ("mhfolder");
 
     if (isatty (fileno (stdout))) {
        folder = getenv ("mhfolder");
 
     if (isatty (fileno (stdout))) {

-       if (!nomore && !sc_hardcopy() && moreproc && *moreproc != '\0') {
+       if (!nomore && moreproc && *moreproc != '\0') {

            if (mhl_action) {
                SIGNAL (SIGINT, SIG_IGN);
                SIGNAL2 (SIGQUIT, quitser);
            }
            SIGNAL2 (SIGPIPE, pipeser);
            if (mhl_action) {
                SIGNAL (SIGINT, SIG_IGN);
                SIGNAL2 (SIGQUIT, quitser);
            }
            SIGNAL2 (SIGPIPE, pipeser);

-           m_popen (moreproc);
+           m_popen (moreproc, mhl_action != NULL);

            ontty = PITTY;
        } else {
            SIGNAL (SIGINT, SIG_IGN);
            ontty = PITTY;
        } else {
            SIGNAL (SIGINT, SIG_IGN);


@@ -480,9 +491,6 @@ mhl (int argc, char **argv)
        ontty = NOTTY;
     }
 
        ontty = NOTTY;
     }
 

-    for (i = 0; i < sizeof(mhlcomp)/sizeof(mhlcomp[0]); i++)
-       mhlcomp[i] = NULL;
-

     mhl_format (form ? form : mhlformat, length, width);
 
     if (vecp == 0) {
     mhl_format (form ? form : mhlformat, length, width);
 
     if (vecp == 0) {


@@ -492,11 +500,9 @@ mhl (int argc, char **argv)
            process (folder, files[i], i + 1, vecp);
     }
 
            process (folder, files[i], i + 1, vecp);
     }
 

-    freecomps();
-

     if (forwall) {
        if (digest) {
     if (forwall) {
        if (digest) {

-           printf ("%s", delim4);
+           fputs(delim4, stdout);

            if (volume == 0) {
                snprintf (buf, sizeof(buf), "End of %s Digest\n", digest);
            } else {
            if (volume == 0) {
                snprintf (buf, sizeof(buf), "End of %s Digest\n", digest);
            } else {


@@ -508,20 +514,20 @@ mhl (int argc, char **argv)
                *cp++ = '*';
            *cp++ = '\n';
            *cp = 0;
                *cp++ = '*';
            *cp++ = '\n';
            *cp = 0;

-           printf ("%s", buf);
+           fputs(buf, stdout);

        }
        else
            printf ("\n------- End of Forwarded Message%s\n",
        }
        else
            printf ("\n------- End of Forwarded Message%s\n",

-                   vecp > 1 ? "s" : "");
+                   PLURALS(vecp));

     }
 
     fflush(stdout);
     if(ferror(stdout)){
     }
 
     fflush(stdout);
     if(ferror(stdout)){

-           adios("output", "error writing");
+           mhladios("output", "error writing");

     }
     
     if (clearflg > 0 && ontty == NOTTY)
     }
     
     if (clearflg > 0 && ontty == NOTTY)

-       clear_screen ();
+       nmh_clear_screen ();

 
     if (ontty == PITTY)
        m_pclose ();
 
     if (ontty == PITTY)
        m_pclose ();


@@ -534,8 +540,8 @@ static void
 mhl_format (char *file, int length, int width)
 {
     int i;
 mhl_format (char *file, int length, int width)
 {
     int i;

-    char *bp, *cp, **ip;
-    char *ap, buffer[BUFSIZ], name[NAMESZ];
+    char *bp, **ip;
+    char *ap, name[NAMESZ];

     struct mcomp *c1;
     struct stat st;
     FILE *fp;
     struct mcomp *c1;
     struct stat st;
     FILE *fp;


@@ -549,12 +555,11 @@ mhl_format (char *file, int length, int width)
                && dev == st.st_dev
                && ino == st.st_ino)
            goto out;
                && dev == st.st_dev
                && ino == st.st_ino)
            goto out;

-       else
-           free_queue (&fmthd, &fmttl);
+        free_queue (&fmthd, &fmttl);

     }
 
     if ((fp = fopen (etcpath (file), "r")) == NULL)
     }
 
     if ((fp = fopen (etcpath (file), "r")) == NULL)

-       adios (file, "unable to open format file");
+       mhladios (file, "unable to open format file");

 
     if (fstat (fileno (fp), &st) != NOTOK) {
        mtime = st.st_mtime;
 
     if (fstat (fileno (fp), &st) != NOTOK) {
        mtime = st.st_mtime;


@@ -573,17 +578,17 @@ mhl_format (char *file, int length, int width)
        global.c_length = i - 1;
     global.c_flags = BELL;             /* BELL is default */
     *(ip = ignores) = NULL;
        global.c_length = i - 1;
     global.c_flags = BELL;             /* BELL is default */
     *(ip = ignores) = NULL;

+    filter_nargs = 0;

 
     while (vfgets (fp, &ap) == OK) {
        bp = ap;
        if (*bp == ';')
            continue;
 
 
     while (vfgets (fp, &ap) == OK) {
        bp = ap;
        if (*bp == ';')
            continue;
 

-       if ((cp = strchr(bp, '\n')))
-           *cp = 0;
+        trim_suffix_c(bp, '\n');

 
        if (*bp == ':') {
 
        if (*bp == ':') {

-           c1 = add_queue (&fmthd, &fmttl, NULL, bp + 1, CLEARTEXT);
+           (void) add_queue (&fmthd, &fmttl, NULL, bp + 1, CLEARTEXT);

            continue;
        }
 
            continue;
        }
 


@@ -597,12 +602,12 @@ mhl_format (char *file, int length, int width)
                 * Split this list of fields to ignore, and copy
                 * it to the end of the current "ignores" list.
                 */
                 * Split this list of fields to ignore, and copy
                 * it to the end of the current "ignores" list.
                 */

-               if (!mh_strcasecmp (name, "ignores")) {
+               if (!strcasecmp (name, "ignores")) {

                    char **tmparray, **p;
                    int n = 0;
 
                    /* split the fields */
                    char **tmparray, **p;
                    int n = 0;
 
                    /* split the fields */

-                   tmparray = brkstring (getcpy (++parptr), ",", NULL);
+                   tmparray = brkstring (mh_xstrdup(++parptr), ",", NULL);

 
                    /* count number of fields split */
                    p = tmparray;
 
                    /* count number of fields split */
                    p = tmparray;


@@ -617,7 +622,7 @@ mhl_format (char *file, int length, int width)
                parptr = bp;
                while (*parptr) {
                    if (evalvar (&global))
                parptr = bp;
                while (*parptr) {
                    if (evalvar (&global))

-                       adios (NULL, "format file syntax error: %s", bp);
+                       mhladios (NULL, "format file syntax error: %s", bp);

                    if (*parptr)
                        parptr++;
                }
                    if (*parptr)
                        parptr++;
                }


@@ -628,34 +633,37 @@ mhl_format (char *file, int length, int width)
                while (*parptr == ':' || *parptr == ',') {
                    parptr++;
                    if (evalvar (c1))
                while (*parptr == ':' || *parptr == ',') {
                    parptr++;
                    if (evalvar (c1))

-                       adios (NULL, "format file syntax error: %s", bp);
+                       mhladios (NULL, "format file syntax error: %s", bp);

                }
                if (!c1->c_nfs && global.c_nfs) {
                    if (c1->c_flags & DATEFMT) {
                }
                if (!c1->c_nfs && global.c_nfs) {
                    if (c1->c_flags & DATEFMT) {

-                       if (global.c_flags & DATEFMT)
-                           c1->c_nfs = getcpy (global.c_nfs);
-                   }
-                   else
-                       if (c1->c_flags & ADDRFMT) {
-                           if (global.c_flags & ADDRFMT)
-                               c1->c_nfs = getcpy (global.c_nfs);
+                       if (global.c_flags & DATEFMT) {
+                           c1->c_nfs = mh_xstrdup(global.c_nfs);
+                           compile_formatfield(c1);

                        }
                        }

+                   } else if (c1->c_flags & ADDRFMT) {
+                        if (global.c_flags & ADDRFMT) {
+                            c1->c_nfs = mh_xstrdup(global.c_nfs);
+                            compile_formatfield(c1);
+                        }
+                    }

                }
                continue;
 
            default: 
                }
                continue;
 
            default: 

-               adios (NULL, "format file syntax error: %s", bp);
+               mhladios (NULL, "format file syntax error: %s", bp);

        }
     }
     fclose (fp);
 
     if (mhldebug) {
        for (c1 = fmthd; c1; c1 = c1->c_next) {
        }
     }
     fclose (fp);
 
     if (mhldebug) {
        for (c1 = fmthd; c1; c1 = c1->c_next) {

+           char buffer[BUFSIZ];
+

            fprintf (stderr, "c1: name=\"%s\" text=\"%s\" ovtxt=\"%s\"\n",
                    c1->c_name, c1->c_text, c1->c_ovtxt);
            fprintf (stderr, "c1: name=\"%s\" text=\"%s\" ovtxt=\"%s\"\n",
                    c1->c_name, c1->c_text, c1->c_ovtxt);

-           fprintf (stderr, "\tnfs=0x%x fmt=0x%x\n",
-                    (unsigned int)(unsigned long) c1->c_nfs,
-                    (unsigned int)(unsigned long) c1->c_fmt);
+           fprintf(stderr, "\tnfs=%p fmt=%p\n",
+                (void *)c1->c_nfs, (void *)c1->c_fmt);

            fprintf (stderr, "\toffset=%d ovoff=%d width=%d cwidth=%d length=%d\n",
                    c1->c_offset, c1->c_ovoff, c1->c_width,
                    c1->c_cwidth, c1->c_length);
            fprintf (stderr, "\toffset=%d ovoff=%d width=%d cwidth=%d length=%d\n",
                    c1->c_offset, c1->c_ovoff, c1->c_width,
                    c1->c_cwidth, c1->c_length);


@@ -702,69 +710,79 @@ evalvar (struct mcomp *c1)
        return 0;
     strncpy (name, parse(), sizeof(name));
 
        return 0;
     strncpy (name, parse(), sizeof(name));
 

-    if (!mh_strcasecmp (name, "component")) {
+    if (!strcasecmp (name, "component")) {

        if (ptos (name, &c1->c_text))
            return 1;
        c1->c_flags &= ~NOCOMPONENT;
        return 0;
     }
 
        if (ptos (name, &c1->c_text))
            return 1;
        c1->c_flags &= ~NOCOMPONENT;
        return 0;
     }
 

-    if (!mh_strcasecmp (name, "overflowtext"))
+    if (!strcasecmp (name, "overflowtext"))

        return ptos (name, &c1->c_ovtxt);
 
        return ptos (name, &c1->c_ovtxt);
 

-    if (!mh_strcasecmp (name, "formatfield")) {
-       char *nfs;
-
+    if (!strcasecmp (name, "formatfield")) {

        if (ptos (name, &cp))
            return 1;
        if (ptos (name, &cp))
            return 1;

-       nfs = new_fs (NULL, NULL, cp);
-       c1->c_nfs = getcpy (nfs);
+       c1->c_nfs = getcpy (new_fs (NULL, NULL, cp));
+       compile_formatfield(c1);

        c1->c_flags |= FORMAT;
        return 0;
     }
 
        c1->c_flags |= FORMAT;
        return 0;
     }
 

-    if (!mh_strcasecmp (name, "decode")) {
-       char *nfs;
-
-       nfs = new_fs (NULL, NULL, "%(decode{text})");
-       c1->c_nfs = getcpy (nfs);
+    if (!strcasecmp (name, "decode")) {
+       c1->c_nfs = getcpy (new_fs (NULL, NULL, "%(decode{text})"));
+       compile_formatfield(c1);

        c1->c_flags |= FORMAT;
        return 0;
     }
 
        c1->c_flags |= FORMAT;
        return 0;
     }
 

-    if (!mh_strcasecmp (name, "offset"))
+    if (!strcasecmp (name, "offset"))

        return ptoi (name, &c1->c_offset);
        return ptoi (name, &c1->c_offset);

-    if (!mh_strcasecmp (name, "overflowoffset"))
+    if (!strcasecmp (name, "overflowoffset"))

        return ptoi (name, &c1->c_ovoff);
        return ptoi (name, &c1->c_ovoff);

-    if (!mh_strcasecmp (name, "width"))
+    if (!strcasecmp (name, "width"))

        return ptoi (name, &c1->c_width);
        return ptoi (name, &c1->c_width);

-    if (!mh_strcasecmp (name, "compwidth"))
+    if (!strcasecmp (name, "compwidth"))

        return ptoi (name, &c1->c_cwidth);
        return ptoi (name, &c1->c_cwidth);

-    if (!mh_strcasecmp (name, "length"))
+    if (!strcasecmp (name, "length"))

        return ptoi (name, &c1->c_length);
        return ptoi (name, &c1->c_length);

-    if (!mh_strcasecmp (name, "nodashstuffing"))
+    if (!strcasecmp (name, "nodashstuffing"))

        return (dashstuff = -1);
 
     for (ap = triples; ap->t_name; ap++)
        return (dashstuff = -1);
 
     for (ap = triples; ap->t_name; ap++)

-       if (!mh_strcasecmp (ap->t_name, name)) {
+       if (!strcasecmp (ap->t_name, name)) {

            c1->c_flags |= ap->t_on;
            c1->c_flags &= ~ap->t_off;
            return 0;
        }
 
            c1->c_flags |= ap->t_on;
            c1->c_flags &= ~ap->t_off;
            return 0;
        }
 

-   if (!mh_strcasecmp (name, "formatarg")) {
-       char *nfs;
-       int rc;
+   if (!strcasecmp (name, "formatarg")) {
+       struct arglist *args;

 
        if (ptos (name, &cp))
            return 1;
 
        if (ptos (name, &cp))
            return 1;

-       nfs = new_fs (NULL, NULL, cp);

 
 

-       rc = compileargs(c1, nfs);
+       if (! c1->c_name  ||  strcasecmp (c1->c_name, "body")) {
+           inform("format filters are currently only supported on "
+                   "the \"body\" component");
+           return 1;
+       }
+
+       NEW0(args);

 
 

-       return rc;
-    }
+       if (arglist_tail)
+           arglist_tail->a_next = args;
+
+       arglist_tail = args;

 
 

+       if (! arglist_head)
+           arglist_head = args;
+
+       args->a_nfs = getcpy (new_fs (NULL, NULL, cp));
+       filter_nargs++;
+
+       return 0;
+    }

 
     return 1;
 }
 
     return 1;
 }


@@ -776,7 +794,7 @@ ptoi (char *name, int *i)
     char *cp;
 
     if (*parptr++ != '=' || !*(cp = parse ())) {
     char *cp;
 
     if (*parptr++ != '=' || !*(cp = parse ())) {

-       advise (NULL, "missing argument to variable %s", name);
+       inform("missing argument to variable %s", name);

        return 1;
     }
 
        return 1;
     }
 


@@ -791,7 +809,7 @@ ptos (char *name, char **s)
     char c, *cp;
 
     if (*parptr++ != '=') {
     char c, *cp;
 
     if (*parptr++ != '=') {

-       advise (NULL, "missing argument to variable %s", name);
+       inform("missing argument to variable %s", name);

        return 1;
     }
 
        return 1;
     }
 


@@ -808,7 +826,7 @@ ptos (char *name, char **s)
     }
     c = *parptr;
     *parptr = 0;
     }
     c = *parptr;
     *parptr = 0;

-    *s = getcpy (cp);
+    *s = mh_xstrdup(cp);

     if ((*parptr = c) == '"')
        parptr++;
     return 0;
     if ((*parptr = c) == '"')
        parptr++;
     return 0;


@@ -824,15 +842,14 @@ parse (void)
 
     for (cp = result; *parptr && (cp - result < NAMESZ); parptr++) {
        c = *parptr;
 
     for (cp = result; *parptr && (cp - result < NAMESZ); parptr++) {
        c = *parptr;

-       if (isalnum (c)
-               || c == '.'
-               || c == '-'
-               || c == '_'
-               || c =='['
-               || c == ']')
-           *cp++ = c;
-       else
+       if (!isalnum (c)
+               && c != '.'
+               && c != '-'
+               && c != '_'
+               && c !='['
+               && c != ']')

            break;
            break;

+        *cp++ = c;

     }
     *cp = '\0';
 
     }
     *cp = '\0';
 


@@ -840,13 +857,24 @@ parse (void)
 }
 
 
 }
 
 

+/*
+ * Process one file/message
+ */
+

 static void
 process (char *folder, char *fname, int ofilen, int ofilec)
 {
 static void
 process (char *folder, char *fname, int ofilen, int ofilec)
 {

-    char *cp = NULL;
-    FILE *fp = NULL;
+    /* static to prevent "might be clobbered" warning from gcc 4.9.2: */
+    static char *cp;
+    static FILE *fp;

     struct mcomp *c1;
     struct stat st;
     struct mcomp *c1;
     struct stat st;

+    struct arglist *ap;
+    /* volatile to prevent "might be clobbered" warning from gcc: */
+    char *volatile fname2 = fname ? fname : "(stdin)";
+
+    cp = NULL;
+    fp = NULL;

 
     switch (setjmp (env)) {
        case OK: 
 
     switch (setjmp (env)) {
        case OK: 


@@ -858,7 +886,6 @@ process (char *folder, char *fname, int ofilen, int ofilec)
                    return;
                }
            } else {
                    return;
                }
            } else {

-               fname = "(stdin)";

                fp = stdin;
            }
            if (fstat(fileno(fp), &st) == 0) {
                fp = stdin;
            }
            if (fstat(fileno(fp), &st) == 0) {


@@ -866,28 +893,34 @@ process (char *folder, char *fname, int ofilen, int ofilec)
            } else {
                filesize = 0;
            }
            } else {
                filesize = 0;
            }

-           cp = folder ? concat (folder, ":", fname, NULL) : getcpy (fname);
+           cp = folder ? concat (folder, ":", fname2, NULL) : mh_xstrdup(fname2);

            if (ontty != PITTY)
                SIGNAL (SIGINT, intrser);
            if (ontty != PITTY)
                SIGNAL (SIGINT, intrser);

-           mhlfile (fp, cp, ofilen, ofilec);  /* FALL THROUGH! */
+           mhlfile (fp, cp, ofilen, ofilec);
+            free (cp);

 
 

-       default: 
+           for (ap = arglist_head; ap; ap = ap->a_next) {
+               fmt_free(ap->a_fmt, 0);
+               ap->a_fmt = NULL;
+           }
+
+           if (arglist_head)
+               fmt_free(NULL, 1);
+           /* FALLTHRU */
+
+       default:

            if (ontty != PITTY)
                SIGNAL (SIGINT, SIG_IGN);
            if (ontty != PITTY)
                SIGNAL (SIGINT, SIG_IGN);

-           if (mhl_action == NULL && fp != stdin)
+           if (mhl_action == NULL && fp != stdin && fp != NULL)

                fclose (fp);
                fclose (fp);

-           free (cp);
-           if (holder.c_text) {
-               free (holder.c_text);
-               holder.c_text = NULL;
-           }
+            free(holder.c_text);
+            holder.c_text = NULL;

            free_queue (&msghd, &msgtl);
            for (c1 = fmthd; c1; c1 = c1->c_next)
                c1->c_flags &= ~HDROUTPUT;
            break;
     }
 
            free_queue (&msghd, &msgtl);
            for (c1 = fmthd; c1; c1 = c1->c_next)
                c1->c_flags &= ~HDROUTPUT;
            break;
     }
 

-    freecomptext();

 }
 
 
 }
 
 


@@ -896,18 +929,21 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
 {
     int state, bucket;
     struct mcomp *c1, *c2, *c3;
 {
     int state, bucket;
     struct mcomp *c1, *c2, *c3;

-    char **ip, name[NAMESZ], buf[BUFSIZ];
+    char **ip, name[NAMESZ], buf[NMH_BUFSIZ];
+    m_getfld_state_t gstate;
+
+    compile_filterargs();

 
     if (forwall) {
        if (digest)
 
     if (forwall) {
        if (digest)

-           printf ("%s", ofilen == 1 ? delim3 : delim4);
+           fputs(ofilen == 1 ? delim3 : delim4, stdout);

        else {
            printf ("\n-------");
            if (ofilen == 1)
        else {
            printf ("\n-------");
            if (ofilen == 1)

-               printf (" Forwarded Message%s", ofilec > 1 ? "s" : "");
+               printf (" Forwarded Message%s", PLURALS(ofilec));

            else
                printf (" Message %d", ofilen);
            else
                printf (" Message %d", ofilen);

-           printf ("\n\n");
+           puts("\n");

        }
     } else {
        switch (ontty) {
        }
     } else {
        switch (ontty) {


@@ -915,9 +951,9 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
                if (ofilec > 1) {
                    if (ofilen > 1) {
                        if ((global.c_flags & CLEARSCR))
                if (ofilec > 1) {
                    if (ofilen > 1) {
                        if ((global.c_flags & CLEARSCR))

-                           clear_screen ();
+                           nmh_clear_screen ();

                        else
                        else

-                           printf ("\n\n\n");
+                            puts("\n\n");

                    }
                    printf (">>> %s\n\n", mname);
                }
                    }
                    printf (">>> %s\n\n", mname);
                }


@@ -928,27 +964,29 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
                if (ofilec > 1) {
                    if (SOprintf ("Press <return> to list \"%s\"...", mname)) {
                        if (ofilen > 1)
                if (ofilec > 1) {
                    if (SOprintf ("Press <return> to list \"%s\"...", mname)) {
                        if (ofilen > 1)

-                           printf ("\n\n\n");
+                           puts("\n\n");

                        printf ("Press <return> to list \"%s\"...", mname);
                    }
                    fflush (stdout);
                    buf[0] = 0;
                        printf ("Press <return> to list \"%s\"...", mname);
                    }
                    fflush (stdout);
                    buf[0] = 0;

-                   read (fileno (stdout), buf, sizeof(buf));
+                   if (read (fileno (stdout), buf, sizeof(buf)) < 0) {
+                       advise ("stdout", "read");
+                   }

                }
                if (strchr(buf, '\n')) {
                    if ((global.c_flags & CLEARSCR))
                }
                if (strchr(buf, '\n')) {
                    if ((global.c_flags & CLEARSCR))

-                       clear_screen ();
+                       nmh_clear_screen ();

                }
                else
                }
                else

-                   printf ("\n");
+                   putchar('\n');

                break;
 
            default: 
                if (ofilec > 1) {
                    if (ofilen > 1) {
                break;
 
            default: 
                if (ofilec > 1) {
                    if (ofilen > 1) {

-                       printf ("\n\n\n");
+                       puts("\n\n");

                        if (clearflg > 0)
                        if (clearflg > 0)

-                           clear_screen ();
+                           nmh_clear_screen ();

                    }
                    printf (">>> %s\n\n", mname);
                }
                    }
                    printf (">>> %s\n\n", mname);
                }


@@ -956,16 +994,19 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
        }
     }
 
        }
     }
 

-    for (state = FLD;;) {
-       switch (state = m_getfld (state, name, buf, sizeof(buf), fp)) {
+    gstate = m_getfld_state_init(fp);
+    for (;;) {
+       int bufsz = sizeof buf;
+       switch (state = m_getfld2(&gstate, name, buf, &bufsz)) {

            case FLD: 
            case FLDPLUS: 
            case FLD: 
            case FLDPLUS: 

-               bucket = checkcomp(name, buf);
+               bucket = fmt_addcomptext(name, buf);

                for (ip = ignores; *ip; ip++)
                for (ip = ignores; *ip; ip++)

-                   if (!mh_strcasecmp (name, *ip)) {
+                   if (!strcasecmp (name, *ip)) {

                        while (state == FLDPLUS) {
                        while (state == FLDPLUS) {

-                           state = m_getfld (state, name, buf, sizeof(buf), fp);
-                           addcomp(bucket, name, buf);
+                           bufsz = sizeof buf;
+                           state = m_getfld2(&gstate, name, buf, &bufsz);
+                           fmt_appendcomp(bucket, name, buf);

                        }
                        break;
                    }
                        }
                        break;
                    }


@@ -973,12 +1014,13 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
                    continue;
 
                for (c2 = fmthd; c2; c2 = c2->c_next)
                    continue;
 
                for (c2 = fmthd; c2; c2 = c2->c_next)

-                   if (!mh_strcasecmp (c2->c_name, name))
+                   if (!strcasecmp (FENDNULL(c2->c_name), name))

                        break;
                c1 = NULL;
                if (!((c3 = c2 ? c2 : &global)->c_flags & SPLIT))
                    for (c1 = msghd; c1; c1 = c1->c_next)
                        break;
                c1 = NULL;
                if (!((c3 = c2 ? c2 : &global)->c_flags & SPLIT))
                    for (c1 = msghd; c1; c1 = c1->c_next)

-                       if (!mh_strcasecmp (c1->c_name, c3->c_name)) {
+                       if (!strcasecmp (FENDNULL(c1->c_name),
+                                        FENDNULL(c3->c_name))) {

                            c1->c_text =
                                mcomp_add (c1->c_flags, buf, c1->c_text);
                            break;
                            c1->c_text =
                                mcomp_add (c1->c_flags, buf, c1->c_text);
                            break;


@@ -986,9 +1028,10 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
                if (c1 == NULL)
                    c1 = add_queue (&msghd, &msgtl, name, buf, 0);
                while (state == FLDPLUS) {
                if (c1 == NULL)
                    c1 = add_queue (&msghd, &msgtl, name, buf, 0);
                while (state == FLDPLUS) {

-                   state = m_getfld (state, name, buf, sizeof(buf), fp);
+                   bufsz = sizeof buf;
+                   state = m_getfld2(&gstate, name, buf, &bufsz);

                    c1->c_text = add (buf, c1->c_text);
                    c1->c_text = add (buf, c1->c_text);

-                   addcomp(bucket, name, buf);
+                   fmt_appendcomp(bucket, name, buf);

                }
                if (c2 == NULL)
                    c1->c_flags |= EXTRA;
                }
                if (c2 == NULL)
                    c1->c_flags |= EXTRA;


@@ -1002,7 +1045,8 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
                        putcomp (c1, c1, ONECOMP);
                        continue;
                    }
                        putcomp (c1, c1, ONECOMP);
                        continue;
                    }

-                   if (!mh_strcasecmp (c1->c_name, "messagename")) {
+                   if (!c1->c_name  ||
+                       !strcasecmp (c1->c_name, "messagename")) {

                        holder.c_text = concat ("(Message ", mname, ")\n",
                                            NULL);
                        putcomp (c1, &holder, ONECOMP);
                        holder.c_text = concat ("(Message ", mname, ")\n",
                                            NULL);
                        putcomp (c1, &holder, ONECOMP);


@@ -1010,23 +1054,25 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
                        holder.c_text = NULL;
                        continue;
                    }
                        holder.c_text = NULL;
                        continue;
                    }

-                   if (!mh_strcasecmp (c1->c_name, "extras")) {
+                   if (!c1->c_name  ||  !strcasecmp (c1->c_name, "extras")) {

                        for (c2 = msghd; c2; c2 = c2->c_next)
                            if (c2->c_flags & EXTRA)
                                putcomp (c1, c2, TWOCOMP);
                        continue;
                    }
                        for (c2 = msghd; c2; c2 = c2->c_next)
                            if (c2->c_flags & EXTRA)
                                putcomp (c1, c2, TWOCOMP);
                        continue;
                    }

-                   if (dobody && !mh_strcasecmp (c1->c_name, "body")) {
+                   if (dobody && (!c1->c_name  ||
+                                  !strcasecmp (c1->c_name, "body"))) {

                        if (c1->c_flags & FMTFILTER && state == BODY &&
                                                        formatproc != NULL) {
                        if (c1->c_flags & FMTFILTER && state == BODY &&
                                                        formatproc != NULL) {

-                           filterbody(c1, buf, sizeof(buf), state, fp);
+                           filterbody(c1, buf, sizeof(buf), state, gstate);

                        } else {
                            holder.c_text = mh_xmalloc (sizeof(buf));
                            strncpy (holder.c_text, buf, sizeof(buf));
                            while (state == BODY) {
                                putcomp (c1, &holder, BODYCOMP);
                        } else {
                            holder.c_text = mh_xmalloc (sizeof(buf));
                            strncpy (holder.c_text, buf, sizeof(buf));
                            while (state == BODY) {
                                putcomp (c1, &holder, BODYCOMP);

-                               state = m_getfld (state, name, holder.c_text,
-                                           sizeof(buf), fp);
+                               bufsz = sizeof buf;
+                               state = m_getfld2(&gstate, name, holder.c_text,
+                                           &bufsz);

                            }
                            free (holder.c_text);
                            holder.c_text = NULL;
                            }
                            free (holder.c_text);
                            holder.c_text = NULL;


@@ -1034,22 +1080,25 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec)
                        continue;
                    }
                    for (c2 = msghd; c2; c2 = c2->c_next)
                        continue;
                    }
                    for (c2 = msghd; c2; c2 = c2->c_next)

-                       if (!mh_strcasecmp (c2->c_name, c1->c_name)) {
+                       if (!strcasecmp (FENDNULL(c2->c_name),
+                                        FENDNULL(c1->c_name))) {

                            putcomp (c1, c2, ONECOMP);
                            if (!(c1->c_flags & SPLIT))
                                break;
                        }
                }
                            putcomp (c1, c2, ONECOMP);
                            if (!(c1->c_flags & SPLIT))
                                break;
                        }
                }

+               m_getfld_state_destroy (&gstate);

                return;
 
            case LENERR: 
            case FMTERR: 
                return;
 
            case LENERR: 
            case FMTERR: 

-               advise (NULL, "format error in message %s", mname);
+               inform("format error in message %s", mname);

                exitstat++;
                exitstat++;

+               m_getfld_state_destroy (&gstate);

                return;
 
            default: 
                return;
 
            default: 

-               adios (NULL, "getfld() returned %d", state);
+               mhladios (NULL, "getfld() returned %d", state);

        }
     }
 }
        }
     }
 }


@@ -1061,7 +1110,7 @@ mcomp_flags (char *name)
     struct pair *ap;
 
     for (ap = pairs; ap->p_name; ap++)
     struct pair *ap;
 
     for (ap = pairs; ap->p_name; ap++)

-       if (!mh_strcasecmp (ap->p_name, name))
+       if (!strcasecmp (ap->p_name, name))

            return (ap->p_flags);
 
     return 0;
            return (ap->p_flags);
 
     return 0;


@@ -1069,7 +1118,7 @@ mcomp_flags (char *name)
 
 
 static char *
 
 
 static char *

-mcomp_add (long flags, char *s1, char *s2)
+mcomp_add (unsigned long flags, char *s1, char *s2)

 {
     char *dp;
 
 {
     char *dp;
 


@@ -1095,8 +1144,7 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2)
 {
     int dat[5];
     char *ap, *cp;
 {
     int dat[5];
     char *ap, *cp;

-    char buffer[BUFSIZ], error[BUFSIZ];
-    struct comp *cptr;
+    char error[BUFSIZ];

     struct pqpair *p, *q;
     struct pqpair pq;
     struct mailname *mp;
     struct pqpair *p, *q;
     struct pqpair pq;
     struct mailname *mp;


@@ -1106,50 +1154,55 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2)
     dat[0] = 0;
     dat[1] = 0;
     dat[2] = filesize;
     dat[0] = 0;
     dat[1] = 0;
     dat[2] = filesize;

-    dat[3] = sizeof(buffer) - 1;
+    dat[3] = BUFSIZ - 1;

     dat[4] = 0;
     dat[4] = 0;

-    fmt_compile (c1->c_nfs, &c1->c_fmt);

 
     if (!(c1->c_flags & ADDRFMT)) {
 
     if (!(c1->c_flags & ADDRFMT)) {

-       FINDCOMP (cptr, "text");
-       if (cptr)
-           cptr->c_text = ap;
+       charstring_t scanl = charstring_create (BUFSIZ);
+
+       if (c1->c_c_text)
+           c1->c_c_text->c_text = ap;

        if ((cp = strrchr(ap, '\n')))   /* drop ending newline */
            if (!cp[1])
                *cp = 0;
 
        if ((cp = strrchr(ap, '\n')))   /* drop ending newline */
            if (!cp[1])
                *cp = 0;
 

-       fmt_scan (c1->c_fmt, buffer, sizeof buffer - 1, sizeof buffer - 1, dat);
+       fmt_scan (c1->c_fmt, scanl, BUFSIZ - 1, dat, NULL);

        /* Don't need to append a newline, dctime() already did */
        /* Don't need to append a newline, dctime() already did */

-       c2->c_text = getcpy (buffer);
+       c2->c_text = charstring_buffer_copy (scanl);
+       charstring_free (scanl);

 
 

-       free (ap);
+       /* ap is now owned by the component struct, so do NOT free it here */

        return;
     }
 
     (q = &pq)->pq_next = NULL;
     while ((cp = getname (ap))) {
        return;
     }
 
     (q = &pq)->pq_next = NULL;
     while ((cp = getname (ap))) {

-       if ((p = (struct pqpair *) calloc ((size_t) 1, sizeof(*p))) == NULL)
-           adios (NULL, "unable to allocate pqpair memory");
-
-       if ((mp = getm (cp, NULL, 0, AD_NAME, error)) == NULL) {
-           p->pq_text = getcpy (cp);
-           p->pq_error = getcpy (error);
-       } else {
-           p->pq_text = getcpy (mp->m_text);
-           mnfree (mp);
-       }
-       q = (q->pq_next = p);
+       NEW0(p);
+        if ((mp = getm (cp, NULL, 0, error, sizeof(error))) == NULL) {
+            p->pq_text = mh_xstrdup(cp);
+            p->pq_error = mh_xstrdup(error);
+        } else {
+            p->pq_text = getcpy (mp->m_text);
+            mnfree (mp);
+        }
+        q = (q->pq_next = p);

     }
 
     for (p = pq.pq_next; p; p = q) {
     }
 
     for (p = pq.pq_next; p; p = q) {

-       FINDCOMP (cptr, "text");
-       if (cptr)
-           cptr->c_text = p->pq_text;
-       FINDCOMP (cptr, "error");
-       if (cptr)
-           cptr->c_text = p->pq_error;
+       charstring_t scanl = charstring_create (BUFSIZ);
+       char *buffer;
+
+       if (c1->c_c_text) {
+           c1->c_c_text->c_text = p->pq_text;
+           p->pq_text = NULL;
+       }
+       if (c1->c_c_error) {
+           c1->c_c_error->c_text = p->pq_error;
+           p->pq_error = NULL;
+       }

 
 

-       fmt_scan (c1->c_fmt, buffer, sizeof buffer - 1, sizeof buffer - 1, dat);
+       fmt_scan (c1->c_fmt, scanl, BUFSIZ - 1, dat, NULL);
+       buffer = charstring_buffer_copy (scanl);

        if (*buffer) {
            if (c2->c_text)
                c2->c_text = add (",\n", c2->c_text);
        if (*buffer) {
            if (c2->c_text)
                c2->c_text = add (",\n", c2->c_text);


@@ -1157,12 +1210,12 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2)
                *cp = 0;
            c2->c_text = add (buffer, c2->c_text);
        }
                *cp = 0;
            c2->c_text = add (buffer, c2->c_text);
        }

+       charstring_free (scanl);

 
 

-       free (p->pq_text);
-       if (p->pq_error)
-           free (p->pq_error);
+        free(p->pq_text);
+        free(p->pq_error);

        q = p->pq_next;
        q = p->pq_next;

-       free ((char *) p);
+       free(p);

     }
 
     c2->c_text = add ("\n", c2->c_text);
     }
 
     c2->c_text = add ("\n", c2->c_text);


@@ -1175,21 +1228,19 @@ add_queue (struct mcomp **head, struct mcomp **tail, char *name, char *text, int
 {
     struct mcomp *c1;
 
 {
     struct mcomp *c1;
 

-    if ((c1 = (struct mcomp *) calloc ((size_t) 1, sizeof(*c1))) == NULL)
-       adios (NULL, "unable to allocate comp memory");
-
+    NEW0(c1);

     c1->c_flags = flags & ~INIT;
     c1->c_flags = flags & ~INIT;

-    if ((c1->c_name = name ? getcpy (name) : NULL))
-       c1->c_flags |= mcomp_flags (c1->c_name);
-    c1->c_text = text ? getcpy (text) : NULL;
+    if ((c1->c_name = name ? mh_xstrdup(name) : NULL))
+        c1->c_flags |= mcomp_flags (c1->c_name);
+    c1->c_text = text ? mh_xstrdup(text) : NULL;

     if (flags & INIT) {
     if (flags & INIT) {

-       if (global.c_ovtxt)
-           c1->c_ovtxt = getcpy (global.c_ovtxt);
-       c1->c_offset = global.c_offset;
-       c1->c_ovoff = global. c_ovoff;
-       c1->c_width = c1->c_length = 0;
-       c1->c_cwidth = global.c_cwidth;
-       c1->c_flags |= global.c_flags & GFLAGS;
+        if (global.c_ovtxt)
+            c1->c_ovtxt = mh_xstrdup(global.c_ovtxt);
+        c1->c_offset = global.c_offset;
+        c1->c_ovoff = global. c_ovoff;
+        c1->c_width = c1->c_length = 0;
+        c1->c_cwidth = global.c_cwidth;
+        c1->c_flags |= global.c_flags & GFLAGS;

     }
     if (*head == NULL)
        *head = c1;
     }
     if (*head == NULL)
        *head = c1;


@@ -1208,28 +1259,13 @@ free_queue (struct mcomp **head, struct mcomp **tail)
 
     for (c1 = *head; c1; c1 = c2) {
        c2 = c1->c_next;
 
     for (c1 = *head; c1; c1 = c2) {
        c2 = c1->c_next;

-       if (c1->c_name)
-           free (c1->c_name);
-       if (c1->c_text)
-           free (c1->c_text);
-       if (c1->c_ovtxt)
-           free (c1->c_ovtxt);
-       if (c1->c_nfs)
-           free (c1->c_nfs);
+        free(c1->c_name);
+        free(c1->c_text);
+        free(c1->c_ovtxt);
+        free(c1->c_nfs);

        if (c1->c_fmt)
        if (c1->c_fmt)

-           free ((char *) c1->c_fmt);
-       if (c1->c_f_args) {
-           struct arglist *a1, *a2;
-           for (a1 = c1->c_f_args; a1; a1 = a2) {
-               a2 = a1->a_next;
-               if (a1->a_fmt)
-                   free(a1->a_fmt);
-               if (a1->a_nfs)
-                   free(a1->a_nfs);
-           }
-           free(a1);
-       }
-       free ((char *) c1);
+           fmt_free (c1->c_fmt, 0);
+       free(c1);

     }
 
     *head = *tail = NULL;
     }
 
     *head = *tail = NULL;


@@ -1239,8 +1275,22 @@ free_queue (struct mcomp **head, struct mcomp **tail)
 static void
 putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
 {
 static void
 putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
 {

+    char *text; /* c1's text, or the name as a fallback. */
+    char *trimmed_prefix;

     int count, cchdr;
     int count, cchdr;

-    unsigned char *cp;
+    char *cp;
+    const int utf8 = strcasecmp(get_charset(), "UTF-8") == 0;
+
+    if (! utf8  &&  flag != BODYCOMP) {
+        /* Don't print 8-bit bytes in header field values if not in a
+           UTF-8 locale, as required by RFC 6532. */
+       c1->c_flags |= FORCE7BIT;
+    }
+
+    text = c1->c_text ? c1->c_text : c1->c_name;
+    /* Create a copy with trailing whitespace trimmed, for use with
+     * blank lines. */
+    trimmed_prefix = rtrim(mh_xstrdup(FENDNULL(text)));

 
     cchdr = 0;
     lm = 0;
 
     cchdr = 0;
     lm = 0;


@@ -1251,12 +1301,13 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
     if ((ovtxt = c1->c_ovtxt ? c1->c_ovtxt : global.c_ovtxt) == NULL)
        ovtxt = "";
     if (wid < ovoff + strlen (ovtxt) + 5)
     if ((ovtxt = c1->c_ovtxt ? c1->c_ovtxt : global.c_ovtxt) == NULL)
        ovtxt = "";
     if (wid < ovoff + strlen (ovtxt) + 5)

-       adios (NULL, "component: %s width(%d) too small for overflow(%d)",
+       mhladios(NULL, "component: %s width(%d) too small for overflow(%zu)",

                c1->c_name, wid, ovoff + strlen (ovtxt) + 5);
     onelp = NULL;
 
     if (c1->c_flags & CLEARTEXT) {
                c1->c_name, wid, ovoff + strlen (ovtxt) + 5);
     onelp = NULL;
 
     if (c1->c_flags & CLEARTEXT) {

-       putstr (c1->c_text, c1->c_flags);
+       putstr (c1->c_flags & RTRIM ? rtrim (c1->c_text) : c1->c_text,
+               c1->c_flags);

        putstr ("\n", c1->c_flags);
        return;
     }
        putstr ("\n", c1->c_flags);
        return;
     }


@@ -1268,7 +1319,7 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
        count = (c1->c_width ? c1->c_width : global.c_width)
            - c1->c_offset - strlen (c2->c_text);
        if (!(c1->c_flags & HDROUTPUT) && !(c1->c_flags & NOCOMPONENT))
        count = (c1->c_width ? c1->c_width : global.c_width)
            - c1->c_offset - strlen (c2->c_text);
        if (!(c1->c_flags & HDROUTPUT) && !(c1->c_flags & NOCOMPONENT))

-           count -= strlen (c1->c_text ? c1->c_text : c1->c_name) + 2;
+           count -= strlen(text) + 2;

        lm = c1->c_offset + (count / 2);
     } else {
        if (c1->c_offset)
        lm = c1->c_offset + (count / 2);
     } else {
        if (c1->c_offset)


@@ -1277,18 +1328,15 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
 
     if (!(c1->c_flags & HDROUTPUT) && !(c1->c_flags & NOCOMPONENT)) {
         if (c1->c_flags & UPPERCASE)           /* uppercase component also */
 
     if (!(c1->c_flags & HDROUTPUT) && !(c1->c_flags & NOCOMPONENT)) {
         if (c1->c_flags & UPPERCASE)           /* uppercase component also */

-           for (cp = (c1->c_text ? c1->c_text : c1->c_name); *cp; cp++)
-               if (islower (*cp))
-                   *cp = toupper (*cp);
-       putstr (c1->c_text ? c1->c_text : c1->c_name, c1->c_flags);
+            to_upper(text);
+       putstr(text, c1->c_flags);

        if (flag != BODYCOMP) {
            putstr (": ", c1->c_flags);
            if (!(c1->c_flags & SPLIT))
                c1->c_flags |= HDROUTPUT;
 
        cchdr++;
        if (flag != BODYCOMP) {
            putstr (": ", c1->c_flags);
            if (!(c1->c_flags & SPLIT))
                c1->c_flags |= HDROUTPUT;
 
        cchdr++;

-       if ((count = c1->c_cwidth -
-               strlen (c1->c_text ? c1->c_text : c1->c_name) - 2) > 0)
+       if ((count = c1->c_cwidth - strlen(text) - 2) > 0)

            while (count--)
                putstr (" ", c1->c_flags);
        }
            while (count--)
                putstr (" ", c1->c_flags);
        }


@@ -1300,9 +1348,7 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
            && !(c2->c_flags & HDROUTPUT)
            && !(c2->c_flags & NOCOMPONENT)) {
         if (c1->c_flags & UPPERCASE)
            && !(c2->c_flags & HDROUTPUT)
            && !(c2->c_flags & NOCOMPONENT)) {
         if (c1->c_flags & UPPERCASE)

-           for (cp = c2->c_name; *cp; cp++)
-               if (islower (*cp))
-                   *cp = toupper (*cp);
+            to_upper(c2->c_name);

        putstr (c2->c_name, c1->c_flags);
        putstr (": ", c1->c_flags);
        if (!(c1->c_flags & SPLIT))
        putstr (c2->c_name, c1->c_flags);
        putstr (": ", c1->c_flags);
        if (!(c1->c_flags & SPLIT))


@@ -1314,9 +1360,7 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
                putstr (" ", c1->c_flags);
     }
     if (c1->c_flags & UPPERCASE)
                putstr (" ", c1->c_flags);
     }
     if (c1->c_flags & UPPERCASE)

-       for (cp = c2->c_text; *cp; cp++)
-           if (islower (*cp))
-               *cp = toupper (*cp);
+        to_upper(c2->c_text);

 
     count = 0;
     if (cchdr) {
 
     count = 0;
     if (cchdr) {


@@ -1325,31 +1369,43 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag)
                        : (int) strlen (c2->c_name) + 2;
        else
            count = (c1->c_cwidth >= 0) ? (size_t) c1->c_cwidth
                        : (int) strlen (c2->c_name) + 2;
        else
            count = (c1->c_cwidth >= 0) ? (size_t) c1->c_cwidth

-                       : strlen (c1->c_text ? c1->c_text : c1->c_name) + 2;
+                       : strlen(text) + 2;

     }
     count += c1->c_offset;
 
     if ((cp = oneline (c2->c_text, c1->c_flags)))
     }
     count += c1->c_offset;
 
     if ((cp = oneline (c2->c_text, c1->c_flags)))

-       putstr(cp, c1->c_flags);
+       /* Output line, trimming trailing whitespace if requested. */
+       putstr (c1->c_flags & RTRIM ? rtrim (cp) : cp, c1->c_flags);

     if (term == '\n')
        putstr ("\n", c1->c_flags);
     while ((cp = oneline (c2->c_text, c1->c_flags))) {
        lm = count;
        if (flag == BODYCOMP
     if (term == '\n')
        putstr ("\n", c1->c_flags);
     while ((cp = oneline (c2->c_text, c1->c_flags))) {
        lm = count;
        if (flag == BODYCOMP

-               && !(c1->c_flags & NOCOMPONENT))
-           putstr (c1->c_text ? c1->c_text : c1->c_name, c1->c_flags);
-       if (*cp)
-           putstr (cp, c1->c_flags);
+               && !(c1->c_flags & NOCOMPONENT)) {
+           /* Output component, trimming trailing whitespace if there
+              is no text on the line. */
+           if (*cp) {
+               putstr(text, c1->c_flags);
+           } else {
+               putstr (trimmed_prefix, c1->c_flags);
+           }
+       }
+       if (*cp) {
+           /* Output line, trimming trailing whitespace if requested. */
+           putstr (c1->c_flags & RTRIM ? rtrim (cp) : cp, c1->c_flags);
+        }

        if (term == '\n')
            putstr ("\n", c1->c_flags);
     }
     if (flag == BODYCOMP && term == '\n')
        c1->c_flags &= ~HDROUTPUT;              /* Buffer ended on a newline */
        if (term == '\n')
            putstr ("\n", c1->c_flags);
     }
     if (flag == BODYCOMP && term == '\n')
        c1->c_flags &= ~HDROUTPUT;              /* Buffer ended on a newline */

+
+    free (trimmed_prefix);

 }
 
 
 static char *
 }
 
 
 static char *

-oneline (char *stuff, long flags)
+oneline (char *stuff, unsigned long flags)

 {
     int spc;
     char *cp, *ret;
 {
     int spc;
     char *cp, *ret;


@@ -1363,17 +1419,16 @@ oneline (char *stuff, long flags)
     term = 0;
     if (flags & COMPRESS) {
        for (spc = 1, cp = ret; *onelp; onelp++)
     term = 0;
     if (flags & COMPRESS) {
        for (spc = 1, cp = ret; *onelp; onelp++)

-           if (isspace (*onelp)) {
+           if (isspace ((unsigned char) *onelp)) {

                if (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT))) {
                    term = '\n';
                    *onelp++ = 0;
                    break;
                }
                if (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT))) {
                    term = '\n';
                    *onelp++ = 0;
                    break;
                }

-               else
-                   if (!spc) {
-                       *cp++ = ' ';
-                       spc++;
-                   }
+                if (!spc) {
+                    *cp++ = ' ';
+                    spc++;
+                }

            }
            else {
                *cp++ = *onelp;
            }
            else {
                *cp++ = *onelp;


@@ -1401,8 +1456,12 @@ oneline (char *stuff, long flags)
 
 
 static void
 
 
 static void

-putstr (char *string, long flags)
+putstr (char *string, unsigned long flags)

 {
 {

+    /* To not count, for the purpose of counting columns, all of
+       the bytes of a multibyte character. */
+    int char_len;
+

     if (!column && lm > 0) {
        while (lm > 0)
            if (lm >= 8) {
     if (!column && lm > 0) {
        while (lm > 0)
            if (lm >= 8) {


@@ -1415,13 +1474,38 @@ putstr (char *string, long flags)
            }
     }
     lm = 0;
            }
     }
     lm = 0;

-    while (*string)
-       putch (*string++, flags);
+
+#ifdef MULTIBYTE_SUPPORT
+    if (mbtowc (NULL, NULL, 0)) {} /* reset shift state */
+    char_len = 0;
+#else
+    NMH_UNUSED (char_len);
+#endif
+
+    while (*string) {
+        flags &= ~INVISIBLE;
+#ifdef MULTIBYTE_SUPPORT
+        /* mbtowc should never return 0, because *string is non-NULL. */
+        if (char_len <= 0) {
+            /* Find number of bytes in next character. */
+            if ((char_len =
+                 mbtowc (NULL, string, (size_t) MB_CUR_MAX)) == -1) {
+                char_len = 1;
+            }
+        } else {
+            /* Multibyte character, after the first byte. */
+            flags |= INVISIBLE;
+        }
+
+        --char_len;
+#endif
+        putch (*string++, flags);
+    }

 }
 
 
 static void
 }
 
 
 static void

-putch (char ch, long flags)
+putch (char ch, unsigned long flags)

 {
     char buf[BUFSIZ];
 
 {
     char buf[BUFSIZ];
 


@@ -1440,10 +1524,12 @@ putch (char ch, long flags)
                putchar ('\007');
            fflush (stdout);
            buf[0] = 0;
                putchar ('\007');
            fflush (stdout);
            buf[0] = 0;

-           read (fileno (stdout), buf, sizeof(buf));
+           if (read (fileno (stdout), buf, sizeof(buf)) < 0) {
+               advise ("stdout", "read");
+           }

            if (strchr(buf, '\n')) {
                if (global.c_flags & CLEARSCR)
            if (strchr(buf, '\n')) {
                if (global.c_flags & CLEARSCR)

-                   clear_screen ();
+                   nmh_clear_screen ();

                row = 0;
            } else {
                putchar ('\n');
                row = 0;
            } else {
                putchar ('\n');


@@ -1473,8 +1559,25 @@ putch (char ch, long flags)
                putchar ('-');
                putchar (' ');
            }
                putchar ('-');
                putchar (' ');
            }

-           if (ch >= ' ')
-               column++;
+            /*
+             * Increment the character count, unless
+             * 1) In UTF-8 locale, this is other than the last byte of
+                  a multibyte character, or
+             * 2) In C locale, will print a non-printable character.
+             */
+            if ((flags & FORCE7BIT) == 0) {
+                /* UTF-8 locale */
+                if ((flags & INVISIBLE) == 0) {
+                    /* If multibyte character, its first byte only. */
+                    ++column;
+                }
+            } else {
+                /* If not an ASCII character, the replace character will be
+                   displayed.  Count it. */
+                if (! isascii((unsigned char) ch) || isprint((unsigned char) ch)) {
+                    ++column;
+                }
+            }

            break;
     }
 
            break;
     }
 


@@ -1482,12 +1585,16 @@ putch (char ch, long flags)
        putch ('\n', flags);
        if (ovoff > 0)
            lm = ovoff;
        putch ('\n', flags);
        if (ovoff > 0)
            lm = ovoff;

-       putstr (ovtxt ? ovtxt : "", flags);
+       putstr (FENDNULL(ovtxt), flags);

        putch (ch, flags);
        return;
     }
 
        putch (ch, flags);
        return;
     }
 

-    putchar (ch);
+    if (flags & FORCE7BIT  &&  ! isascii((unsigned char) ch)) {
+        putchar ('?');
+    } else {
+        putchar (ch);
+    }

 }
 
 
 }
 
 


@@ -1507,7 +1614,7 @@ pipeser (int i)
 {
     NMH_UNUSED (i);
 
 {
     NMH_UNUSED (i);
 

-    done (NOTOK);
+    mhldone (NOTOK);

 }
 
 
 }
 
 


@@ -1518,58 +1625,9 @@ quitser (int i)
 
     putchar ('\n');
     fflush (stdout);
 
     putchar ('\n');
     fflush (stdout);

-    done (NOTOK);
-}
-
-
-int
-mhlsbr (int argc, char **argv, FILE *(*action)())
-{
-    SIGNAL_HANDLER istat = NULL, pstat = NULL, qstat = NULL;
-    char *cp = NULL;
-    struct mcomp *c1;
-
-    switch (setjmp (mhlenv)) {
-       case OK: 
-           cp = invo_name;
-           sleepsw = 0;        /* XXX */
-           bellflg = clearflg = forwflg = forwall = exitstat = 0;
-           digest = NULL;
-           ontty = NOTTY;
-           mhl_action = action;
-
-           /*
-            * If signal is at default action, then start ignoring
-            * it, else let it set to its current action.
-            */
-           if ((istat = SIGNAL (SIGINT, SIG_IGN)) != SIG_DFL)
-               SIGNAL (SIGINT, istat);
-           if ((qstat = SIGNAL (SIGQUIT, SIG_IGN)) != SIG_DFL)
-               SIGNAL (SIGQUIT, qstat);
-           pstat = SIGNAL (SIGPIPE, pipeser);
-           mhl (argc, argv);                  /* FALL THROUGH! */
-
-       default: 
-           SIGNAL (SIGINT, istat);
-           SIGNAL (SIGQUIT, qstat);
-           SIGNAL (SIGPIPE, SIG_IGN);/* should probably change to block instead */
-           if (ontty == PITTY)
-               m_pclose ();
-           SIGNAL (SIGPIPE, pstat);
-           invo_name = cp;
-           if (holder.c_text) {
-               free (holder.c_text);
-               holder.c_text = NULL;
-           }
-           free_queue (&msghd, &msgtl);
-           for (c1 = fmthd; c1; c1 = c1->c_next)
-               c1->c_flags &= ~HDROUTPUT;
-           return exitstat;
-    }
+    mhldone (NOTOK);

 }
 
 }
 

-#undef adios
-#undef done

 
 static void
 mhladios (char *what, char *fmt, ...)
 
 static void
 mhladios (char *what, char *fmt, ...)


@@ -1589,251 +1647,71 @@ mhldone (int status)
     exitstat = status;
     if (mhl_action)
        longjmp (mhlenv, DONE);
     exitstat = status;
     if (mhl_action)
        longjmp (mhlenv, DONE);

-    else
-       done (exitstat);
+    done (exitstat);

 }
 
 
 }
 
 

-static int m_pid = NOTOK;
-static  int sd = NOTOK;
+/*
+ * Compile a format string used by the formatfield option and save it
+ * for later.
+ *
+ * We will want the {text} (and possibly {error}) components for later,
+ * so look for them and save them if we find them.
+ */

 
 static void
 
 static void

-m_popen (char *name)
-{
-    int pd[2];
-
-    if (mhl_action && (sd = dup (fileno (stdout))) == NOTOK)
-       adios ("standard output", "unable to dup()");
-
-    if (pipe (pd) == NOTOK)
-       adios ("pipe", "unable to");
-
-    switch (m_pid = vfork()) {
-       case NOTOK: 
-           adios ("fork", "unable to");
-
-       case OK: 
-           SIGNAL (SIGINT, SIG_DFL);
-           SIGNAL (SIGQUIT, SIG_DFL);
-
-           close (pd[1]);
-           if (pd[0] != fileno (stdin)) {
-               dup2 (pd[0], fileno (stdin));
-               close (pd[0]);
-           }
-           execlp (name, r1bindex (name, '/'), NULL);
-           fprintf (stderr, "unable to exec ");
-           perror (name);
-           _exit (-1);
-
-       default: 
-           close (pd[0]);
-           if (pd[1] != fileno (stdout)) {
-               dup2 (pd[1], fileno (stdout));
-               close (pd[1]);
-           }
-    }
-}
-
-
-void
-m_pclose (void)
+compile_formatfield(struct mcomp *c1)

 {
 {

-    if (m_pid == NOTOK)
-       return;
+    fmt_compile(c1->c_nfs, &c1->c_fmt, 1);

 
 

-    if (sd != NOTOK) {
-       fflush (stdout);
-       if (dup2 (sd, fileno (stdout)) == NOTOK)
-           adios ("standard output", "unable to dup2()");
-
-       clearerr (stdout);
-       close (sd);
-       sd = NOTOK;
-    }
-    else
-       fclose (stdout);
+    /*
+     * As a note to myself and any other poor bastard who is looking through
+     * this code in the future ....
+     *
+     * When the format hash table is reset later on (as it almost certainly
+     * will be), there will still be references to these components in the
+     * compiled format instructions.  Thus these component references will
+     * be free'd when the format instructions are free'd (by fmt_free()).
+     *
+     * So, in other words ... don't go free'ing them yourself!
+     */

 
 

-    pidwait (m_pid, OK);
-    m_pid = NOTOK;
+    c1->c_c_text = fmt_findcomp("text");
+    c1->c_c_error = fmt_findcomp("error");

 }
 
 }
 

-

 /*
 /*

- * Compile a format string and add it to the list of arguments used by
- * the formatproc.
+ * Compile all of the arguments for our format list.

  *
  *

- * This deserves some explanation.  Here's the deal:
+ * Iterate through the linked list of format strings and compile them.
+ * Note that we reset the format hash table before we start, but we do NOT
+ * reset it between calls to fmt_compile().

  *
  *

- * We want to keep track of components used as arguments by formatproc,
- * but the hash table is reset every time fmt_compile is called.  So we
- * iterate through the function list looking for things that use components
- * and save the name.  And because we might get the same components used
- * by different arguments we need to keep track to every reference of
- * every component so we can add them when the message is processed.  So
- * we compile the argument string now (to get the components we use) and
- * save them for later.

  */
 
  */
 

-static int
-compileargs (struct mcomp *c1, char *nfs)
+static void
+compile_filterargs (void)

 {
 {

-    struct format *fmt;
-    struct arglist *args;
-    char **ap;
+    struct arglist *arg = arglist_head;

     struct comp *cptr;
     struct comp *cptr;

-    unsigned int i;
+    char **ap;
+
+    fmt_free(NULL, 1);

 
 

-    i = fmt_compile(nfs, &fmt);
+    while (arg) {
+       fmt_compile(arg->a_nfs, &arg->a_fmt, 0);
+       arg = arg->a_next;
+    }

 
     /*
      * Search through and mark any components that are address components
      */
 
     for (ap = addrcomps; *ap; ap++) {
 
     /*
      * Search through and mark any components that are address components
      */
 
     for (ap = addrcomps; *ap; ap++) {

-       FINDCOMP (cptr, *ap);
+       cptr = fmt_findcomp (*ap);

        if (cptr)
            cptr->c_type |= CT_ADDR;
     }
        if (cptr)
            cptr->c_type |= CT_ADDR;
     }

-
-    args = (struct arglist *) mh_xmalloc(sizeof(struct arglist));
-
-    if (! args)
-       adios (NULL, "Unable to allocate formatproc args storage");
-
-    args->a_fmt = fmt;
-    args->a_nfs = format_string;
-    args->a_next = NULL;
-    c1->c_nargs++;
-    format_string = NULL;
-
-    if (c1->c_f_tail)
-       c1->c_f_tail->a_next = args;
-
-    c1->c_f_tail = args;
-
-    if (! c1->c_f_args)
-       c1->c_f_args = args;
-
-    if (i == 0)
-       return 0;
-
-    /*
-     * If wantcomp ever changes size, we need to change the size
-     * of mhlcomp as well
-     */
-
-    for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++) {
-       if (wantcomp[i]) {
-           if (mhlcomp[i]) {
-               struct comp *c;
-               for (c = mhlcomp[i]; c->c_next != NULL; c = c->c_next)
-                   ;
-               c->c_next = wantcomp[i];
-           } else
-               mhlcomp[i] = wantcomp[i];
-       }
-    }
-
-    return 0;
-}
-
-/*
- * Check to see if we are interested in a component.  If we are, save
- * the text.
- */
-
-static int
-checkcomp(char *name, char *buf)
-{
-    int found = 0, i;
-    struct comp *c;
-    int bucket = CHASH(name);
-    char *cp;
- 
-    if ((c = mhlcomp[bucket])) {
-       do {
-           if (mh_strcasecmp(name, c->c_name) == 0) {
-               found++;
-               if (! c->c_text) {
-                   c->c_text = strdup(buf);
-               } else {
-                   i = strlen(cp = c->c_text) - 1;
-                   if (cp[i] == '\n') {
-                       if (c->c_type & CT_ADDR) {
-                           cp[i] = '\0';
-                           cp = add (",\n\t", cp);
-                       } else {
-                           cp = add ("\t", cp);
-                       }
-                   }
-                   c->c_text = add (buf, cp);
-               }
-           }
-       } while ((c = c->c_next));
-    }
-
-    return found ? bucket : -1;
-}
-
-/*
- * Add text to an existing component
- */
-
-static void
-addcomp(int bucket, char *name, char *buf)
-{
-    struct comp *c;
-
-    if (bucket != -1) {
-       c = mhlcomp[bucket];
-       do {
-           if (mh_strcasecmp(name, c->c_name) == 0)
-               c->c_text = add (buf, c->c_text);
-       } while ((c = c->c_next));
-    }
-}
-
-/*
- * Free up saved component structures
- */
-
-static void
-freecomps(void)
-{
-    struct comp *c1, *c2;
-    unsigned int i;
-
-    for (i = 0; i < sizeof(mhlcomp)/sizeof(mhlcomp[0]); i++) {
-       if ((c1 = mhlcomp[i]))
-           for (; c1; c1 = c2) {
-               c2 = c1->c_next;
-               if (c1->c_text)
-                   free(c1->c_text);
-               free(c1);
-           }
-    }
-}
-
-/*
- * Just free up the component text.
- */
-
-static void
-freecomptext(void)
-{
-    struct comp *c1;
-    unsigned int i;
-
-    for (i = 0; i < sizeof(mhlcomp)/sizeof(mhlcomp[0]); i++) {
-       if ((c1 = mhlcomp[i]))
-           for (; c1; c1 = c1->c_next) {
-               if (c1->c_text) {
-                   free(c1->c_text);
-                   c1->c_text = NULL;
-               }
-           }
-    }

 }
 
 /*
 }
 
 /*


@@ -1841,7 +1719,8 @@ freecomptext(void)
  */
 
 static void
  */
 
 static void

-filterbody (struct mcomp *c1, char *buf, int bufsz, int state, FILE *fp)
+filterbody (struct mcomp *c1, char *buf, int bufsz, int state,
+    m_getfld_state_t gstate)

 {
     struct mcomp holder;
     char name[NAMESZ];
 {
     struct mcomp holder;
     char name[NAMESZ];


@@ -1891,12 +1770,15 @@ filterbody (struct mcomp *c1, char *buf, int bufsz, int state, FILE *fp)
        close(fdoutput[1]);
 
        /*
        close(fdoutput[1]);
 
        /*

-        * Call m_getfld() until we're no longer in the BODY state
+        * Call m_getfld2() until we're no longer in the BODY state

         */
 
        while (state == BODY) {
         */
 
        while (state == BODY) {

-           write(fdinput[1], buf, strlen(buf));
-           state = m_getfld(state, name, buf, bufsz, fp);
+           int bufsz2 = bufsz;
+           if (write(fdinput[1], buf, strlen(buf)) < 0) {
+               advise ("pipe output", "write");
+           }
+           state = m_getfld2(&gstate, name, buf, &bufsz2);

        }
 
        /*
        }
 
        /*


@@ -1909,7 +1791,6 @@ filterbody (struct mcomp *c1, char *buf, int bufsz, int state, FILE *fp)
         * buffers that we have duplicated from the parent.
         */
        _exit(0);
         * buffers that we have duplicated from the parent.
         */
        _exit(0);

-       break;

     case -1:
        adios(NULL, "Unable to fork for filter writer process");
        break;
     case -1:
        adios(NULL, "Unable to fork for filter writer process");
        break;


@@ -1921,18 +1802,17 @@ filterbody (struct mcomp *c1, char *buf, int bufsz, int state, FILE *fp)
      */
 
     switch (filterpid = fork()) {
      */
 
     switch (filterpid = fork()) {

-        char **args;
+        char **args, *program;

        struct arglist *a;
        struct arglist *a;

-       int i, dat[5], s;
+       int i, dat[5], s, argp;

 
     case 0:
        /*
 
     case 0:
        /*

-        * Allocate an argument array for us
+        * Configure an argument array for us

         */
 
         */
 

-       args = (char **) mh_xmalloc((c1->c_nargs + 2) * sizeof(char *));
-       args[0] = formatproc;
-       args[c1->c_nargs + 1] = NULL;
+       args = argsplit(formatproc, &program, &argp);
+       args[argp + filter_nargs] = NULL;

        dat[0] = 0;
        dat[1] = 0;
        dat[2] = 0;
        dat[0] = 0;
        dat[1] = 0;
        dat[2] = 0;


@@ -1943,19 +1823,26 @@ filterbody (struct mcomp *c1, char *buf, int bufsz, int state, FILE *fp)
         * Pull out each argument and scan them.
         */
 
         * Pull out each argument and scan them.
         */
 

-       for (a = c1->c_f_args, i = 1; a != NULL; a = a->a_next, i++) {
-           args[i] = mh_xmalloc(BUFSIZ);
-           fmt_scan(a->a_fmt, args[i], BUFSIZ - 1, BUFSIZ, dat);
+       for (a = arglist_head, i = argp; a != NULL; a = a->a_next, i++) {
+           charstring_t scanl = charstring_create (BUFSIZ);
+
+           fmt_scan(a->a_fmt, scanl, BUFSIZ, dat, NULL);
+           args[i] = charstring_buffer_copy (scanl);
+           charstring_free (scanl);

            /*
             * fmt_scan likes to put a trailing newline at the end of the
             * format string.  If we have one, get rid of it.
             */
            s = strlen(args[i]);
            if (args[i][s - 1] == '\n')
            /*
             * fmt_scan likes to put a trailing newline at the end of the
             * format string.  If we have one, get rid of it.
             */
            s = strlen(args[i]);
            if (args[i][s - 1] == '\n')

-               args[i][s - 1] = '\0';
+               args[i][s - 1] = '\0';
+
+           if (mhldebug)
+               fprintf(stderr, "filterarg: fmt=\"%s\", output=\"%s\"\n",
+                       a->a_nfs, args[i]);

        }
 
        }
 

-       if (dup2(fdinput[0], STDIN_FILENO) < 0) {
+       if (dup2(fdinput[0], STDIN_FILENO) < 0) {

            adios("formatproc", "Unable to dup2() standard input");
        }
        if (dup2(fdoutput[1], STDOUT_FILENO) < 0) {
            adios("formatproc", "Unable to dup2() standard input");
        }
        if (dup2(fdoutput[1], STDOUT_FILENO) < 0) {