X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/cebf14da4fc370baeba455bad0a1dc6df9532a15..872ef4dde72a88ceb1358849a462f791135b842d:/sbr/m_getfld.c diff --git a/sbr/m_getfld.c b/sbr/m_getfld.c index c73d8ba5..f5fa9a4e 100644 --- a/sbr/m_getfld.c +++ b/sbr/m_getfld.c @@ -1,6 +1,4 @@ - -/* - * 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 @@ -10,6 +8,75 @@ #include #include #include +#include + +/* + Purpose + ======= + Reads an Internet message (RFC 5322), or one or more messages + stored in a maildrop in mbox (RFC 4155) or MMDF format, from a file + stream. Each call to m_getfld() reads one header field, or a + portion of the body, in sequence. + + Inputs + ====== + gstate: opaque parse state + bufsz: maximum number of characters to load into buf + iob: input file stream + + Outputs + ======= + name: header field name (array of size NAMESZ=999) + buf: either a header field body or message body + bufsz: number of characters loaded into buf + (return value): message parse state on return from function + + Functions + ========= + void m_getfld_state_destroy (m_getfld_state_t *gstate): destroys + the parse state pointed to by the gstate argument. + + m_getfld_state_reset (m_getfld_state_t *gstate): resets the parse + state to FLD. + + void m_unknown(FILE *iob): Determines the message delimiter string + for the maildrop. Called by inc and scan when reading from a + maildrop file. + + State variables + =============== + m_getfld() retains state internally between calls in the + m_getfld_state_t variable. These are used for detecting the end of + each message when reading maildrops: + + char **pat_map + char *fdelim + char *delimend + int fdelimlen + char *edelim + int edelimlen + char *msg_delim + int msg_style + + Usage + ===== + 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_reset (&gstate); +*/ + +/* The following described the old implementation. The high-level + structure hasn't changed, but some of the details have. I'm + leaving this as-is, though, for posterity. + */ /* 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 @@ -25,9 +92,9 @@ 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, - 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 @@ -94,7 +161,7 @@ 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. @@ -110,7 +177,7 @@ 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" @@ -135,276 +202,404 @@ */ /* -Purpose -======= -Reads an Internet message (RFC 5322), or one or more messages stored in a -maildrop in mbox (RFC 4155) or MMDF format, from a file stream. Each call -to m_getfld() reads one header field, or a portion of the body, in sequence. - -Inputs -====== -state: message parse state -bufsz: maximum number of characters to load into buf -iob: input file stream - -Outputs -======= -name: header field name (array of size NAMESZ=999) -buf: either a header field body or message body -bufsz: number of characters loaded into buf -(return value): message parse state on return from function - -Functions -========= -void m_unknown(FILE *iob): Determines the message delimiter string for the - maildrop. Called by inc, scan, and msh when reading from a maildrop file. - -void m_eomsbr (int (*action)(int)): Sets the hook to check for end of - message in a maildrop. Called only by msh. - -Those functions save state in the State variables listed below. - -State variables -=============== -m_getfld() retains state internally between calls in some state variables. -These are used for detecting the end of each message when reading maildrops: -static unsigned char **pat_map -static unsigned char *fdelim -static unsigned char *delimend -static int fdelimlen -static unsigned char *edelim -static int edelimlen -char * msg_delim -int msg_style -int (*eom_action)(int) - -Restrictions -============ -m_getfld() is restricted to operate on one file stream at a time -because of the retained state (see "State variables" above). And the -first call to m_getfld() on that file stream requires that the read -pointer be at the beginning of the file (ftell() of 0). - -Current usage -============= -The first call to m_getfld() on a file stream is with a state of FLD. -Subsequent calls provide the state returned by the previous call. -Therefore, given the Restrictions above, the state variable could be -removed from the signature and just retained internally. -*/ + * 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))) /* - * static prototypes + * 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. + * + * MSG_INPUT_SIZE is the size of the buffer. + * MAX_DELIMITER_SIZE is the maximum size of the delimiter used to + * separate messages in a maildrop, such as mbox "From ". + * + * Some of the tests in the test suite assume a MSG_INPUT_SIZE + * of 8192. */ -static int m_Eom (int, FILE *); -static unsigned char *matchc(int, char *, int, char *); +#define MSG_INPUT_SIZE NMH_BUFSIZ +#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; + /* 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; + /* 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; + + /* 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 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; + /* 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 + */ -#define eom(c,iob) (msg_style != MS_DEFAULT && \ - (((c) == *msg_delim && m_Eom(c,iob)) ||\ - (eom_action && (*eom_action)(c)))) + /* 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; -static unsigned 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; +}; -static int msg_style = MS_DEFAULT; +m_getfld_state_t m_getfld_state_init(FILE *iob) +{ + m_getfld_state_t s; + + 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->iob = iob; + s->pat_map = NULL; + s->msg_style = MS_DEFAULT; + s->msg_delim = ""; + s->fdelim = s->delimend = s->edelim = NULL; + s->fdelimlen = s->edelimlen = 0; + s->state = FLD; + s->track_filepos = 0; + + return s; +} + +/* scan() needs to force an initial state of FLD for each message. */ +void +m_getfld_state_reset (m_getfld_state_t *gstate) { + if (*gstate) { + (*gstate)->state = FLD; + } +} + +/* If the caller interleaves ftell*()/fseek*() calls with m_getfld() + 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) { + if (! *gstate) { + *gstate = m_getfld_state_init(iob); + } + + (*gstate)->track_filepos = 1; +} + +/* m_getfld_track_filepos() with the existing iob. */ +void m_getfld_track_filepos2(m_getfld_state_t *gstate) +{ + if (!*gstate) + adios(NULL, "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) { + if (s->fdelim) { + free (s->fdelim-1); + free (s->pat_map); + } + free (s); + *gstate = 0; + } +} /* - * 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. - */ -static char *msg_delim = ""; -static unsigned char *fdelim; -static unsigned char *delimend; -static int fdelimlen; -static unsigned char *edelim; -static int edelimlen; - -static int (*eom_action)(int) = NULL; - -/* This replaces the old approach, which included direct access to - stdio internals. It uses one fread() to load a buffer that we - manage. - MSG_INPUT_SIZE is the size of the buffer. - MAX_DELIMITER_SIZE is the maximum size of the delimiter used to - separate messages in a maildrop, such as mbox "\nFrom ". */ -#define MSG_INPUT_SIZE 8192 -#define MAX_DELIMITER_SIZE 32 -static struct m_getfld_buffer { - unsigned char msg_buf[2 * MSG_INPUT_SIZE + MAX_DELIMITER_SIZE]; - unsigned char *readpos; - unsigned char *end; /* One past the last character read in. */ - /* The following support tracking of the read position in the - input file so that callers can interleave m_getfld() calls with - ftell() and fseek(). bytes_read replaces the old m_getfld() - msg_count global. */ - off_t bytes_read; - off_t last_file_position; -} m; + Summary of file and message input buffer positions: + + input file -------------------------------------------EOF + | | + last_caller_pos last_internal_pos + + + msg_buf --------------------EOF + | | | + msg_buf readpos end + + |<>|=retained characters, difference + between last_internal_pos and + first readpos value after reading + in new chunk in read_more() + + When returning from m_getfld()/m_unknown(): + 1) Save the internal file position in last_internal_pos. That's the + m_getfld() position reference in the input file. + 2) Set file stream position so that callers can use ftell(). + + When entering m_getfld()/m_unknown(): + Check to see if the call had changed the file position. If so, + adjust the internal position reference accordingly. If not, restore + the internal file position from last_internal_pos. +*/ + static void -setup_buffer (FILE *iob, struct m_getfld_buffer *m) { - /* Rely on Restriction that the first call to m_getfld (), etc., - is with the read position for the file stream set to 0. */ - if (ftello (iob) == 0) { - /* A new file stream, so reset the buffer state. */ - m->readpos = m->end = m->msg_buf; - m->last_file_position = ftello (iob); - } else { - off_t position = ftello (iob); - - /* Compare current file position with last file position. If - different, then caller must have called ftell(), so adjust - by the same amounmt. */ - if (position - m->last_file_position != 0) { - size_t num_read; - - /* Opportunity for optimization here: don't reread if the - new position had already been read into the buffer, - just move m->readpos to it. */ - fseeko (iob, 0, SEEK_SET); - do { - num_read = fread (m->msg_buf, 1, MSG_INPUT_SIZE, iob); - position -= num_read; - } while (position > 0); - m->readpos = m->msg_buf + position + num_read; - m->end = m->msg_buf + num_read; - - m->last_file_position = position; - } +enter_getfld (m_getfld_state_t *gstate, FILE *iob) { + m_getfld_state_t s; + off_t pos; + off_t pos_movement; + + if (! *gstate) { + *gstate = m_getfld_state_init(iob); + } + s = *gstate; + s->bytes_read = 0; + + /* This is ugly and no longer necessary, but is retained just in + case it's needed again. The parser used to open the input file + multiple times, so we had to always use the FILE * that's + passed to m_getfld(). Now the parser inits a new + m_getfld_state for each file. See comment below about the + readpos shift code being currently unused. */ + s->iob = iob; + + if (!s->track_filepos) + return; + + 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; + } - fseeko (iob, position, SEEK_SET); + 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; + } } - m->bytes_read = 0; + if (fseeko(iob, pos, SEEK_SET) == -1) + adios("getfld's iob", "failed to set offset on entry: %" PRIdMAX, + (intmax_t)pos); } static void -update_input_filepos (struct m_getfld_buffer *m, FILE *iob) { - /* Need to fseek so that callers can use ftell (). */ - m->last_file_position = ftello (iob); +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. */ + 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(). */ + 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 (struct m_getfld_buffer *m, FILE *iob) { - /* Retain at least edelimlen characters that have already been - read so that we can back up to them in m_Eom(). */ - ssize_t retain = 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 (m->end > m->readpos) { - if (retain < m->end - m->readpos) retain = m->end - m->readpos; - } - if (retain > m->readpos - m->msg_buf) { - /* Should not happen: there have been fewer characters read - than are remaining in the buffer. */ - retain = m->readpos - m->msg_buf; - } + if (retain > 0) { + if (retain < s->end - s->readpos) + retain = s->end - s->readpos; + assert (retain <= s->readpos - s->msg_buf); - /* Move any leftover at the end of buf to the beginning. */ - memmove (m->msg_buf, m->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); + } - m->readpos = m->msg_buf + retain; - num_read = fread (m->readpos, 1, MSG_INPUT_SIZE, iob); - m->end = m->readpos + num_read; + s->readpos = s->msg_buf + retain; + num_read = fread (s->readpos, 1, MSG_INPUT_SIZE, s->iob); + s->end = s->readpos + num_read; return num_read; } +/* 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 (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; - /* Don't seem to need the following but maybe because no - caller of m_getfld () looks at it. */ - ++m.bytes_read; - return EOF; - } - } +Getc (m_getfld_state_t s) { + if ((s->end - s->readpos < 1 && read_more (s) == 0) || + s->readpos >= s->end) + return EOF; - ++m.bytes_read; - return m.readpos < m.end ? *m.readpos++ : EOF; + s->bytes_read++; + return (unsigned char)*s->readpos++; } +/* Return the next character that Getc() would return, which may be EOF. */ static int -Peek (FILE *iob) { - int next_char = Getc (iob); - --m.readpos; - --m.bytes_read; +Peek (m_getfld_state_t s) +{ + int c; + + c = Getc(s); + if (c != EOF) + Ungetc(s); - return next_char; + return c; } -static int -Ungetc (int c, FILE *iob) { - NMH_UNUSED (iob); +/* 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) + adios(NULL, "Ungetc() at start of message buffer."); - if (m.readpos == m.msg_buf) { - return EOF; - } else { - --m.bytes_read; - return *--m.readpos = c; - } + s->readpos--; + s->bytes_read--; } int -m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, - int *bufsz, FILE *iob) +m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, + FILE *iob) { - register unsigned char *bp, *cp, *ep, *sp; - register int cnt, c, i, j; + m_getfld_state_t s; + char *cp; + int max, n, c; - setup_buffer (iob, &m); + enter_getfld (gstate, iob); + s = *gstate; - if ((c = Getc(iob)) < 0) { + if ((c = Getc(s)) == EOF) { *bufsz = *buf = 0; - update_input_filepos (&m, iob); - return FILEEOF; + leave_getfld (s); + return s->state = FILEEOF; } - if (eom (c, iob)) { - if (! eom_action) { - /* flush null messages */ - while ((c = Getc(iob)) >= 0 && eom (c, iob)) - ; - - if (c >= 0) - Ungetc(c, iob); - } + if (eom (c, s)) { + /* flush null messages */ + while ((c = Getc(s)) != EOF && eom (c, s)) + ; + + if (c != EOF) + Ungetc(s); *bufsz = *buf = 0; - update_input_filepos (&m, iob); - return FILEEOF; + leave_getfld (s); + return s->state = FILEEOF; } - switch (state) { - case FLDEOF: - case BODYEOF: + switch (s->state) { case FLD: if (c == '\n' || c == '-') { /* we hit the header/body separator */ - while (c != '\n' && (c = Getc(iob)) >= 0) continue; - - if (c < 0 || (c = Getc(iob)) < 0 || eom (c, iob)) { - if (! eom_action) { - /* flush null messages */ - while ((c = Getc(iob)) >= 0 && eom (c, iob)) - ; - if (c >= 0) - Ungetc(c, iob); - } + 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; - update_input_filepos (&m, iob); - return FILEEOF; + leave_getfld (s); + return s->state = FILEEOF; } - state = BODY; + s->state = BODY; goto body; } /* @@ -413,126 +608,144 @@ m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, * comes first. */ cp = name; - i = NAMESZ - 1; - for (;;) { - /* Get the field name. The first time through the - loop, this copies out the first character, which - was loaded into c prior to loop entry. Initialize - j to 1 to account for that. */ - for (j = 1; - c != ':' && c != '\n' && c != EOF && j <= i; - ++j, c = Getc (iob)) { - *cp++ = c; - } + max = NAMESZ - 1; + /* Get the field name. The first time through the loop, + this copies out the first character, which was loaded + into c prior to loop entry. Initialize n to 1 to + account for that. */ + for (n = 1; + c != ':' && c != '\n' && c != EOF && n < max; + ++n, c = Getc (s)) { + *cp++ = c; + } - /* Skip next character, which is either the space - after the ':' or the first folded whitespace. */ - { - int next_char; - if (c == EOF || (next_char = Peek (iob)) == EOF) { - *bufsz = *cp = *buf = 0; - advise (NULL, "eof encountered in field \"%s\"", name); - update_input_filepos (&m, iob); - return FMTERR; - } + /* Check for next character, which is either the space after + the ':' or the first folded whitespace. */ + { + int next_char; + if (c == EOF || (next_char = Peek (s)) == EOF) { + *bufsz = *cp = *buf = 0; + inform("eof encountered in field \"%s\"", name); + leave_getfld (s); + return s->state = FMTERR; } - if (c == ':') - break; + } - /* - * something went wrong. possibilities are: - * . hit a newline (error) - * . got more than namesz chars. (error) - * . hit the end of the buffer. (loop) - */ - if (c == '\n') { - /* We hit the end of the line without seeing ':' to - * terminate the field name. This is usually (always?) - * spam. But, blowing up is lame, especially when - * scan(1)ing a folder with such messages. Pretend such - * lines are the first of the body (at least mutt also - * handles it this way). */ - - /* See if buf can hold this line, since we were assuming - * we had a buffer of NAMESZ, not bufsz. */ - /* + 1 for the newline */ - - if (*bufsz < j + 1) { - /* No, it can't. Oh well, guess we'll blow up. */ - *bufsz = *cp = *buf = 0; - advise (NULL, "eol encountered in field \"%s\"", name); - state = FMTERR; - goto finish; - } - memcpy (buf, name, j - 1); - buf[j - 1] = '\n'; - buf[j] = '\0'; - *bufsz = m.bytes_read - 1; - update_input_filepos (&m, iob); - return BODY; - } - if ((i -= j) <= 0) { + /* If c isn't ':' here, something went wrong. Possibilities are: + * . hit a newline (error) + * . got more than namesz chars. (error) + */ + if (c == ':') { + /* Finished header name, fall through to FLDPLUS below. */ + } else if (c == '\n') { + /* We hit the end of the line without seeing ':' to + * terminate the field name. This is usually (always?) + * spam. But, blowing up is lame, especially when + * scan(1)ing a folder with such messages. Pretend such + * lines are the first of the body (at least mutt also + * handles it this way). */ + + /* See if buf can hold this line, since we were assuming + * we had a buffer of NAMESZ, not bufsz. */ + /* + 1 for the newline */ + if (*bufsz < n + 1) { + /* No, it can't. Oh well, guess we'll blow up. */ *bufsz = *cp = *buf = 0; - advise (NULL, "field name \"%s\" exceeds %d bytes", name, NAMESZ - 2); - state = LENERR; - goto finish; + inform("eol encountered in field \"%s\"", name); + 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; + } + 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; + inform("field name \"%s\" exceeds %d bytes", name, + NAMESZ - 2); + s->state = LENERR; + break; } /* Trim any trailing spaces from the end of name. */ - while (isspace (*--cp) && cp >= name) continue; + while (isspace ((unsigned char) *--cp) && cp >= name) continue; *++cp = 0; - /* c is ':' here. And readpos points to the first - character of the field body. */ - /* fall through */ + /* readpos points to the first character of the field body. */ + /* FALLTHRU */ - case FLDPLUS: + case FLDPLUS: { /* * get (more of) the text of a field. Take * characters up to the end of this field (newline * followed by non-blank) or bufsz-1 characters. */ + int finished; + cp = buf; - i = *bufsz-1; - for (;;) { - for (j = 0; c != '\n' && c != EOF && j++ <= i; ) { - *cp++ = c = Getc (iob); + max = *bufsz-1; + n = 0; + for (finished = 0; ! finished; ) { + while (c != '\n' && c != EOF && n++ < max) { + if ((c = Getc (s)) != EOF) + *cp++ = c; } - if (c != EOF) c = Peek (iob); - if (i < j) { - /* the dest buffer is full */ - *bufsz = m.bytes_read; - state = FLDPLUS; - goto finish; + 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 + reentered, it will read a character. Then + we'll jump right to the FLDPLUS handling code, + which will not store that character, but + instead move on to the next one. */ + if (s->readpos > s->msg_buf) { + --s->readpos; + --s->bytes_read; + } + s->state = FLDPLUS; + finished = 1; } 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 (). */ - *bufsz = m.bytes_read; - state = FLD; - goto finish; + s->state = FLD; + finished = 1; } else { /* Folded header field, continues on the next line. */ - continue; } } - *bufsz = m.bytes_read; + *bufsz = s->bytes_read; break; + } - case BODY: body: + case BODY: { /* * get the message body up to bufsz characters or the * end of the message. */ - i = *bufsz-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 (msg_style != MS_DEFAULT && c > 1) { + char *bp; + + name[0] = '\0'; + max = *bufsz-1; + /* Back up and store the current position. */ + bp = --s->readpos; + c = min(s->end - s->readpos, max); + if (s->msg_style != MS_DEFAULT && c > 1) { /* * packed maildrop - only take up to the (possible) * start of the next message. This "matchc" should @@ -545,7 +758,12 @@ m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, * algorithms vs. brute force.) Since I (currently) * run MH on a vax, we use the matchc instruction. --vj */ - if ((ep = matchc( fdelimlen, fdelim, c, bp ))) + 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 { /* @@ -561,8 +779,10 @@ m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, * ends with one of the characters in the pattern * (excluding the first and last), we do only one test. */ - ep = bp + c - 1; - if ((sp = pat_map[*ep])) { + char *sp; + + 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 * small to contain this delimiter prefix, or @@ -574,7 +794,7 @@ m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, * should have found it. Thus it's not a delim * and we know we won't get a match. */ - if (((sp - fdelim) + 2) <= c) { + if (((sp - s->fdelim) + 2) <= c) { cp = sp; /* Unfortunately although fdelim has a preceding NUL * we can't use this as a sentinel in case the buffer @@ -582,9 +802,9 @@ m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, * would cause us to run off the front of fdelim). */ while (*--ep == *--cp) - if (cp < fdelim) + if (cp < s->fdelim) break; - if (cp < fdelim) { + if (cp < s->fdelim) { /* we matched the entire delim prefix, * so only take the buffer up to there. * we know ep >= bp -- check above prevents underrun @@ -595,7 +815,7 @@ m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, } /* try matching one less char of delim string */ ep = bp + c - 1; - } while (--sp > fdelim); + } while (--sp > s->fdelim); } } } @@ -603,34 +823,52 @@ m_getfld (int state, unsigned char name[NAMESZ], unsigned char *buf, /* Advance the current position to reflect the copy out. c is less than or equal to the number of bytes remaining in the read buffer, so will not overrun it. */ - m.readpos += c; + s->readpos += c; cp = buf + c; - *bufsz = m.bytes_read + cp - buf - 1; + /* Subtract 1 from c because the first character was read by + Getc(), and therefore already accounted for in s->bytes_read. */ + s->bytes_read += c - 1; + *bufsz = s->bytes_read; break; + } default: - adios (NULL, "m_getfld() called with bogus state of %d", state); + adios (NULL, "m_getfld() called with bogus state of %d", s->state); } -finish: + *cp = 0; + leave_getfld (s); - update_input_filepos (&m, iob); - return (state); + return s->state; +} + + +/* m_getfld() with the existing iob. */ +int m_getfld2(m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz) +{ + if (!*gstate) + adios(NULL, "m_getfld2 without gstate"); + + return m_getfld(gstate, name, buf, bufsz, (*gstate)->iob); } void -m_unknown(FILE *iob) +m_unknown(m_getfld_state_t *gstate, FILE *iob) { - register int c; + m_getfld_state_t s; + int c; char text[MAX_DELIMITER_SIZE]; - register char *cp; - register char *delimstr; + char from[] = "From "; + char *cp; + char *delimstr; + unsigned int i; - setup_buffer (iob, &m); + 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 @@ -642,80 +880,76 @@ m_unknown(FILE *iob) * specified when nmh was built (or from the mts.conf file). */ - msg_style = MS_UNKNOWN; + s->msg_style = MS_UNKNOWN; - for (c = 0, cp = text; c < 5; ++c, ++cp) { - if ((*cp = Getc (iob)) == EOF) { + for (i = 0, cp = text; i < sizeof text; ++i, ++cp) { + if ((c = Getc (s)) == EOF) { + *cp = '\0'; break; } + *cp = c; } - if (c == 5 && strncmp (text, "From ", 5) == 0) { - msg_style = MS_MBOX; + if (i == sizeof from-1 && strncmp (text, "From ", sizeof from-1) == 0) { + s->msg_style = MS_MBOX; delimstr = "\nFrom "; - while ((c = Getc (iob)) != '\n' && c >= 0) continue; - /* m_unknown is only called on maildrop files, and they are only - read using m_getfld (). The caller musn't try to read from - the stream directly because the file position indicator was - not advanced based on bytes_read, but instead on whatever - was read into the message buffer. */ + while ((c = Getc(s)) != EOF && c != '\n') + ; } else { /* not a Unix style maildrop */ - m.readpos -= m.bytes_read; - if (mmdlm2 == NULL || *mmdlm2 == 0) - mmdlm2 = "\001\001\001\001\n"; - delimstr = mmdlm2; - msg_style = MS_MMDF; + s->readpos -= s->bytes_read; + s->bytes_read = 0; + 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); - fdelim = (unsigned char *) mh_xmalloc((size_t) (c + 3)); - *fdelim++ = '\0'; - *fdelim = '\n'; - msg_delim = (char *)fdelim+1; - edelim = (unsigned char *)msg_delim+1; - fdelimlen = c + 1; - edelimlen = c - 1; /* == strlen (delimstr) */ - strcpy (msg_delim, delimstr); - delimend = (unsigned char *)msg_delim + edelimlen; - if (edelimlen <= 1) + s->fdelim = mh_xmalloc (c + 3); /* \0, \n, delimstr, \0 */ + *s->fdelim++ = '\0'; + *s->fdelim = '\n'; + s->fdelimlen = c + 1; + s->msg_delim = s->fdelim+1; + 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) adios (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 * separator) or the last char (since the matchc would have found it * if it was a real delim). */ - pat_map = (unsigned char **) calloc (256, sizeof(unsigned char *)); + s->pat_map = (char **) mh_xcalloc (256, sizeof(char *)); - for (cp = (char *) fdelim + 1; cp < (char *) delimend; cp++ ) - pat_map[(unsigned char)*cp] = (unsigned char *) cp; + for (cp = s->fdelim + 1; cp < s->delimend; cp++ ) + s->pat_map[(unsigned char)*cp] = cp; - if (msg_style == MS_MMDF) { + if (s->msg_style == MS_MMDF) { /* flush extra msg hdrs */ - while ((c = Getc(iob)) >= 0 && eom (c, iob)) + while ((c = Getc(s)) != EOF && eom (c, s)) ; - if (c >= 0) - Ungetc(c, iob); + if (c != EOF) + Ungetc(s); } - update_input_filepos (&m, iob); + leave_getfld (s); } -void -m_eomsbr (int (*action)(int)) +/* m_unknown() with the existing iob. */ +void m_unknown2(m_getfld_state_t *gstate) { - if ((eom_action = action)) { - msg_style = MS_MSH; - *msg_delim = 0; - fdelimlen = 1; - delimend = fdelim; - } else { - msg_style = MS_MMDF; - msg_delim = (char *)fdelim + 1; - fdelimlen = strlen((char *)fdelim); - delimend = (unsigned char *)(msg_delim + edelimlen); - } + if (!*gstate) + adios(NULL, "m_unknown2 without gstate"); + + m_unknown(gstate, (*gstate)->iob); } @@ -724,61 +958,53 @@ m_eomsbr (int (*action)(int)) */ static int -m_Eom (int c, FILE *iob) +m_Eom (m_getfld_state_t s) { - register int i; + int i; char text[MAX_DELIMITER_SIZE]; char *cp; + int adjust = 1; - for (i = 0, cp = text; i < edelimlen; ++i, ++cp) { - if ((*cp = Getc (iob)) == EOF) { + for (i = 0, cp = text; i < s->edelimlen; ++i, ++cp) { + int c2; + + if ((c2 = Getc (s)) == EOF) { + *cp = '\0'; break; } + *cp = c2; } - if (i != edelimlen || strncmp (text, (char *)edelim, edelimlen)) { - if (i == 0 && msg_style == MS_MBOX) + if (i != s->edelimlen || + strncmp (text, (char *)s->edelim, s->edelimlen)) { + if (i == 0 && s->msg_style == MS_MBOX) { /* 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; + } + + 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. */ - m.readpos -= m.bytes_read - 1; + s->readpos -= s->bytes_read - adjust; + s->bytes_read = adjust; return 0; } - if (msg_style == MS_MBOX) { - while ((c = Getc (iob)) != '\n') - if (c < 0) - break; + if (s->msg_style == MS_MBOX) { + int c; + while ((c = Getc(s)) != EOF && c != '\n') + ; } 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++; - - 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 ((unsigned char *)--str); - } -}