* 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
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:
To speed things up considerably, the routine Eom() was made an auxiliary
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
/*
* static prototypes
*/
+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 && \
((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.
*
#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];
+ /* Points to the next byte to read from msg_buf. */
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(). bytes_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 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;
+ /* Saved position in iob from filling msg_buf, prior to returning. */
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;
- /*
- * 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 *fdelim;
+ /* The last non-NUL char of msg_delim. */
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;
+ /* The second char of msg_delim. Used when the first char has
+ * already been matched to test the rest. */
char *edelim;
+ /* strlen(edelim). */
int edelimlen;
+ /* 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 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;
NEW(s);
- *gstate = 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->fdelimlen = s->edelimlen = 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
-m_getfld_state_reset (m_getfld_state_t *gstate) {
+m_getfld_state_reset (m_getfld_state_t *gstate)
+{
if (*gstate) {
(*gstate)->state = FLD;
}
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) {
- m_getfld_state_init (gstate, iob);
+ *gstate = m_getfld_state_init(iob);
}
(*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) {
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;
off_t pos;
off_t pos_movement;
if (! *gstate) {
- m_getfld_state_init (gstate, iob);
+ *gstate = m_getfld_state_init(iob);
}
s = *gstate;
s->bytes_read = 0;
if (!s->track_filepos)
return;
- pos = ftello(iob);
+ if ((pos = ftello(iob)) == -1)
+ adios("getfld's iob", "failed to get offset on entry");
if (pos == 0 && s->last_internal_pos == 0)
return;
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. */
- fseeko (iob, pos/MSG_INPUT_SIZE * MSG_INPUT_SIZE, SEEK_SET);
+ 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;
}
}
- fseeko (iob, pos, SEEK_SET);
+ if (fseeko(iob, pos, SEEK_SET) == -1)
+ adios("getfld's iob", "failed to set offset on entry: %" PRIdMAX,
+ (intmax_t)pos);
}
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->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(). */
- 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
-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;
- 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);
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
-Getc (m_getfld_state_t s) {
+Getc (m_getfld_state_t s)
+{
if ((s->end - s->readpos < 1 && read_more (s) == 0) ||
s->readpos >= s->end)
return EOF;
return (unsigned char)*s->readpos++;
}
+/* Return the next character that Getc() would return, which may be EOF. */
static int
-Peek (m_getfld_state_t s) {
- if (s->end - s->readpos < 1 && read_more (s) == 0) {
- return EOF;
- }
- return s->readpos < s->end ? (unsigned char) *s->readpos : EOF;
+Peek (m_getfld_state_t s)
+{
+ int c;
+
+ c = Getc(s);
+ if (c != EOF)
+ Ungetc(s);
+
+ return c;
}
-static int
-Ungetc (int c, m_getfld_state_t s) {
- if (s->readpos == s->msg_buf) {
- return EOF;
- }
- --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--;
}
;
if (c != EOF)
- Ungetc(c, s);
+ Ungetc(s);
*bufsz = *buf = 0;
leave_getfld (s);
return s->state = FILEEOF;
while ((c = Getc(s)) != EOF && eom (c, s))
;
if (c != EOF)
- Ungetc(c, s);
+ Ungetc(s);
*bufsz = *buf = 0;
leave_getfld (s);
return s->state = FILEEOF;
* 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;
- for (finished = 0; ! finished; ) {
+ for (bool finished = false; !finished; ) {
while (c != '\n' && c != EOF && n++ < max) {
if ((c = Getc (s)) != EOF)
*cp++ = c;
--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;
- finished = 1;
+ finished = true;
} else {
/* Folded header field, continues on the next line. */
}
char *ep;
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 {
/*
*/
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
}
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;
}
+/* 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)
{
/* not a Unix style maildrop */
s->readpos -= s->bytes_read;
s->bytes_read = 0;
- delimstr = mmdlm1;
+ delimstr = MMDF_DELIM;
s->msg_style = MS_MMDF;
}
+ /* "\nFrom \0" 7 "\001\001\001\001\n\0" 6
+ * | |
+ * delimstr c=6 delimstr c=5
+ */
c = strlen (delimstr);
s->fdelim = mh_xmalloc (c + 3); /* \0, \n, delimstr, \0 */
*s->fdelim++ = '\0';
s->edelimlen = c - 1;
s->delimend = s->msg_delim + s->edelimlen;
if (s->edelimlen <= 1)
- adios (NULL, "maildrop delimiter must be at least 2 bytes");
-
- /* Now malloc'd memory at s->fdelim-1 is referenced several times,
- * containing a copy of the string constant from delimstr.
- *
- * "\nFrom \0" 7 "\001\001\001\001\n\0" 6
- * | |
- * delimstr c=6 delimstr c=5
- *
- * "\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
- */
+ die("maildrop delimiter must be at least 2 bytes");
/*
* build a Boyer-Moore end-position map for the matcher in m_getfld.
* separator) or the last char (since the matchc would have found it
* if it was a real delim).
*/
- s->pat_map = (char **) mh_xcalloc (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;
while ((c = Getc(s)) != EOF && eom (c, s))
;
if (c != EOF)
- Ungetc(c, s);
+ Ungetc(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
*/
int i;
char text[MAX_DELIMITER_SIZE];
char *cp;
+ int adjust = 1;
for (i = 0, cp = text; i < s->edelimlen; ++i, ++cp) {
int c2;
*cp = '\0';
break;
}
- *cp = c2;
+ *cp = c2;
}
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
* maildrop is part of the delimiter - delete it.
*/
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. */
- s->readpos -= s->bytes_read - 1;
- s->bytes_read = 1;
+ s->readpos -= s->bytes_read - adjust;
+ s->bytes_read = adjust;
return 0;
}
projects / nmh / blobdiff