X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/adc0a3232c43033729dbc036f0757bddfba463bd..a3724ed39:/sbr/m_getfld.c?ds=inline diff --git a/sbr/m_getfld.c b/sbr/m_getfld.c index 59b49677..e82a2fff 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 @@ -11,6 +9,71 @@ #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 = 0; + ... + int state = m_getfld (&gstate, ...); + ... + 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 an inter-message delimiter. It really is four CTRL-A:s followed by a @@ -25,7 +88,7 @@ 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 message. @@ -94,7 +157,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 +173,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" @@ -134,93 +197,34 @@ there is data in "name" or "buf"). */ -/* -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_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. - -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: - - unsigned char **pat_map - unsigned char *fdelim - unsigned char *delimend - int fdelimlen - unsigned char *edelim - int edelimlen - char *msg_delim - int msg_style - int (*eom_action)(int) - -Usage -===== - m_getfld_state_t gstate; - m_getfld_state_init (&gstate); - int state = m_getfld (gstate, ...); - ... - m_getfld_state_destroy (&gstate); - -The state is retained internally by gstate. To reset its state to FLD: - - m_getfld_state_reset (&gstate); -*/ - /* * static prototypes */ -struct m_getfld_state; -static int m_Eom (m_getfld_state_t, int); -static unsigned char *matchc(int, char *, int, char *); +static int m_Eom (m_getfld_state_t); #define eom(c,s) (s->msg_style != MS_DEFAULT && \ - (((c) == *s->msg_delim && m_Eom(s,c)) || \ - (s->eom_action && (*s->eom_action)(c)))) + ((c) == *s->msg_delim && m_Eom(s))) /* 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 "\nFrom ". + * separate messages in a maildrop, such as mbox "From ". * * Some of the tests in the test suite assume a MSG_INPUT_SIZE - * of 8192. */ -#define MSG_INPUT_SIZE (BUFSIZ >= 1024 ? BUFSIZ : 1024) -#define MAX_DELIMITER_SIZE 32 + * of 8192. + */ +#define MSG_INPUT_SIZE NMH_BUFSIZ +#define MAX_DELIMITER_SIZE 5 struct m_getfld_state { - unsigned char msg_buf[2 * MSG_INPUT_SIZE + MAX_DELIMITER_SIZE]; - unsigned char *readpos; - unsigned char *end; /* One past the last character read in. */ + char msg_buf[2 * MSG_INPUT_SIZE + MAX_DELIMITER_SIZE]; + char *readpos; + char *end; /* One past the last character read in. */ /* The following support tracking of the read position in the input file stream so that callers can interleave m_getfld() - calls with ftell() and fseek(). ytes_read replaces the old + 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 @@ -231,56 +235,80 @@ struct m_getfld_state { off_t last_internal_pos; FILE *iob; - unsigned char **pat_map; + char **pat_map; 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 + * "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 + * 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. */ char *msg_delim; - unsigned char *fdelim; - unsigned char *delimend; + char *fdelim; + char *delimend; int fdelimlen; - unsigned char *edelim; + char *edelim; int edelimlen; - int (*eom_action)(int); int state; + int track_filepos; }; +static void -m_getfld_state_init (m_getfld_state_t *s) { - *s = (m_getfld_state_t) mh_xmalloc(sizeof (struct m_getfld_state)); - (*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 gets loaded on every call to m_getfld()/m_unknown(). */ - (*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)->eom_action = NULL; - (*s)->state = FLD; +m_getfld_state_init (m_getfld_state_t *gstate, 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->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; } /* scan() needs to force a state an initial state of FLD for each message. */ void -m_getfld_state_reset (m_getfld_state_t *s) { - (*s)->state = FLD; +m_getfld_state_reset (m_getfld_state_t *gstate) { + if (*gstate) { + (*gstate)->state = FLD; + } } -void m_getfld_state_destroy (m_getfld_state_t *s) { - if (*s) { - free (*s); - *s = 0; +/* 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) { + m_getfld_state_init (gstate, iob); + } + + (*gstate)->track_filepos = 1; +} + +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; } } @@ -314,60 +342,84 @@ void m_getfld_state_destroy (m_getfld_state_t *s) { static void -enter_getfld (m_getfld_state_t s, 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); + } + s = *gstate; + s->bytes_read = 0; - /* Ugly. The parser opens the input file multiple times, so we - have to always use the FILE * that's passed to m_getfld(). */ + /* 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; - pos = ftello (iob); - - if (pos != 0) { - off_t pos_movement = pos - s->last_caller_pos; /* Can be < 0. */ - - if (pos_movement == 0) { - pos = s->last_internal_pos; - } else { - /* The current file stream position differs from the last - one, so caller must have called ftell/o(). Or, this is - the first call and the file position was not at 0. */ - - if (s->readpos + pos_movement >= s->msg_buf && - s->readpos + pos_movement < s->end) { - /* We can shift readpos and remain within the bounds of - msg_buf. */ - s->readpos += pos_movement; - s->total_bytes_read += pos_movement; - pos = s->last_internal_pos; - } else { - size_t num_read; - - /* This seek skips past an integral number of chunks of - size MSG_INPUT_SIZE. */ - fseeko (iob, pos / MSG_INPUT_SIZE * MSG_INPUT_SIZE, SEEK_SET); - num_read = fread (s->msg_buf, 1, MSG_INPUT_SIZE, iob); - s->readpos = s->msg_buf + pos % MSG_INPUT_SIZE; - s->end = s->msg_buf + num_read; - s->total_bytes_read = pos; - } - } + if (!s->track_filepos) + return; - if (s->last_internal_pos != 0) fseeko (iob, pos, SEEK_SET); + pos = ftello(iob); + if (pos == 0 && s->last_internal_pos == 0) + return; + + if (s->last_internal_pos == 0) { + s->total_bytes_read = pos; + return; } - s->bytes_read = 0; + pos_movement = pos - s->last_caller_pos; /* Can be < 0. */ + if (pos_movement == 0) { + pos = s->last_internal_pos; + } else { + /* The current file stream position differs from the + last one, so caller must have called ftell/o(). + Or, this is the first call and the file position + was not at 0. */ + + if (s->readpos + pos_movement >= s->msg_buf && + s->readpos + pos_movement < s->end) { + /* This is currently unused. It could be used by + parse_mime() if it was changed to use a global + m_getfld_state. */ + /* We can shift readpos and remain within the + bounds of msg_buf. */ + s->readpos += pos_movement; + s->total_bytes_read += pos_movement; + pos = s->last_internal_pos; + } else { + size_t num_read; + + /* This seek skips past an integral number of + chunks of size MSG_INPUT_SIZE. */ + fseeko (iob, pos/MSG_INPUT_SIZE * MSG_INPUT_SIZE, SEEK_SET); + num_read = fread (s->msg_buf, 1, MSG_INPUT_SIZE, iob); + s->readpos = s->msg_buf + pos % MSG_INPUT_SIZE; + s->end = s->msg_buf + num_read; + s->total_bytes_read = pos; + } + } + + fseeko (iob, pos, SEEK_SET); } static void leave_getfld (m_getfld_state_t s) { - /* Save the internal file position that we use for the input buffer. */ - s->last_internal_pos = ftello (s->iob); - - /* Set file stream position so that callers can use ftell(). */ s->total_bytes_read += s->bytes_read; - fseeko (s->iob, s->total_bytes_read, SEEK_SET); - s->last_caller_pos = ftello (s->iob); + + if (s->track_filepos) { + /* Save the internal file position that we use for the input buffer. */ + s->last_internal_pos = ftello (s->iob); + + /* 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); + } } static size_t @@ -377,8 +429,9 @@ read_more (m_getfld_state_t s) { ssize_t retain = s->edelimlen; size_t num_read; - if (retain < s->end - s->readpos) retain = s->end - s->readpos; - /* assert (retain <= s->readpos - s->msg_buf <= sizeof msg_buf); */ + 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); @@ -390,63 +443,60 @@ 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. */ static int Getc (m_getfld_state_t s) { - if (s->end - s->readpos < 1) { - if (read_more (s) == 0) { - /* Pretend that we read a character. That's what stdio does. */ - ++s->readpos; - return EOF; - } - } + if ((s->end - s->readpos < 1 && read_more (s) == 0) || + s->readpos >= s->end) + return EOF; - ++s->bytes_read; - return s->readpos < s->end ? *s->readpos++ : EOF; + s->bytes_read++; + return (unsigned char)*s->readpos++; } static int Peek (m_getfld_state_t s) { - int next_char = Getc (s); - --s->readpos; - --s->bytes_read; - - return next_char; + if (s->end - s->readpos < 1 && read_more (s) == 0) { + return EOF; + } + return s->readpos < s->end ? (unsigned char) *s->readpos : EOF; } static int Ungetc (int c, m_getfld_state_t s) { if (s->readpos == s->msg_buf) { return EOF; - } else { - --s->bytes_read; - return *--s->readpos = c; } + --s->bytes_read; + return *--s->readpos = (unsigned char) c; } int -m_getfld (m_getfld_state_t s, 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 *cp; - register int max, n, c; + m_getfld_state_t s; + char *cp; + int max, n, c; - enter_getfld (s, iob); + enter_getfld (gstate, iob); + s = *gstate; - if ((c = Getc(s)) < 0) { + if ((c = Getc(s)) == EOF) { *bufsz = *buf = 0; leave_getfld (s); return s->state = FILEEOF; } if (eom (c, s)) { - if (! s->eom_action) { - /* flush null messages */ - while ((c = Getc(s)) >= 0 && eom (c, s)) - ; + /* flush null messages */ + while ((c = Getc(s)) != EOF && eom (c, s)) + ; - if (c >= 0) - Ungetc(c, s); - } + if (c != EOF) + Ungetc(c, s); *bufsz = *buf = 0; leave_getfld (s); return s->state = FILEEOF; @@ -456,16 +506,15 @@ m_getfld (m_getfld_state_t s, unsigned char name[NAMESZ], unsigned char *buf, case FLD: if (c == '\n' || c == '-') { /* we hit the header/body separator */ - while (c != '\n' && (c = Getc(s)) >= 0) continue; - - if (c < 0 || (c = Getc(s)) < 0 || eom (c, s)) { - if (! s->eom_action) { - /* flush null messages */ - while ((c = Getc(s)) >= 0 && eom (c, s)) - ; - if (c >= 0) - Ungetc(c, s); - } + while (c != '\n' && (c = Getc(s)) != EOF) + ; + + if (c == EOF || (c = Getc(s)) == EOF || eom (c, s)) { + /* flush null messages */ + while ((c = Getc(s)) != EOF && eom (c, s)) + ; + if (c != EOF) + Ungetc(c, s); *bufsz = *buf = 0; leave_getfld (s); return s->state = FILEEOF; @@ -496,7 +545,7 @@ m_getfld (m_getfld_state_t s, unsigned char name[NAMESZ], unsigned char *buf, 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; } @@ -522,35 +571,39 @@ m_getfld (m_getfld_state_t s, unsigned char name[NAMESZ], unsigned char *buf, if (*bufsz < n + 1) { /* No, it can't. Oh well, guess we'll blow up. */ *bufsz = *cp = *buf = 0; - advise (NULL, "eol encountered in field \"%s\"", name); + inform("eol encountered in field \"%s\"", name); s->state = FMTERR; break; } memcpy (buf, name, n - 1); buf[n - 1] = '\n'; buf[n] = '\0'; + /* 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; - } else if (max <= n) { + } + if (max <= n) { /* By design, the loop above discards the last character it had read. It's in c, use it. */ *cp++ = c; *bufsz = *cp = *buf = 0; - advise (NULL, "field name \"%s\" exceeds %d bytes", name, + 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; /* readpos points to the first character of the field body. */ - /* fall through */ + /* FALLTHRU */ case FLDPLUS: { /* @@ -565,12 +618,23 @@ m_getfld (m_getfld_state_t s, unsigned char name[NAMESZ], unsigned char *buf, n = 0; for (finished = 0; ! finished; ) { while (c != '\n' && c != EOF && n++ < max) { - *cp++ = c = Getc (s); + 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 */ + /* 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') { @@ -594,12 +658,13 @@ m_getfld (m_getfld_state_t s, unsigned char name[NAMESZ], unsigned char *buf, * get the message body up to bufsz characters or the * end of the message. */ - unsigned char *bp; + char *bp; + name[0] = '\0'; max = *bufsz-1; - /* Back up and store the current position and update cnt. */ + /* 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) @@ -613,9 +678,9 @@ m_getfld (m_getfld_state_t s, 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 */ - unsigned char *ep; + char *ep; - if ((ep = matchc( s->fdelimlen, s->fdelim, c, bp ))) + if ((ep = memmem(bp, c, s->fdelim, s->fdelimlen))) c = ep - bp + 1; else { /* @@ -631,10 +696,10 @@ m_getfld (m_getfld_state_t s, 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. */ - unsigned char *sp; + char *sp; ep = bp + c - 1; - if ((sp = s->pat_map[*ep])) { + 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 @@ -696,17 +761,21 @@ m_getfld (m_getfld_state_t s, unsigned char name[NAMESZ], unsigned char *buf, void -m_unknown(m_getfld_state_t s, 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; - enter_getfld (s, iob); + 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 @@ -720,55 +789,74 @@ m_unknown(m_getfld_state_t s, FILE *iob) s->msg_style = MS_UNKNOWN; - for (c = 0, cp = text; c < 5; ++c, ++cp) { - if ((*cp = Getc (s)) == 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) { + if (i == sizeof from-1 && strncmp (text, "From ", sizeof from-1) == 0) { s->msg_style = MS_MBOX; delimstr = "\nFrom "; - while ((c = Getc (s)) != '\n' && c >= 0) continue; - /* 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 */ s->readpos -= s->bytes_read; - delimstr = mmdlm2; + s->bytes_read = 0; + delimstr = MMDF_DELIM; s->msg_style = MS_MMDF; } + c = strlen (delimstr); - s->fdelim = (unsigned char *) mh_xmalloc((size_t) (c + 3)); + s->fdelim = mh_xmalloc (c + 3); /* \0, \n, delimstr, \0 */ *s->fdelim++ = '\0'; *s->fdelim = '\n'; - s->msg_delim = (char *)s->fdelim+1; - s->edelim = (unsigned char *)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->delimend = (unsigned char *)s->msg_delim + s->edelimlen; + 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"); + + /* 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 + */ + /* * 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 = (unsigned char **) calloc (256, sizeof(unsigned char *)); + s->pat_map = (char **) mh_xcalloc (256, sizeof(char *)); - for (cp = (char *) s->fdelim + 1; cp < (char *) s->delimend; cp++ ) - s->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 (s->msg_style == MS_MMDF) { /* flush extra msg hdrs */ - while ((c = Getc(s)) >= 0 && eom (c, s)) + while ((c = Getc(s)) != EOF && eom (c, s)) ; - if (c >= 0) + if (c != EOF) Ungetc(c, s); } @@ -776,45 +864,32 @@ m_unknown(m_getfld_state_t s, FILE *iob) } -void -m_eomsbr (m_getfld_state_t s, int (*action)(int)) -{ - if ((s->eom_action = action)) { - s->msg_style = MS_MSH; - *s->msg_delim = 0; - s->fdelimlen = 1; - s->delimend = s->fdelim; - } else { - s->msg_style = MS_MMDF; - s->msg_delim = (char *)s->fdelim + 1; - s->fdelimlen = strlen((char *)s->fdelim); - s->delimend = (unsigned char *)(s->msg_delim + s->edelimlen); - } -} - - /* * test for msg delimiter string */ static int -m_Eom (m_getfld_state_t s, int c) +m_Eom (m_getfld_state_t s) { - register int i; + int i; char text[MAX_DELIMITER_SIZE]; char *cp; for (i = 0, cp = text; i < s->edelimlen; ++i, ++cp) { - if ((*cp = Getc (s)) == EOF) { + int c2; + + if ((c2 = Getc (s)) == EOF) { + *cp = '\0'; break; } + *cp = c2; } 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; @@ -822,38 +897,15 @@ m_Eom (m_getfld_state_t s, int c) 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; return 0; } if (s->msg_style == MS_MBOX) { - while ((c = Getc (s)) != '\n') - if (c < 0) - break; + int c; + while ((c = Getc(s)) != EOF && c != '\n') + ; } return 1; } - - -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); - } -}