X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/67c31724273a5582eaedef7990a68657a36227ad..670a0d84c25b458bbb348d2a1ecee178cfa6c226:/sbr/m_getfld.c diff --git a/sbr/m_getfld.c b/sbr/m_getfld.c index 5c5b4a3a..940b3efc 100644 --- a/sbr/m_getfld.c +++ b/sbr/m_getfld.c @@ -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. */ -#include -#include -#include +#include "h/mh.h" +#include "m_getfld.h" +#include "error.h" +#include "h/mts.h" +#include "h/utils.h" +#include /* Purpose @@ -61,10 +62,13 @@ 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: @@ -92,7 +96,7 @@ 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 @@ -202,13 +206,20 @@ /* * static prototypes */ -struct m_getfld_state; +static void Ungetc(m_getfld_state_t s); static int m_Eom (m_getfld_state_t); -static char *matchc(int, char *, int, char *); #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. * @@ -223,53 +234,88 @@ static char *matchc(int, char *, int, char *); #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; @@ -281,11 +327,14 @@ m_getfld_state_init (m_getfld_state_t *gstate, FILE *iob) { 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; } @@ -295,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 -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) { @@ -346,13 +408,14 @@ void m_getfld_state_destroy (m_getfld_state_t *gstate) { 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; @@ -368,7 +431,8 @@ enter_getfld (m_getfld_state_t *gstate, FILE *iob) { 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; @@ -397,11 +461,15 @@ enter_getfld (m_getfld_state_t *gstate, FILE *iob) { 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; @@ -409,35 +477,47 @@ enter_getfld (m_getfld_state_t *gstate, FILE *iob) { } } - 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); @@ -446,11 +526,11 @@ read_more (m_getfld_state_t s) { 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; @@ -459,21 +539,29 @@ Getc (m_getfld_state_t s) { 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--; } @@ -499,7 +587,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, ; if (c != EOF) - Ungetc(c, s); + Ungetc(s); *bufsz = *buf = 0; leave_getfld (s); return s->state = FILEEOF; @@ -517,7 +605,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, 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; @@ -548,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; - advise (NULL, "eof encountered in field \"%s\"", name); + inform("eof encountered in field \"%s\"", name); leave_getfld (s); return s->state = FMTERR; } @@ -574,7 +662,7 @@ 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; - advise (NULL, "eol encountered in field \"%s\"", name); + inform("eol encountered in field \"%s\"", name); s->state = FMTERR; break; } @@ -596,7 +684,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, 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; @@ -606,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. */ - /* fall through */ + /* FALLTHRU */ case FLDPLUS: { /* @@ -614,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. */ - 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; } + 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 @@ -637,14 +725,14 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, --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. */ } @@ -665,7 +753,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, 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) @@ -681,7 +769,10 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, */ 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 { /* @@ -699,7 +790,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, */ 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 @@ -751,7 +842,7 @@ m_getfld (m_getfld_state_t *gstate, char name[NAMESZ], char *buf, int *bufsz, } 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; @@ -761,6 +852,17 @@ 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) { @@ -776,7 +878,7 @@ m_unknown(m_getfld_state_t *gstate, FILE *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 @@ -794,9 +896,8 @@ m_unknown(m_getfld_state_t *gstate, FILE *iob) if ((c = Getc (s)) == EOF) { *cp = '\0'; break; - } else { - *cp = c; } + *cp = c; } if (i == sizeof from-1 && strncmp (text, "From ", sizeof from-1) == 0) { @@ -808,28 +909,34 @@ m_unknown(m_getfld_state_t *gstate, FILE *iob) /* not a Unix style maildrop */ s->readpos -= s->bytes_read; s->bytes_read = 0; - delimstr = mmdlm2; + 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); + s->fdelim = mh_xmalloc (c + 3); /* \0, \n, delimstr, \0 */ *s->fdelim++ = '\0'; *s->fdelim = '\n'; - s->msg_delim = s->fdelim+1; - s->edelim = s->msg_delim+1; s->fdelimlen = c + 1; - s->edelimlen = c - 1; /* == strlen (delimstr) */ + 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"); + 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). */ - 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; @@ -839,13 +946,24 @@ m_unknown(m_getfld_state_t *gstate, FILE *iob) 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 */ @@ -856,6 +974,7 @@ m_Eom (m_getfld_state_t s) int i; char text[MAX_DELIMITER_SIZE]; char *cp; + int adjust = 1; for (i = 0, cp = text; i < s->edelimlen; ++i, ++cp) { int c2; @@ -863,24 +982,32 @@ m_Eom (m_getfld_state_t s) if ((c2 = Getc (s)) == EOF) { *cp = '\0'; break; - } else { - *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 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. */ - s->readpos -= s->bytes_read - 1; - s->bytes_read = 1; + s->readpos -= s->bytes_read - adjust; + s->bytes_read = adjust; return 0; } @@ -892,27 +1019,3 @@ m_Eom (m_getfld_state_t s) return 1; } - - -static char * -matchc(int patln, char *pat, int strln, char *str) -{ - char *es = str + strln - patln; - char *sp; - char *pp; - char *ep = pat + patln; - 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; - } -}