#include <h/mh.h>
#include <h/utils.h>
+#include <ctype.h>
+#include <sysexits.h>
/*
-** This module has a long and checkered history. First, it didn't burst
-** maildrops correctly because it considered two CTRL-A:s in a row to be
-** an inter-message delimiter. It really is four CTRL-A:s followed by a
-** newline. Unfortunately, MMDF will convert this delimiter *inside* a
-** message to a CTRL-B followed by three CTRL-A:s and a newline. This
-** caused the old version of m_getfld() to declare eom prematurely. The
-** fix was a lot slower than
+** This module has a long and checkered history.
**
-** c == '\001' && peekc (iob) == '\001'
+** [ Here had been some history of delimiter problems in MMDF maildrops ... ]
**
-** but it worked, and to increase generality, MBOX style maildrops could
-** be parsed as well. Unfortunately the speed issue finally caught up with
-** us since this routine is at the very heart of MH.
+** 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 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 message.
**
-** To speed things up considerably, the routine Eom() was made an auxilary
-** 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
-** message.
+** [ ... and here had been some more of it. ]
**
-** After mhl was made a built-in in msh, m_getfld() worked just fine
-** (using m_unknown() at startup). Until one day: a message which was
-** the result of a bursting was shown. Then, since the burst boundaries
-** aren't CTRL-A:s, m_getfld() would blinding plunge on past the boundary.
-** Very sad. The solution: introduce m_eomsbr(). This hook gets called
-** after the end of each line (since testing for eom involves an fseek()).
-** This worked fine, until one day: a message with no body portion arrived.
-** Then the
-**
-** while (eom(c = getc(iob), iob))
-** continue;
-**
-** loop caused m_getfld() to return FMTERR. So, that logic was changed to
-** check for (*eom_action) and act accordingly.
-**
-** [ Note by meillo 2011-10:
-** as msh was removed from mmh, m_eomsbr() became irrelevant. ]
-**
-** This worked fine, until one day: someone didn't use four CTRL:A's as
-** their delimiters. So, the bullet got bit and we read mts.h and
-** continue to struggle on. It's not that bad though, since the only time
-** the code gets executed is when inc (or msh) calls it, and both of these
-** have already called mts_init().
-**
-** [ Note by meillo 2012-02:
-** MMDF-style maildrops (4x ^A) and mts_init() were removed. ]
**
** ------------------------
** (Written by Van Jacobson for the mh6 m_getfld, January, 1986):
** If you hack on this and slow it down, I, my children and my
** children's children will curse you.
**
-** This routine gets used on three different types of files: normal,
-** single msg files, "packed" unix or mmdf mailboxs (when used by inc)
-** and packed, directoried bulletin board files (when used by msh).
+** This routine gets used on two different types of files: normal,
+** single msg files and "packed" unix mailboxs (when used by inc).
** The biggest impact of different file types is in "eom" testing. The
** code has been carefully organized to test for eom at appropriate
** times and at no other times (since the check is quite expensive).
static unsigned char *matchc(int, char *, int, char *);
static unsigned char *locc(int, unsigned char *, unsigned char);
-#define eom(c,iob) (msg_style != MS_DEFAULT && \
+#define eom(c,iob) (ismbox && \
(((c) == *msg_delim && m_Eom(c,iob)) ||\
(eom_action && (*eom_action)(c))))
static unsigned char **pat_map;
/*
-** defined in sbr/m_msgdef.c = 0
** This is a disgusting hack for "inc" so it can know how many
** characters were stuffed in the buffer on the last call
** (see comments in uip/scansbr.c).
*/
-extern int msg_count;
+int msg_count = 0;
-/*
-** defined in sbr/m_msgdef.c = MS_DEFAULT
-*/
-extern int msg_style;
+int ismbox = FALSE;
/*
** The "full" delimiter string for a packed maildrop consists
** is used in m_Eom because the first character of the string
** has been read and matched before m_Eom is called.
*/
-extern char *msg_delim; /* defined in sbr/m_msgdef.c = "" */
+static char *msg_delim = "";
+
static unsigned char *fdelim;
static unsigned char *delimend;
static int fdelimlen;
static int (*eom_action)(int) = NULL;
-#ifdef _FSTDIO
-# define _ptr _p /* Gag */
-# define _cnt _r /* Retch */
-# define _filbuf __srget /* Puke */
-# define DEFINED__FILBUF_TO_SOMETHING_SPECIFIC
-#endif
+/*
+** This replaces the old approach, which included direct access to
+** stdio internals. It uses one fread() to load a buffer that we
+** manage.
+*/
+#define MSG_INPUT_SIZE 8192
+static struct m_getfld_buffer {
+ unsigned char msg_buf[2 * MSG_INPUT_SIZE];
+ unsigned char *readpos;
+ unsigned char *end; /* One past the last character read in. */
+} m;
+
+static void
+setup_buffer(FILE *iob, struct m_getfld_buffer *m)
+{
+ /*
+ ** Rely on Restrictions that m_getfld() calls on different file
+ ** streams are not interleaved, and no other file stream read
+ ** methods are used. And, the first call to m_getfld (), etc., on
+ ** a stream always reads at least 1 byte.
+ ** I don't think it's necessary to use ftello() because we just
+ ** need to determine whether the current offset is 0 or not.
+ */
+ if (ftell(iob) == 0) {
+ /* A new file stream, so reset the buffer state. */
+ m->readpos = m->end = m->msg_buf;
+ }
+}
-#ifdef SCO_5_STDIO
-# define _ptr __ptr
-# define _cnt __cnt
-# define _base __base
-# define _filbuf(fp) ((fp)->__cnt = 0, __filbuf(fp))
-# define DEFINED__FILBUF_TO_SOMETHING_SPECIFIC
-#endif
+static size_t
+read_more(struct m_getfld_buffer *m, FILE *iob)
+{
+ size_t num_read;
+
+ /* Move any leftover at the end of buf to the beginning. */
+ if (m->end > m->readpos) {
+ memmove(m->msg_buf, m->readpos, m->end - m->readpos);
+ }
+ m->readpos = m->msg_buf + (m->end - m->readpos);
+ num_read = fread(m->readpos, 1, MSG_INPUT_SIZE, iob);
+ m->end = m->readpos + num_read;
+
+ return num_read;
+}
+
+static int
+Getc(FILE *iob)
+{
+ if (m.end - m.readpos < 1) {
+ if (read_more(&m, iob) == 0) {
+ /*
+ ** Pretend that we read a character.
+ ** That's what stdio does.
+ */
+ ++m.readpos;
+ return EOF;
+ }
+ }
+ return (m.readpos < m.end) ? *m.readpos++ : EOF;
+}
+
+static int
+Ungetc(int c, FILE *iob)
+{
+ return (m.readpos == m.msg_buf) ? EOF : (*--m.readpos = c);
+}
-#ifndef DEFINED__FILBUF_TO_SOMETHING_SPECIFIC
-extern int _filbuf(FILE*);
-#endif
int
m_getfld(int state, unsigned char *name, unsigned char *buf,
int bufsz, FILE *iob)
{
- register unsigned char *bp, *cp, *ep, *sp;
- register int cnt, c, i, j;
+ unsigned char *bp, *cp, *ep, *sp;
+ int cnt, c, i, j, k;
- if ((c = getc(iob)) < 0) {
+ setup_buffer(iob, &m);
+
+ if ((c = Getc(iob)) < 0) {
msg_count = 0;
*buf = 0;
return FILEEOF;
if (eom(c, iob)) {
if (! eom_action) {
/* flush null messages */
- while ((c = getc(iob)) >= 0 && eom(c, iob))
+ while ((c = Getc(iob)) >= 0 && eom(c, iob))
;
if (c >= 0)
- ungetc(c, iob);
+ Ungetc(c, iob);
}
msg_count = 0;
*buf = 0;
case FLD:
if (c == '\n' || c == '-') {
/* we hit the header/body separator */
- while (c != '\n' && (c = getc(iob)) >= 0)
+ while (c != '\n' && (c = Getc(iob)) >= 0)
;
- if (c < 0 || (c = getc(iob)) < 0 || eom(c, iob)) {
- if (! eom_action) {
+ if (c < 0 || (c = Getc(iob)) < 0 || eom(c, iob)) {
+ if (!eom_action) {
/* flush null messages */
- while ((c = getc(iob)) >= 0 && eom(c, iob))
+ while ((c = Getc(iob)) >= 0 && eom(c, iob))
;
if (c >= 0)
- ungetc(c, iob);
+ Ungetc(c, iob);
}
msg_count = 0;
*buf = 0;
cp = name;
i = NAMESZ - 1;
for (;;) {
-#ifdef LINUX_STDIO
- bp = sp = (unsigned char *) iob->_IO_read_ptr - 1;
- j = (cnt = ((long) iob->_IO_read_end -
- (long) iob->_IO_read_ptr) + 1) < i ? cnt : i;
-#elif defined(__DragonFly__)
- bp = sp = (unsigned char *) ((struct __FILE_public *)iob)->_p - 1;
- j = (cnt = ((struct __FILE_public *)iob)->_r+1) < i ? cnt : i;
-#else
- bp = sp = (unsigned char *) iob->_ptr - 1;
- j = (cnt = iob->_cnt+1) < i ? cnt : i;
-#endif
+ /* Store current pos, ungetting the last char. */
+ bp = sp = (unsigned char *) m.readpos - 1;
+ j = ((cnt = m.end - m.readpos + 1) < i) ? cnt : i;
+
while (--j >= 0 && (c = *bp++) != ':' && c != '\n')
*cp++ = c;
j = bp - sp;
if ((cnt -= j) <= 0) {
-#ifdef LINUX_STDIO
- iob->_IO_read_ptr = iob->_IO_read_end;
- if (__underflow(iob) == EOF) {
-#elif defined(__DragonFly__)
- if (__srget(iob) == EOF) {
-#else
- if (_filbuf(iob) == EOF) {
-#endif
+ /*
+ ** Used to explicitly force refill of the
+ ** buffer here, but Getc() will do that
+ ** if necessary.
+ */
+ if (Getc (iob) == EOF) {
*cp = *buf = 0;
advise(NULL, "eof encountered in field \"%s\"", name);
return FMTERR;
}
-#ifdef LINUX_STDIO
- iob->_IO_read_ptr++; /* NOT automatic in __underflow()! */
-#endif
} else {
-#ifdef LINUX_STDIO
- iob->_IO_read_ptr = bp + 1;
-#elif defined(__DragonFly__)
- ((struct __FILE_public *)iob)->_p = bp + 1;
- ((struct __FILE_public *)iob)->_r = cnt - 1;
-#else
- iob->_ptr = bp + 1;
- iob->_cnt = cnt - 1;
-#endif
+ /* Restore the current offset. */
+ m.readpos = bp + 1;
}
if (c == ':')
break;
** that should be harmless enough, right?
** This is a corrupt message anyway.
*/
- fseek(iob, ftell(iob) - 2, SEEK_SET);
+ /* emulates: fseek(iob, ftell(iob) -(-2 + cnt + 1), SEEK_SET) */
+ m.readpos += cnt - 1;
+ /*
+ ** Reset file stream position so caller,
+ ** e.g., get_content, can use ftell(), etc.
+ */
+ fseek(iob, -cnt - 1, SEEK_CUR);
return BODY;
}
if ((i -= j) <= 0) {
*/
cp = buf; i = bufsz-1;
for (;;) {
-#ifdef LINUX_STDIO
- cnt = (long) iob->_IO_read_end - (long) iob->_IO_read_ptr;
- bp = (unsigned char *) --iob->_IO_read_ptr;
-#elif defined(__DragonFly__)
- cnt = ((struct __FILE_public *)iob)->_r++;
- bp = (unsigned char *) --((struct __FILE_public *)iob)->_p;
-#else
- cnt = iob->_cnt++;
- bp = (unsigned char *) --iob->_ptr;
-#endif
+ /* Set and save the current pos and update cnt. */
+ cnt = m.end - m.readpos;
+ bp = --m.readpos;
c = cnt < i ? cnt : i;
while ((ep = locc( c, bp, '\n' ))) {
/*
** return.
*/
if ((j = *++ep) != ' ' && j != '\t') {
-#ifdef LINUX_STDIO
- j = ep - (unsigned char *) iob->_IO_read_ptr;
- memcpy(cp, iob->_IO_read_ptr, j);
- iob->_IO_read_ptr = ep;
-#elif defined(__DragonFly__)
- j = ep - (unsigned char *) ((struct __FILE_public *)iob)->_p;
- memcpy(cp, ((struct __FILE_public *)iob)->_p, j);
- ((struct __FILE_public *)iob)->_p = ep;
- ((struct __FILE_public *)iob)->_r -= j;
-#else
- j = ep - (unsigned char *) iob->_ptr;
- memcpy(cp, iob->_ptr, j);
- iob->_ptr = ep;
- iob->_cnt -= j;
-#endif
+ /*
+ ** Save the text and update the
+ ** current position.
+ */
+ j = ep - m.readpos;
+ memcpy (cp, m.readpos, j);
+ m.readpos = ep;
cp += j;
state = FLD;
goto finish;
** end of input or dest buffer - copy what
** we've found.
*/
-#ifdef LINUX_STDIO
- c += bp - (unsigned char *) iob->_IO_read_ptr;
- memcpy(cp, iob->_IO_read_ptr, c);
-#elif defined(__DragonFly__)
- c += bp - (unsigned char *) ((struct __FILE_public *)iob)->_p;
- memcpy(cp, ((struct __FILE_public *)iob)->_p, c);
-#else
- c += bp - (unsigned char *) iob->_ptr;
- memcpy(cp, iob->_ptr, c);
-#endif
- i -= c;
- cp += c;
+ c += bp - m.readpos;
+ for (k = 0; k < c; ++k, --i) {
+ *cp++ = Getc (iob);
+ }
if (i <= 0) {
/* the dest buffer is full */
-#ifdef LINUX_STDIO
- iob->_IO_read_ptr += c;
-#elif defined(__DragonFly__)
- ((struct __FILE_public *)iob)->_r -= c;
- ((struct __FILE_public *)iob)->_p += c;
-#else
- iob->_cnt -= c;
- iob->_ptr += c;
-#endif
state = FLDPLUS;
break;
}
/*
** There's one character left in the input
- ** buffer. Copy it & fill the buffer.
- ** If the last char was a newline and the
- ** next char is not whitespace, this is
- ** the end of the field. Otherwise loop.
+ ** buffer. Copy it & fill the buffer (that
+ ** fill used to be explicit, but now Getc()
+ ** does it). If the last char was a newline
+ ** and the next char is not whitespace, this
+ ** is the end of the field. Otherwise loop.
*/
--i;
-#ifdef LINUX_STDIO
- *cp++ = j = *(iob->_IO_read_ptr + c);
- iob->_IO_read_ptr = iob->_IO_read_end;
- c = __underflow(iob);
- iob->_IO_read_ptr++; /* NOT automatic! */
-#elif defined(__DragonFly__)
- *cp++ =j = *(((struct __FILE_public *)iob)->_p + c);
- c = __srget(iob);
-#else
- *cp++ = j = *(iob->_ptr + c);
- c = _filbuf(iob);
-#endif
- if (c == EOF ||
- ((j == '\0' || j == '\n') && c != ' ' && c != '\t')) {
+ *cp++ = j = Getc(iob);
+ c = Getc(iob);
+ if (c == EOF || ((j == '\0' || j == '\n')
+ && c != ' ' && c != '\t')) {
if (c != EOF) {
-#ifdef LINUX_STDIO
- --iob->_IO_read_ptr;
-#elif defined(__DragonFly__)
- --((struct __FILE_public *)iob)->_p;
- ++((struct __FILE_public *)iob)->_r;
-#else
- --iob->_ptr;
- ++iob->_cnt;
-#endif
+ /*
+ ** Put the character back for
+ ** the next call.
+ */
+ --m.readpos;
}
state = FLD;
break;
** don't add an eos.
*/
i = (bufsz < 0) ? -bufsz : bufsz-1;
-#ifdef LINUX_STDIO
- bp = (unsigned char *) --iob->_IO_read_ptr;
- cnt = (long) iob->_IO_read_end - (long) iob->_IO_read_ptr;
-#elif defined(__DragonFly__)
- bp = (unsigned char *) --((struct __FILE_public *)iob)->_p;
- cnt = ++((struct __FILE_public *)iob)->_r;
-#else
- bp = (unsigned char *) --iob->_ptr;
- cnt = ++iob->_cnt;
-#endif
- c = (cnt < i ? cnt : i);
- if (msg_style != MS_DEFAULT && c > 1) {
+ /* Back up and store the current position and update cnt. */
+ bp = --m.readpos;
+ cnt = m.end - m.readpos;
+ c = (cnt < i) ? cnt : i;
+ if (ismbox && c > 1) {
/*
** packed maildrop - only take up to the (possible)
** start of the next message. This "matchc" should
}
}
memcpy( buf, bp, c );
-#ifdef LINUX_STDIO
- iob->_IO_read_ptr += c;
-#elif defined(__DragonFly__)
- ((struct __FILE_public *)iob)->_r -= c;
- ((struct __FILE_public *)iob)->_p += c;
-#else
- iob->_cnt -= c;
- iob->_ptr += c;
-#endif
+ /* Advance the current position to reflect the copy out. */
+ m.readpos += c;
if (bufsz < 0) {
msg_count = c;
return (state);
break;
default:
- adios(NULL, "m_getfld() called with bogus state of %d", state);
+ adios(EX_SOFTWARE, NULL, "m_getfld() called with bogus state of %d", state);
}
finish:
*cp = 0;
return (state);
}
-static char unixbuf[BUFSIZ] = "";
void
-m_unknown(FILE *iob)
+thisisanmbox(FILE *iob)
{
- register int c;
- register long pos;
+ int c;
char text[10];
- register char *cp;
- register char *delimstr;
+ char *cp;
+ char *delimstr;
-/*
-** Figure out what the message delimitter 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
-** every newline in the message).
-**
-** If the first line of the maildrop is a Unix "From " line, we
-** say the style is MBOX and eat the rest of the line. Otherwise
-** abort.
-*/
+ setup_buffer(iob, &m);
- msg_style = MS_UNKNOWN;
-
- pos = ftell(iob);
- if (fread(text, sizeof(*text), 5, iob) == 5
- && strncmp(text, "From ", 5) == 0) {
- msg_style = MS_MBOX;
- delimstr = "\nFrom ";
- cp = unixbuf;
- while ((c = getc(iob)) != '\n' && cp - unixbuf < BUFSIZ - 1)
- *cp++ = c;
- *cp = 0;
- } else {
- /* not a Unix style maildrop */
- adios(NULL, "No Unix style (mbox) maildrop.");
+ c = Getc(iob);
+ if (feof(iob)) {
+ return;
+ }
+ Ungetc(c, iob);
+
+ /*
+ ** Figure out what the message delimitter 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
+ ** every newline in the message).
+ **
+ ** If the first line of the maildrop is a Unix "From " line, we
+ ** say the style is MBOX and eat the rest of the line. Otherwise
+ ** abort.
+ */
+ for (c=0, cp=text; c<5; ++c, ++cp) {
+ if ((*cp = Getc(iob)) == EOF) {
+ break;
+ }
+ }
+ if (c != 5) {
+ adios(EX_IOERR, NULL, "Read error");
+ }
+ if (strncmp(text, "From ", 5)!=0) {
+ adios(EX_USAGE, NULL, "No Unix style (mbox) maildrop.");
+ }
+ ismbox = TRUE;
+ delimstr = "\nFrom ";
+ while ((c = Getc(iob)) != '\n' && c >= 0) {
+ continue;
}
c = strlen(delimstr);
fdelim = (unsigned char *) mh_xmalloc((size_t) (c + 3));
edelimlen = c - 1;
strcpy(msg_delim, delimstr);
delimend = (unsigned char *)msg_delim + edelimlen;
- if (edelimlen <= 1)
- adios(NULL, "maildrop delimiter must be at least 2 bytes");
+ if (edelimlen <= 1) {
+ adios(EX_DATAERR, NULL, "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
*/
pat_map = (unsigned char **) calloc(256, sizeof(unsigned char *));
- for (cp = (char *) fdelim + 1; cp < (char *) delimend; cp++ )
+ for (cp = (char *) fdelim + 1; cp < (char *) delimend; cp++) {
pat_map[(unsigned char)*cp] = (unsigned char *) cp;
+ }
}
static int
m_Eom(int c, FILE *iob)
{
- register long pos = 0L;
- register int i;
+ unsigned char *pos;
+ int i;
char text[10];
- register char *cp;
+ char *cp;
- pos = ftell(iob);
- if ((i = fread(text, sizeof *text, edelimlen, iob)) != edelimlen
- || (strncmp(text, (char *)edelim, edelimlen)!=0)) {
- if (i == 0 && msg_style == MS_MBOX)
+ pos = m.readpos; /* ftell */
+ for (i=0, cp=text; i<edelimlen; ++i, ++cp) {
+ if ((*cp = Getc(iob)) == EOF) {
+ break;
+ }
+ }
+ if (i != edelimlen ||
+ (strncmp(text, (char *)edelim, edelimlen)!=0)) {
+ if (i == 0 && ismbox) {
/*
** the final newline in the (brain damaged) unix-format
** maildrop is part of the delimitter - delete it.
*/
return 1;
-
- fseek(iob, (long)(pos-1), SEEK_SET);
- getc(iob); /* should be OK */
+ }
+ m.readpos = pos - 1; /* fseek(iob, pos - 1, SEEK_SET) */
+ Getc(iob); /* should be OK */
return 0;
}
- if (msg_style == MS_MBOX) {
- cp = unixbuf;
- while ((c = getc(iob)) != '\n' && c >= 0 && cp - unixbuf < BUFSIZ - 1)
- *cp++ = c;
- *cp = 0;
- }
-
- return 1;
-}
-
-
-/*
-** Return the Return-Path and Delivery-Date
-** header information.
-**
-** Currently, I'm assuming that the "From " line
-** takes one of the following forms.
-**
-** From sender date remote from host (for UUCP delivery)
-** From sender@host date (for sendmail delivery)
-*/
-
-int
-get_returnpath(char *rp, int rplen, char *dd, int ddlen)
-{
- char *ap, *bp, *cp, *dp;
-
- ap = unixbuf;
- if (!(bp = cp = strchr(ap, ' ')))
- return 0;
-
- /*
- ** Check for "remote from" in envelope to see
- ** if this message uses UUCP style addressing
- */
- while ((cp = strchr(++cp, 'r'))) {
- if (strncmp(cp, "remote from", 11) == 0) {
- cp = strrchr(cp, ' ');
- break;
+ if (ismbox) {
+ while ((c = Getc(iob)) != '\n' && c >= 0) {
+ continue;
}
}
- /*
- ** Get the Return-Path information from
- ** the "From " envelope.
- */
- if (cp) {
- /* return path for UUCP style addressing */
- dp = strchr(++cp, '\n');
- snprintf(rp, rplen, "%.*s!%.*s\n", (int)(dp - cp), cp, (int)(bp - ap), ap);
- } else {
- /* return path for standard domain addressing */
- snprintf(rp, rplen, "%.*s\n", (int)(bp - ap), ap);
- }
-
- /*
- ** advance over the spaces to get to
- ** delivery date on envelope
- */
- while (*bp == ' ')
- bp++;
-
- /* Now get delivery date from envelope */
- snprintf(dd, ddlen, "%.*s\n", 24, bp);
-
- unixbuf[0] = 0;
return 1;
}
static unsigned 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++;
+ char *es = str + strln - patln;
+ char *sp;
+ char *pp;
+ char *ep = pat + patln;
+ char pc = *pat++;
for(;;) {
while (pc != *str++)
projects / mmh / blobdiff