]> diplodocus.org Git - nmh/blobdiff - sbr/m_getfld.c
h/prototypes.h: Remove mhlsbr() prototype; no such function.
[nmh] / sbr / m_getfld.c
index fa6518359326b42994b01090d64826403b60cce8..940b3efc1bf3499ff9903f1258e69fbc0ee288a3 100644 (file)
@@ -1,15 +1,16 @@
-
-/*
- * m_getfld.c -- read/parse a message
+/* m_getfld.c -- read/parse a message
  *
  * This code is Copyright (c) 2002, 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, 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/mts.h>
-#include <h/utils.h>
+#include "h/mh.h"
+#include "m_getfld.h"
+#include "error.h"
+#include "h/mts.h"
+#include "h/utils.h"
+#include <inttypes.h>
 
 /*
    Purpose
 
 /*
    Purpose
      int edelimlen
      char *msg_delim
      int msg_style
      int edelimlen
      char *msg_delim
      int msg_style
-     int (*eom_action)(int)
 
    Usage
    =====
 
    Usage
    =====
-   m_getfld_state_t gstate = 0;
-      ...
-   int state = m_getfld (&gstate, ...);
-      ...
+   m_getfld_state_t gstate;
+
+   gstate = m_getfld_state_init(mailfp);
+   Perhaps m_getfld_track_filepos2(&gstate);
+   ...
+      state = m_getfld2(&gstate, ...);
+      ...Repeat until finished with mailfp.
    m_getfld_state_destroy (&gstate);
 
    The state is retained internally by gstate.  To reset its state to FLD:
    m_getfld_state_destroy (&gstate);
 
    The state is retained internally by gstate.  To reset its state to FLD:
@@ -91,9 +94,9 @@
    be parsed as well.  Unfortunately the speed issue finally caught up with
    us since this routine is at the very heart of MH.
 
    be parsed as well.  Unfortunately the speed issue finally caught up with
    us since this routine is at the very heart of MH.
 
-   To speed things up considerably, the routine Eom() was made an auxilary
+   To speed things up considerably, the routine Eom() was made an auxiliary
    function called by the macro eom().  Unless we are bursting a maildrop,
    function called by the macro eom().  Unless we are bursting a maildrop,
-   the eom() macro returns FALSE saying we aren't at the end of the
+   the eom() macro returns false saying we aren't at the end of the
    message.
 
    The next thing to do is to read the mts.conf file and initialize
    message.
 
    The next thing to do is to read the mts.conf file and initialize
    names are typically short (~8 char) and the loop that extracts them
    might terminate on a colon, newline or max width.  I considered
    using a Vax "scanc" to locate the end of the field followed by a
    names are typically short (~8 char) and the loop that extracts them
    might terminate on a colon, newline or max width.  I considered
    using a Vax "scanc" to locate the end of the field followed by a
-   "bcopy" but the routine call overhead on a Vax is too large for this
+   "memmove" but the routine call overhead on a Vax is too large for this
    to work on short names.  If Berkeley ever makes "inline" part of the
    C optimiser (so things like "scanc" turn into inline instructions) a
    change here would be worthwhile.
    to work on short names.  If Berkeley ever makes "inline" part of the
    C optimiser (so things like "scanc" turn into inline instructions) a
    change here would be worthwhile.
    so message bodies average at least a few hundred characters.
    Assuming your system uses reasonably sized stdio buffers (1K or
    more), this routine should be able to remove the body in large
    so message bodies average at least a few hundred characters.
    Assuming your system uses reasonably sized stdio buffers (1K or
    more), this routine should be able to remove the body in large
-   (>500 byte) chunks.  The makes the cost of a call to "bcopy"
+   (>500 byte) chunks.  The makes the cost of a call to "memmove"
    small but there is a premium on checking for the eom in packed
    maildrops.  The eom pattern is always a simple string so we can
    construct an efficient pattern matcher for it (e.g., a Vax "matchc"
    small but there is a premium on checking for the eom in packed
    maildrops.  The eom pattern is always a simple string so we can
    construct an efficient pattern matcher for it (e.g., a Vax "matchc"
 /*
  * static prototypes
  */
 /*
  * static prototypes
  */
-struct m_getfld_state;
-static int m_Eom (m_getfld_state_t, int);
-static char *matchc(int, char *, int, char *);
+static void Ungetc(m_getfld_state_t s);
+static int m_Eom (m_getfld_state_t);
 
 #define eom(c,s)       (s->msg_style != MS_DEFAULT && \
 
 #define eom(c,s)       (s->msg_style != MS_DEFAULT && \
-                        (((c) == *s->msg_delim && m_Eom(s,c)) || \
-                         (s->eom_action && (*s->eom_action)(c))))
+                        ((c) == *s->msg_delim && m_Eom(s)))
+
+/*
+ * Maildrop styles
+ */
+#define        MS_DEFAULT      0       /* default (one msg per file) */
+#define        MS_UNKNOWN      1       /* type not known yet         */
+#define        MS_MBOX         2       /* Unix-style "from" lines    */
+#define        MS_MMDF         3       /* string MMDF_DELIM          */
 
 /* This replaces the old approach, with its direct access to stdio
  * internals.  It uses one fread() to load a buffer that we manage.
 
 /* This replaces the old approach, with its direct access to stdio
  * internals.  It uses one fread() to load a buffer that we manage.
@@ -219,59 +228,94 @@ static char *matchc(int, char *, int, char *);
  * separate messages in a maildrop, such as mbox "From ".
  *
  * Some of the tests in the test suite assume a MSG_INPUT_SIZE
  * separate messages in a maildrop, such as mbox "From ".
  *
  * Some of the tests in the test suite assume a MSG_INPUT_SIZE
- * of 4096.
+ * of 8192.
  */
  */
-#define MSG_INPUT_SIZE 4096
+#define MSG_INPUT_SIZE NMH_BUFSIZ
 #define MAX_DELIMITER_SIZE 5
 
 struct m_getfld_state {
 #define MAX_DELIMITER_SIZE 5
 
 struct m_getfld_state {
+    /* The file to read from;  I/O block.  Caller keeps passing it after
+     * initialisation due to historic interface so it keeps getting
+     * updated, presumably to the same value. */
+    FILE *iob;
+
+    /* Holds content of iob. */
     char msg_buf[2 * MSG_INPUT_SIZE + MAX_DELIMITER_SIZE];
     char msg_buf[2 * MSG_INPUT_SIZE + MAX_DELIMITER_SIZE];
+    /* Points to the next byte to read from msg_buf. */
     char *readpos;
     char *readpos;
-    char *end;  /* One past the last character read in. */
-    /* The following support tracking of the read position in the
-       input file stream so that callers can interleave m_getfld()
-       calls with ftell() and fseek().  ytes_read replaces the old
-       m_getfld() msg_count global.  last_caller_pos is stored when
-       leaving m_getfld()/m_unknown(), then checked on the next entry.
-       last_internal_pos is used to remember the position used
-       internally by m_getfld() (read_more(), actually). */
+    /* Points to just after the last valid byte in msg_buf.  If readpos
+     * equals end then msg_buf is empty. */
+    char *end;
+
+    /* Whether the caller intends to ftell(3)/fseek(3) iob's position,
+     * and thus whether m_getfld() needs to detect that and compensate. */
+    int track_filepos;
+    /* Position in iob given what's been consumed ready for returning to
+     * the caller.  Further than this may have been read into msg_buf. */
+    off_t total_bytes_read;
+    /* Bytes of iob consumed during this call. */
     off_t bytes_read;
     off_t bytes_read;
-    off_t total_bytes_read; /* by caller, not necessarily from input file */
+    /* What fseeko(3) tells us iob's position is having just explicitly
+     * set it to total_bytes_read.  Surely always the same? */
     off_t last_caller_pos;
     off_t last_caller_pos;
+    /* Saved position in iob from filling msg_buf, prior to returning. */
     off_t last_internal_pos;
     off_t last_internal_pos;
-    FILE *iob;
 
 
-    char **pat_map;
+    /* One of the MS_* macros tracking the type of iob's content and
+     * thus if it's a single email, or several with delimeters.  Default
+     * is MS_DEFAULT. */
     int msg_style;
     int msg_style;
-    /*
-     * The "full" delimiter string for a packed maildrop consists
-     * of a newline followed by the actual delimiter.  E.g., the
-     * full string for a Unix maildrop would be: "\n\nFrom ".
-     * "Fdelim" points to the start of the full string and is used
-     * in the BODY case of the main routine to search the buffer for
-     * a possible eom.  Msg_delim points to the first character of
-     * the actual delim. string (i.e., fdelim+1).  Edelim
-     * points to the 2nd character of actual delimiter string.  It
-     * is used in m_Eom because the first character of the string
-     * has been read and matched before m_Eom is called.
-     */
+
+    /* The message delimeter if iob has multiple emails, else NULL.  For
+     * MS_MBOX it's the string that separates two emails, "\nFrom ",
+     * i.e. the terminating blank line of the previous email, and the
+     * starting From_ line of the next, but for MS_MMDF it's
+     * "\001\001\001\001\n" that may start or terminate an email. */
     char *msg_delim;
     char *msg_delim;
-    char *fdelim;
+    /* The last non-NUL char of msg_delim. */
     char *delimend;
     char *delimend;
+    /* When searching for msg_delim after an email, it's only of
+     * interest at the start of the line, i.e. when preceded by a
+     * linefeed.  fdelim points to msg_delim[-1] that contains '\n' so
+     * it can be used as the needle. */
+    char *fdelim;
+    /* strlen(fdelim). */
     int fdelimlen;
     int fdelimlen;
+    /* The second char of msg_delim.  Used when the first char has
+     * already been matched to test the rest. */
     char *edelim;
     char *edelim;
+    /* strlen(edelim). */
     int edelimlen;
     int edelimlen;
-    int (*eom_action)(int);
+    /* The relationship between all of these pointers and lengths for
+     * the two possible msg_delim values.
+     *
+     *     "\0\n\nFrom \0"   9              "\0\n\001\001\001\001\n\0"   8
+     *         | ||   |                         |   |   |         |
+     *         | ||   s->delimend               |   |   |         s->delimend
+     *         | ||                             |   |   |
+     *         | |s->edelim  s->edelimlen=5     |   |   s->edelim  s->edelimlen=4
+     *         | |                              |   |
+     *         | s->msg_delim                   |   s->msg_delim
+     *         |                                |
+     *         s->fdelim  s->fdelimlen=7        s->fdelim  s->fdelimlen=6
+     */
+
+    /* Maps all the bytes of msg_delim, apart from the last two,
+     * including the NUL, onto the last position in msg_delim where they
+     * occur.  Bytes not present are NULL. */
+    char **pat_map;
+
+    /* The parser's current state.  Also returned to the caller, amongst
+     * other possible values, to indicate the token consumed.  One of
+     * FLD, FLDPLUS, BODY, or FILEEOF. */
     int state;
     int state;
-    int track_filepos;
 };
 
 };
 
-static
-void
-m_getfld_state_init (m_getfld_state_t *gstate, FILE *iob) {
+m_getfld_state_t m_getfld_state_init(FILE *iob)
+{
     m_getfld_state_t s;
 
     m_getfld_state_t s;
 
-    s = *gstate = (m_getfld_state_t) mh_xmalloc(sizeof (struct m_getfld_state));
+    NEW(s);
     s->readpos = s->end = s->msg_buf;
     s->bytes_read = s->total_bytes_read = 0;
     s->last_caller_pos = s->last_internal_pos = 0;
     s->readpos = s->end = s->msg_buf;
     s->bytes_read = s->total_bytes_read = 0;
     s->last_caller_pos = s->last_internal_pos = 0;
@@ -281,14 +325,16 @@ m_getfld_state_init (m_getfld_state_t *gstate, FILE *iob) {
     s->msg_delim = "";
     s->fdelim = s->delimend = s->edelim = NULL;
     s->fdelimlen = s->edelimlen = 0;
     s->msg_delim = "";
     s->fdelim = s->delimend = s->edelim = NULL;
     s->fdelimlen = s->edelimlen = 0;
-    s->eom_action = NULL;
     s->state = FLD;
     s->track_filepos = 0;
     s->state = FLD;
     s->track_filepos = 0;
+
+    return s;
 }
 
 }
 
-/* scan() needs to force a state an initial state of FLD for each message. */
+/* scan() needs to force an initial state of FLD for each message. */
 void
 void
-m_getfld_state_reset (m_getfld_state_t *gstate) {
+m_getfld_state_reset (m_getfld_state_t *gstate)
+{
     if (*gstate) {
        (*gstate)->state = FLD;
     }
     if (*gstate) {
        (*gstate)->state = FLD;
     }
@@ -298,15 +344,28 @@ m_getfld_state_reset (m_getfld_state_t *gstate) {
    calls, m_getfld() must keep track of the file position.  The caller
    must use this function to inform m_getfld(). */
 void
    calls, m_getfld() must keep track of the file position.  The caller
    must use this function to inform m_getfld(). */
 void
-m_getfld_track_filepos (m_getfld_state_t *gstate, FILE *iob) {
+m_getfld_track_filepos (m_getfld_state_t *gstate, FILE *iob)
+{
     if (! *gstate) {
     if (! *gstate) {
-       m_getfld_state_init (gstate, iob);
+       *gstate = m_getfld_state_init(iob);
     }
 
     (*gstate)->track_filepos = 1;
 }
 
     }
 
     (*gstate)->track_filepos = 1;
 }
 
-void m_getfld_state_destroy (m_getfld_state_t *gstate) {
+/* m_getfld_track_filepos() with the existing iob. */
+void
+m_getfld_track_filepos2(m_getfld_state_t *gstate)
+{
+    if (!*gstate)
+       die("m_getfld_track_filepos2 without gstate");
+
+    m_getfld_track_filepos(gstate, (*gstate)->iob);
+}
+
+void
+m_getfld_state_destroy (m_getfld_state_t *gstate)
+{
     m_getfld_state_t s = *gstate;
 
     if (s) {
     m_getfld_state_t s = *gstate;
 
     if (s) {
@@ -349,12 +408,14 @@ void m_getfld_state_destroy (m_getfld_state_t *gstate) {
 
 
 static void
 
 
 static void
-enter_getfld (m_getfld_state_t *gstate, FILE *iob) {
+enter_getfld (m_getfld_state_t *gstate, FILE *iob)
+{
     m_getfld_state_t s;
     m_getfld_state_t s;
-    off_t pos = ftello (iob);
+    off_t pos;
+    off_t pos_movement;
 
     if (! *gstate) {
 
     if (! *gstate) {
-       m_getfld_state_init (gstate, iob);
+       *gstate = m_getfld_state_init(iob);
     }
     s = *gstate;
     s->bytes_read = 0;
     }
     s = *gstate;
     s->bytes_read = 0;
@@ -367,74 +428,96 @@ enter_getfld (m_getfld_state_t *gstate, FILE *iob) {
        readpos shift code being currently unused. */
     s->iob = iob;
 
        readpos shift code being currently unused. */
     s->iob = iob;
 
-    if (s->track_filepos  &&  (pos != 0  ||  s->last_internal_pos != 0)) {
-       if (s->last_internal_pos == 0) {
-           s->total_bytes_read = pos;
-       } else {
-           off_t pos_movement = pos - s->last_caller_pos; /* Can be < 0. */
-
-           if (pos_movement == 0) {
-               pos = s->last_internal_pos;
-           } else {
-               /* The current file stream position differs from the
-                  last one, so caller must have called ftell/o().
-                  Or, this is the first call and the file position
-                  was not at 0. */
-
-               if (s->readpos + pos_movement >= s->msg_buf  &&
-                   s->readpos + pos_movement < s->end) {
-                   /* This is currently unused.  It could be used by
-                      parse_mime() if it was changed to use a global
-                      m_getfld_state. */
-                   /* We can shift readpos and remain within the
-                      bounds of msg_buf. */
-                   s->readpos += pos_movement;
-                   s->total_bytes_read += pos_movement;
-                   pos = s->last_internal_pos;
-               } else {
-                   size_t num_read;
-
-                   /* This seek skips past an integral number of
-                      chunks of size MSG_INPUT_SIZE. */
-                   fseeko (iob, pos/MSG_INPUT_SIZE * MSG_INPUT_SIZE, SEEK_SET);
-                   num_read = fread (s->msg_buf, 1, MSG_INPUT_SIZE, iob);
-                   s->readpos = s->msg_buf  +  pos % MSG_INPUT_SIZE;
-                   s->end = s->msg_buf + num_read;
-                   s->total_bytes_read = pos;
-               }
-           }
+    if (!s->track_filepos)
+        return;
 
 
-           fseeko (iob, pos, SEEK_SET);
-       }
+    if ((pos = ftello(iob)) == -1)
+        adios("getfld's iob", "failed to get offset on entry");
+    if (pos == 0 && s->last_internal_pos == 0)
+        return;
+
+    if (s->last_internal_pos == 0) {
+        s->total_bytes_read = pos;
+        return;
+    }
+
+    pos_movement = pos - s->last_caller_pos; /* Can be < 0. */
+    if (pos_movement == 0) {
+        pos = s->last_internal_pos;
+    } else {
+        /* The current file stream position differs from the
+           last one, so caller must have called ftell/o().
+           Or, this is the first call and the file position
+           was not at 0. */
+
+        if (s->readpos + pos_movement >= s->msg_buf  &&
+            s->readpos + pos_movement < s->end) {
+            /* This is currently unused.  It could be used by
+               parse_mime() if it was changed to use a global
+               m_getfld_state. */
+            /* We can shift readpos and remain within the
+               bounds of msg_buf. */
+            s->readpos += pos_movement;
+            s->total_bytes_read += pos_movement;
+            pos = s->last_internal_pos;
+        } else {
+            off_t off;
+            size_t num_read;
+
+            /* This seek skips past an integral number of
+               chunks of size MSG_INPUT_SIZE. */
+            off = pos / MSG_INPUT_SIZE * MSG_INPUT_SIZE;
+            if (fseeko(iob, off, SEEK_SET) == -1)
+                adios("getfld's iob", "failed to set offset to skip: "
+                    "%" PRIdMAX, (intmax_t)off);
+            num_read = fread (s->msg_buf, 1, MSG_INPUT_SIZE, iob);
+            s->readpos = s->msg_buf  +  pos % MSG_INPUT_SIZE;
+            s->end = s->msg_buf + num_read;
+            s->total_bytes_read = pos;
+        }
     }
     }
+
+    if (fseeko(iob, pos, SEEK_SET) == -1)
+        adios("getfld's iob", "failed to set offset on entry: %" PRIdMAX,
+            (intmax_t)pos);
 }
 
 static void
 }
 
 static void
-leave_getfld (m_getfld_state_t s) {
+leave_getfld (m_getfld_state_t s)
+{
     s->total_bytes_read += s->bytes_read;
 
     if (s->track_filepos) {
        /* Save the internal file position that we use for the input buffer. */
     s->total_bytes_read += s->bytes_read;
 
     if (s->track_filepos) {
        /* Save the internal file position that we use for the input buffer. */
-       s->last_internal_pos = ftello (s->iob);
+        if ((s->last_internal_pos = ftello(s->iob)) == -1)
+            adios("getfld's iob", "failed to get offset before seek");
 
        /* Set file stream position so that callers can use ftell(). */
 
        /* Set file stream position so that callers can use ftell(). */
-       fseeko (s->iob, s->total_bytes_read, SEEK_SET);
-       s->last_caller_pos = ftello (s->iob);
+        if (fseeko(s->iob, s->total_bytes_read, SEEK_SET) == -1)
+            adios("getfld's iob", "failed to set offset: %" PRIdMAX,
+                (intmax_t)s->total_bytes_read);
+
+        s->last_caller_pos = s->total_bytes_read;
     }
 }
 
 static size_t
     }
 }
 
 static size_t
-read_more (m_getfld_state_t s) {
-    /* Retain at least edelimlen characters that have already been
-       read so that we can back up to them in m_Eom(). */
-    ssize_t retain = s->edelimlen;
+read_more (m_getfld_state_t s)
+{
+    /* Retain at least edelimlen characters that have already been read,
+       if at least edelimlen have been read, so that we can back up to them
+       in m_Eom(). */
+    ssize_t retain = s->end - s->msg_buf < s->edelimlen ? 0 : s->edelimlen;
     size_t num_read;
 
     size_t num_read;
 
-    if (retain < s->end - s->readpos) retain = s->end - s->readpos;
-    assert (retain <= s->readpos - s->msg_buf);
+    if (retain > 0) {
+        if (retain < s->end - s->readpos)
+            retain = s->end - s->readpos;
+        assert (retain <= s->readpos - s->msg_buf);
 
 
-    /* Move what we want to retain at end of the buffer to the beginning. */
-    memmove (s->msg_buf, s->readpos - retain, retain);
+        /* Move what we want to retain at end of the buffer to the beginning. */
+        memmove (s->msg_buf, s->readpos - retain, retain);
+    }
 
     s->readpos = s->msg_buf + retain;
     num_read = fread (s->readpos, 1, MSG_INPUT_SIZE, s->iob);
 
     s->readpos = s->msg_buf + retain;
     num_read = fread (s->readpos, 1, MSG_INPUT_SIZE, s->iob);
@@ -443,44 +526,42 @@ read_more (m_getfld_state_t s) {
     return num_read;
 }
 
     return num_read;
 }
 
-/* The return values of the following functions are a bit
-   subtle.  They can return 0x00 - 0xff as a valid character,
-   but EOF is typically 0xffffffff. */
+/* Return the next character consumed from the input, fetching more of
+ * the input for the buffer if required, or EOF on end of file. */
 static int
 static int
-Getc (m_getfld_state_t s) {
-    if (s->end - s->readpos < 1) {
-       if (read_more (s) == 0) {
-           /* Pretend that we read a character.  That's what stdio does. */
-           ++s->readpos;
-           return EOF;
-       }
-    }
+Getc (m_getfld_state_t s)
+{
+    if ((s->end - s->readpos < 1 && read_more (s) == 0) ||
+        s->readpos >= s->end)
+        return EOF;
 
 
-    ++s->bytes_read;
-    return s->readpos < s->end  ?  (unsigned char) *s->readpos++  :  EOF;
+    s->bytes_read++;
+    return (unsigned char)*s->readpos++;
 }
 
 }
 
+/* Return the next character that Getc() would return, which may be EOF. */
 static int
 static int
-Peek (m_getfld_state_t s) {
-    if (s->end - s->readpos < 1) {
-       if (read_more (s) == 0) {
-           /* Pretend that we read a character.  That's what stdio does. */
-           ++s->readpos;
-           return EOF;
-       }
-    }
+Peek (m_getfld_state_t s)
+{
+    int c;
+
+    c = Getc(s);
+    if (c != EOF)
+        Ungetc(s);
 
 
-    return s->readpos < s->end  ?  (unsigned char) *s->readpos  :  EOF;
+    return c;
 }
 
 }
 
-static int
-Ungetc (int c, m_getfld_state_t s) {
-    if (s->readpos == s->msg_buf) {
-       return EOF;
-    } else {
-       --s->bytes_read;
-       return *--s->readpos = (unsigned char) c;
-    }
+/* If there's room, undo the consumption of one character from msg_buf,
+ * rewinding so it's read next, else die. */
+static void
+Ungetc(m_getfld_state_t s)
+{
+    if (s->readpos == s->msg_buf)
+        die("Ungetc() at start of message buffer.");
+
+    s->readpos--;
+    s->bytes_read--;
 }
 
 
 }
 
 
@@ -489,26 +570,24 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
           FILE *iob)
 {
     m_getfld_state_t s;
           FILE *iob)
 {
     m_getfld_state_t s;
-    register char *cp;
-    register int max, n, c;
+    char *cp;
+    int max, n, c;
 
     enter_getfld (gstate, iob);
     s = *gstate;
 
 
     enter_getfld (gstate, iob);
     s = *gstate;
 
-    if ((c = Getc(s)) < 0) {
+    if ((c = Getc(s)) == EOF) {
        *bufsz = *buf = 0;
        leave_getfld (s);
        return s->state = FILEEOF;
     }
     if (eom (c, s)) {
        *bufsz = *buf = 0;
        leave_getfld (s);
        return s->state = FILEEOF;
     }
     if (eom (c, s)) {
-       if (! s->eom_action) {
-           /* flush null messages */
-           while ((c = Getc(s)) >= 0 && eom (c, s))
-               ;
+       /* flush null messages */
+       while ((c = Getc(s)) != EOF && eom (c, s))
+           ;
 
 
-           if (c >= 0)
-               Ungetc(c, s);
-       }
+       if (c != EOF)
+            Ungetc(s);
        *bufsz = *buf = 0;
        leave_getfld (s);
        return s->state = FILEEOF;
        *bufsz = *buf = 0;
        leave_getfld (s);
        return s->state = FILEEOF;
@@ -518,16 +597,15 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
        case FLD:
            if (c == '\n' || c == '-') {
                /* we hit the header/body separator */
        case FLD:
            if (c == '\n' || c == '-') {
                /* we hit the header/body separator */
-               while (c != '\n' && (c = Getc(s)) >= 0) continue;
-
-               if (c < 0 || (c = Getc(s)) < 0 || eom (c, s)) {
-                   if (! s->eom_action) {
-                       /* flush null messages */
-                       while ((c = Getc(s)) >= 0 && eom (c, s))
-                           ;
-                       if (c >= 0)
-                           Ungetc(c, s);
-                   }
+               while (c != '\n' && (c = Getc(s)) != EOF)
+                    ;
+
+               if (c == EOF || (c = Getc(s)) == EOF || eom (c, s)) {
+                   /* flush null messages */
+                   while ((c = Getc(s)) != EOF && eom (c, s))
+                       ;
+                   if (c != EOF)
+                        Ungetc(s);
                    *bufsz = *buf = 0;
                    leave_getfld (s);
                    return s->state = FILEEOF;
                    *bufsz = *buf = 0;
                    leave_getfld (s);
                    return s->state = FILEEOF;
@@ -558,7 +636,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
                int next_char;
                if (c == EOF  ||  (next_char = Peek (s)) == EOF) {
                    *bufsz = *cp = *buf = 0;
                int next_char;
                if (c == EOF  ||  (next_char = Peek (s)) == EOF) {
                    *bufsz = *cp = *buf = 0;
-                   advise (NULL, "eof encountered in field \"%s\"", name);
+                   inform("eof encountered in field \"%s\"", name);
                    leave_getfld (s);
                    return s->state = FMTERR;
                }
                    leave_getfld (s);
                    return s->state = FMTERR;
                }
@@ -584,25 +662,29 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
                if (*bufsz < n + 1) {
                    /* No, it can't.  Oh well, guess we'll blow up. */
                    *bufsz = *cp = *buf = 0;
                if (*bufsz < n + 1) {
                    /* No, it can't.  Oh well, guess we'll blow up. */
                    *bufsz = *cp = *buf = 0;
-                   advise (NULL, "eol encountered in field \"%s\"", name);
+                   inform("eol encountered in field \"%s\"", name);
                    s->state = FMTERR;
                    break;
                }
                memcpy (buf, name, n - 1);
                buf[n - 1] = '\n';
                buf[n] = '\0';
                    s->state = FMTERR;
                    break;
                }
                memcpy (buf, name, n - 1);
                buf[n - 1] = '\n';
                buf[n] = '\0';
+                /* Indicate this wasn't a header field using a character
+                   that can't appear in a header field. */
+                name[0] = ':';
                /* The last character read was '\n'.  s->bytes_read
                   (and n) include that, but it was not put into the
                   name array in the for loop above.  So subtract 1. */
                *bufsz = --s->bytes_read;  /* == n - 1 */
                leave_getfld (s);
                return s->state = BODY;
                /* The last character read was '\n'.  s->bytes_read
                   (and n) include that, but it was not put into the
                   name array in the for loop above.  So subtract 1. */
                *bufsz = --s->bytes_read;  /* == n - 1 */
                leave_getfld (s);
                return s->state = BODY;
-           } else if (max <= n) {
+           }
+            if (max <= n) {
                /* By design, the loop above discards the last character
                    it had read.  It's in c, use it. */
                *cp++ = c;
                *bufsz = *cp = *buf = 0;
                /* By design, the loop above discards the last character
                    it had read.  It's in c, use it. */
                *cp++ = c;
                *bufsz = *cp = *buf = 0;
-               advise (NULL, "field name \"%s\" exceeds %d bytes", name,
+               inform("field name \"%s\" exceeds %d bytes", name,
                        NAMESZ - 2);
                s->state = LENERR;
                break;
                        NAMESZ - 2);
                s->state = LENERR;
                break;
@@ -612,7 +694,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
            while (isspace ((unsigned char) *--cp) && cp >= name) continue;
            *++cp = 0;
            /* readpos points to the first character of the field body. */
            while (isspace ((unsigned char) *--cp) && cp >= name) continue;
            *++cp = 0;
            /* readpos points to the first character of the field body. */
-           /* fall through */
+           /* FALLTHRU */
 
        case FLDPLUS: {
            /*
 
        case FLDPLUS: {
            /*
@@ -620,17 +702,17 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
             * characters up to the end of this field (newline
             * followed by non-blank) or bufsz-1 characters.
             */
             * characters up to the end of this field (newline
             * followed by non-blank) or bufsz-1 characters.
             */
-           int finished;
-
            cp = buf;
            max = *bufsz-1;
            n = 0;
            cp = buf;
            max = *bufsz-1;
            n = 0;
-           for (finished = 0; ! finished; ) {
+           for (bool finished = false; !finished; ) {
                while (c != '\n'  &&  c != EOF  &&  n++ < max) {
                while (c != '\n'  &&  c != EOF  &&  n++ < max) {
-                   if ((c = Getc (s)) != EOF) { *cp++ = c; }
+                   if ((c = Getc (s)) != EOF)
+                        *cp++ = c;
                }
 
                }
 
-               if (c != EOF) c = Peek (s);
+               if (c != EOF)
+                    c = Peek (s);
                if (max < n) {
                    /* The dest buffer is full.  Need to back the read
                       pointer up by one because when m_getfld() is
                if (max < n) {
                    /* The dest buffer is full.  Need to back the read
                       pointer up by one because when m_getfld() is
@@ -643,14 +725,14 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
                        --s->bytes_read;
                    }
                    s->state = FLDPLUS;
                        --s->bytes_read;
                    }
                    s->state = FLDPLUS;
-                   finished = 1;
+                   finished = true;
                } else if (c != ' '  &&  c != '\t') {
                    /* The next character is not folded whitespace, so
                       prepare to move on to the next field.  It's OK
                       if c is EOF, it will be handled on the next
                       call to m_getfld (). */
                    s->state = FLD;
                } else if (c != ' '  &&  c != '\t') {
                    /* The next character is not folded whitespace, so
                       prepare to move on to the next field.  It's OK
                       if c is EOF, it will be handled on the next
                       call to m_getfld (). */
                    s->state = FLD;
-                   finished = 1;
+                   finished = true;
                } else {
                    /* Folded header field, continues on the next line. */
                }
                } else {
                    /* Folded header field, continues on the next line. */
                }
@@ -667,10 +749,11 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
             */
            char *bp;
 
             */
            char *bp;
 
+            name[0] = '\0';
            max = *bufsz-1;
            /* Back up and store the current position. */
            bp = --s->readpos;
            max = *bufsz-1;
            /* Back up and store the current position. */
            bp = --s->readpos;
-           c = s->end - s->readpos < max  ?  s->end - s->readpos  :  max;
+            c = min(s->end - s->readpos, max);
            if (s->msg_style != MS_DEFAULT && c > 1) {
                /*
                 * packed maildrop - only take up to the (possible)
            if (s->msg_style != MS_DEFAULT && c > 1) {
                /*
                 * packed maildrop - only take up to the (possible)
@@ -686,7 +769,10 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
                 */
                char *ep;
 
                 */
                char *ep;
 
-               if ((ep = matchc( s->fdelimlen, s->fdelim, c, bp )))
+                if ((ep = memmem(bp, c, s->fdelim, s->fdelimlen)))
+                    /* Plus one to nab the '\n' that starts fdelim as
+                     * that ends the previous line;  it isn't part of
+                     * msg_delim. */
                    c = ep - bp + 1;
                else {
                    /*
                    c = ep - bp + 1;
                else {
                    /*
@@ -704,7 +790,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
                     */
                    char *sp;
 
                     */
                    char *sp;
 
-                   ep = bp + c - 1;
+                    ep = bp + c - 1; /* The last byte. */
                    if ((sp = s->pat_map[(unsigned char) *ep])) {
                        do {
                            /* This if() is true unless (a) the buffer is too
                    if ((sp = s->pat_map[(unsigned char) *ep])) {
                        do {
                            /* This if() is true unless (a) the buffer is too
@@ -756,7 +842,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
         }
 
        default:
         }
 
        default:
-           adios (NULL, "m_getfld() called with bogus state of %d", s->state);
+           die("m_getfld() called with bogus state of %d", s->state);
     }
 
     *cp = 0;
     }
 
     *cp = 0;
@@ -766,22 +852,33 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz,
 }
 
 
 }
 
 
+/* m_getfld() with the existing iob. */
+int
+m_getfld2(m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz)
+{
+    if (!*gstate)
+       die("m_getfld2 without gstate");
+
+    return m_getfld(gstate, name, buf, bufsz, (*gstate)->iob);
+}
+
+
 void
 m_unknown(m_getfld_state_t *gstate, FILE *iob)
 {
     m_getfld_state_t s;
 void
 m_unknown(m_getfld_state_t *gstate, FILE *iob)
 {
     m_getfld_state_t s;
-    register int c;
+    int c;
     char text[MAX_DELIMITER_SIZE];
     char from[] = "From ";
     char text[MAX_DELIMITER_SIZE];
     char from[] = "From ";
-    register char *cp;
-    register char *delimstr;
+    char *cp;
+    char *delimstr;
     unsigned int i;
 
     enter_getfld (gstate, iob);
     s = *gstate;
 
 /*
     unsigned int i;
 
     enter_getfld (gstate, iob);
     s = *gstate;
 
 /*
- * Figure out what the message delimitter string is for this
+ * Figure out what the message delimiter string is for this
  * maildrop.  (This used to be part of m_Eom but I didn't like
  * the idea of an "if" statement that could only succeed on the
  * first call to m_Eom getting executed on each call, i.e., at
  * maildrop.  (This used to be part of m_Eom but I didn't like
  * the idea of an "if" statement that could only succeed on the
  * first call to m_Eom getting executed on each call, i.e., at
@@ -796,119 +893,129 @@ m_unknown(m_getfld_state_t *gstate, FILE *iob)
     s->msg_style = MS_UNKNOWN;
 
     for (i = 0, cp = text; i < sizeof text; ++i, ++cp) {
     s->msg_style = MS_UNKNOWN;
 
     for (i = 0, cp = text; i < sizeof text; ++i, ++cp) {
-       if ((signed char) (*cp = Getc (s)) == EOF) {
+       if ((c = Getc (s)) == EOF) {
+           *cp = '\0';
            break;
        }
            break;
        }
+        *cp = c;
     }
 
     if (i == sizeof from-1  &&  strncmp (text, "From ", sizeof from-1) == 0) {
        s->msg_style = MS_MBOX;
        delimstr = "\nFrom ";
     }
 
     if (i == sizeof from-1  &&  strncmp (text, "From ", sizeof from-1) == 0) {
        s->msg_style = MS_MBOX;
        delimstr = "\nFrom ";
-       while ((c = Getc (s)) != '\n' && c >= 0) continue;
+       while ((c = Getc(s)) != EOF && c != '\n')
+            ;
     } else {
        /* not a Unix style maildrop */
        s->readpos -= s->bytes_read;
        s->bytes_read = 0;
     } else {
        /* not a Unix style maildrop */
        s->readpos -= s->bytes_read;
        s->bytes_read = 0;
-       delimstr = mmdlm2;
+       delimstr = MMDF_DELIM;
        s->msg_style = MS_MMDF;
     }
        s->msg_style = MS_MMDF;
     }
+
+    /*     "\nFrom \0"   7                  "\001\001\001\001\n\0"  6
+     *       |                                  |
+     *       delimstr   c=6                     delimstr   c=5
+     */
     c = strlen (delimstr);
     c = strlen (delimstr);
-    s->fdelim = mh_xmalloc (c + 3);
+    s->fdelim = mh_xmalloc (c + 3); /* \0, \n, delimstr, \0 */
     *s->fdelim++ = '\0';
     *s->fdelim = '\n';
     *s->fdelim++ = '\0';
     *s->fdelim = '\n';
-    s->msg_delim = s->fdelim+1;
-    s->edelim = s->msg_delim+1;
     s->fdelimlen = c + 1;
     s->fdelimlen = c + 1;
-    s->edelimlen = c - 1; /* == strlen (delimstr) */
+    s->msg_delim = s->fdelim+1;
     strcpy (s->msg_delim, delimstr);
     strcpy (s->msg_delim, delimstr);
+    s->edelim = s->msg_delim+1;
+    s->edelimlen = c - 1;
     s->delimend = s->msg_delim + s->edelimlen;
     if (s->edelimlen <= 1)
     s->delimend = s->msg_delim + s->edelimlen;
     if (s->edelimlen <= 1)
-       adios (NULL, "maildrop delimiter must be at least 2 bytes");
+       die("maildrop delimiter must be at least 2 bytes");
+
     /*
      * build a Boyer-Moore end-position map for the matcher in m_getfld.
      * N.B. - we don't match just the first char (since it's the newline
      * separator) or the last char (since the matchc would have found it
      * if it was a real delim).
      */
     /*
      * build a Boyer-Moore end-position map for the matcher in m_getfld.
      * N.B. - we don't match just the first char (since it's the newline
      * separator) or the last char (since the matchc would have found it
      * if it was a real delim).
      */
-    s->pat_map = (char **) calloc (256, sizeof(char *));
+    s->pat_map = mh_xcalloc (256, sizeof(char *));
 
     for (cp = s->fdelim + 1; cp < s->delimend; cp++ )
        s->pat_map[(unsigned char)*cp] = cp;
 
     if (s->msg_style == MS_MMDF) {
        /* flush extra msg hdrs */
 
     for (cp = s->fdelim + 1; cp < s->delimend; cp++ )
        s->pat_map[(unsigned char)*cp] = cp;
 
     if (s->msg_style == MS_MMDF) {
        /* flush extra msg hdrs */
-       while ((c = Getc(s)) >= 0 && eom (c, s))
+       while ((c = Getc(s)) != EOF && eom (c, s))
            ;
            ;
-       if (c >= 0)
-           Ungetc(c, s);
+       if (c != EOF)
+            Ungetc(s);
     }
 
     leave_getfld (s);
 }
 
 
     }
 
     leave_getfld (s);
 }
 
 
+/* m_unknown() with the existing iob. */
+void
+m_unknown2(m_getfld_state_t *gstate)
+{
+    if (!*gstate)
+       die("m_unknown2 without gstate");
+
+    m_unknown(gstate, (*gstate)->iob);
+}
+
+
 /*
  * test for msg delimiter string
  */
 
 static int
 /*
  * test for msg delimiter string
  */
 
 static int
-m_Eom (m_getfld_state_t s, int c)
+m_Eom (m_getfld_state_t s)
 {
 {
-    register int i;
+    int i;
     char text[MAX_DELIMITER_SIZE];
     char *cp;
     char text[MAX_DELIMITER_SIZE];
     char *cp;
+    int adjust = 1;
 
     for (i = 0, cp = text; i < s->edelimlen; ++i, ++cp) {
 
     for (i = 0, cp = text; i < s->edelimlen; ++i, ++cp) {
-       if ((signed char) (*cp = Getc (s)) == EOF) {
+       int c2;
+
+       if ((c2 = Getc (s)) == EOF) {
+           *cp = '\0';
            break;
        }
            break;
        }
+       *cp = c2;
     }
 
     if (i != s->edelimlen  ||
         strncmp (text, (char *)s->edelim, s->edelimlen)) {
     }
 
     if (i != s->edelimlen  ||
         strncmp (text, (char *)s->edelim, s->edelimlen)) {
-       if (i == 0 && s->msg_style == MS_MBOX)
+       if (i == 0 && s->msg_style == MS_MBOX) {
            /* the final newline in the (brain damaged) unix-format
            /* the final newline in the (brain damaged) unix-format
-            * maildrop is part of the delimitter - delete it.
+            * maildrop is part of the delimiter - delete it.
             */
            return 1;
             */
            return 1;
+       }
+
+       if (i <= 2  &&  s->msg_style == MS_MBOX  &&
+           i != s->edelimlen  &&  ! strncmp(text, s->fdelim, i)) {
+           /* If all or part of fdelim appeared at the end of the file,
+              back up even more so that the bytes are included in the
+              message. */
+           adjust = 2;
+       }
 
        /* Did not find delimiter, so restore the read position.
           Note that on input, a character had already been read
           with Getc().  It will be unget by m_getfld () on return. */
 
        /* Did not find delimiter, so restore the read position.
           Note that on input, a character had already been read
           with Getc().  It will be unget by m_getfld () on return. */
-       s->readpos -= s->bytes_read - 1;
-       s->bytes_read = 1;
+       s->readpos -= s->bytes_read - adjust;
+       s->bytes_read = adjust;
        return 0;
     }
 
     if (s->msg_style == MS_MBOX) {
        return 0;
     }
 
     if (s->msg_style == MS_MBOX) {
-       while ((c = Getc (s)) != '\n')
-           if (c < 0)
-               break;
+       int c;
+       while ((c = Getc(s)) != EOF && c != '\n')
+            ;
     }
 
     return 1;
 }
     }
 
     return 1;
 }
-
-
-static char *
-matchc(int patln, char *pat, int strln, char *str)
-{
-       register char *es = str + strln - patln;
-       register char *sp;
-       register char *pp;
-       register char *ep = pat + patln;
-       register char pc = *pat++;
-
-       for(;;) {
-               while (pc != *str++)
-                       if (str > es)
-                               return 0;
-               if (str > es+1)
-                       return 0;
-               sp = str; pp = pat;
-               while (pp < ep && *sp++ == *pp)
-                       pp++;
-               if (pp >= ep)
-                       return --str;
-       }
-}