X-Git-Url: http://git.marmaro.de/?p=mmh;a=blobdiff_plain;f=sbr%2Fm_getfld.c;h=534f896c2d48138787138a741502a9acbab97ade;hp=cddf362b2d582a61b390023e592aab45e1d17bad;hb=e954d689b5adafa4ec74e7dbd1e087dbf998f6d6;hpb=8563731b02ce9d750806f6b1769af8b399d964e8 diff --git a/sbr/m_getfld.c b/sbr/m_getfld.c index cddf362..534f896 100644 --- a/sbr/m_getfld.c +++ b/sbr/m_getfld.c @@ -1,189 +1,194 @@ - /* - * m_getfld.c -- read/parse a message - * - * $Id$ - */ +** 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 - -/* 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 - - c == '\001' && peekc (iob) == '\001' - - 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. - - 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. - - The next thing to do is to read the mts.conf file and initialize - delimiter[] and delimlen accordingly... - - 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. - - 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(). - - ------------------------ - (Written by Van Jacobson for the mh6 m_getfld, January, 1986): - - This routine was accounting for 60% of the cpu time used by most mh - programs. I spent a bit of time tuning and it now accounts for <10% - of the time used. Like any heavily tuned routine, it's a bit - complex and you want to be sure you understand everything that it's - doing before you start hacking on it. Let me try to emphasize - that: every line in this atrocity depends on every other line, - sometimes in subtle ways. You should understand it all, in detail, - before trying to change any part. If you do change it, test the - result thoroughly (I use a hand-constructed test file that exercises - all the ways a header name, header body, header continuation, - header-body separator, body line and body eom can align themselves - with respect to a buffer boundary). "Minor" bugs in this routine - result in garbaged or lost mail. - - 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). - 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). - I have tried to arrange things so that the eom check need only be - done on entry to this routine. Since an eom can only occur after a - newline, this is easy to manage for header fields. For the msg - body, we try to efficiently search the input buffer to see if - contains the eom delimiter. If it does, we take up to the - delimiter, otherwise we take everything in the buffer. (The change - to the body eom/copy processing produced the most noticeable - performance difference, particularly for "inc" and "show".) - - There are three qualitatively different things this routine busts - out of a message: field names, field text and msg bodies. Field - 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 - 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. - - Field text is typically 60 - 100 characters so there's (barely) - a win in doing a routine call to something that does a "locc" - followed by a "bmove". About 30% of the fields have continuations - (usually the 822 "received:" lines) and each continuation generates - another routine call. "Inline" would be a big win here, as well. - - Messages, as of this writing, seem to come in two flavors: small - (~1K) and long (>2K). Most messages have 400 - 600 bytes of headers - 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" - 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" - instruction). Some thought went into recognizing the start of - an eom that has been split across two buffers. - - This routine wants to deal with large chunks of data so, rather - than "getc" into a local buffer, it uses stdio's buffer. If - you try to use it on a non-buffered file, you'll get what you - deserve. This routine "knows" that struct FILEs have a _ptr - and a _cnt to describe the current state of the buffer and - it knows that _filbuf ignores the _ptr & _cnt and simply fills - the buffer. If stdio on your system doesn't work this way, you - may have to make small changes in this routine. - - This routine also "knows" that an EOF indication on a stream is - "sticky" (i.e., you will keep getting EOF until you reposition the - stream). If your system doesn't work this way it is broken and you - should complain to the vendor. As a consequence of the sticky - EOF, this routine will never return any kind of EOF status when - there is data in "name" or "buf"). - */ +#include + +/* +** 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 +** +** c == '\001' && peekc (iob) == '\001' +** +** 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. +** +** 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. +** +** 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): +** +** This routine was accounting for 60% of the cpu time used by most mh +** programs. I spent a bit of time tuning and it now accounts for <10% +** of the time used. Like any heavily tuned routine, it's a bit +** complex and you want to be sure you understand everything that it's +** doing before you start hacking on it. Let me try to emphasize +** that: every line in this atrocity depends on every other line, +** sometimes in subtle ways. You should understand it all, in detail, +** before trying to change any part. If you do change it, test the +** result thoroughly (I use a hand-constructed test file that exercises +** all the ways a header name, header body, header continuation, +** header-body separator, body line and body eom can align themselves +** with respect to a buffer boundary). "Minor" bugs in this routine +** result in garbaged or lost mail. +** +** 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). +** 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). +** I have tried to arrange things so that the eom check need only be +** done on entry to this routine. Since an eom can only occur after a +** newline, this is easy to manage for header fields. For the msg +** body, we try to efficiently search the input buffer to see if +** contains the eom delimiter. If it does, we take up to the +** delimiter, otherwise we take everything in the buffer. (The change +** to the body eom/copy processing produced the most noticeable +** performance difference, particularly for "inc" and "show".) +** +** There are three qualitatively different things this routine busts +** out of a message: field names, field text and msg bodies. Field +** 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 +** 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. +** +** Field text is typically 60 - 100 characters so there's (barely) +** a win in doing a routine call to something that does a "locc" +** followed by a "bmove". About 30% of the fields have continuations +** (usually the 822 "received:" lines) and each continuation generates +** another routine call. "Inline" would be a big win here, as well. +** +** Messages, as of this writing, seem to come in two flavors: small +** (~1K) and long (>2K). Most messages have 400 - 600 bytes of headers +** 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" +** 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" +** instruction). Some thought went into recognizing the start of +** an eom that has been split across two buffers. +** +** This routine wants to deal with large chunks of data so, rather +** than "getc" into a local buffer, it uses stdio's buffer. If +** you try to use it on a non-buffered file, you'll get what you +** deserve. This routine "knows" that struct FILEs have a _ptr +** and a _cnt to describe the current state of the buffer and +** it knows that _filbuf ignores the _ptr & _cnt and simply fills +** the buffer. If stdio on your system doesn't work this way, you +** may have to make small changes in this routine. +** +** This routine also "knows" that an EOF indication on a stream is +** "sticky" (i.e., you will keep getting EOF until you reposition the +** stream). If your system doesn't work this way it is broken and you +** should complain to the vendor. As a consequence of the sticky +** EOF, this routine will never return any kind of EOF status when +** there is data in "name" or "buf"). +*/ /* - * static prototypes - */ -static int m_Eom (int, FILE *); +** static prototypes +*/ +static int m_Eom(int, FILE *); static unsigned char *matchc(int, char *, int, char *); static unsigned char *locc(int, unsigned char *, unsigned char); -#define Getc(iob) getc(iob) -#define eom(c,iob) (msg_style != MS_DEFAULT && \ - (((c) == *msg_delim && m_Eom(c,iob)) ||\ - (eom_action && (*eom_action)(c)))) +#define eom(c,iob) (msg_style != MS_DEFAULT && \ + (((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). - */ +** 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; /* - * defined in sbr/m_msgdef.c = MS_DEFAULT - */ +** defined in sbr/m_msgdef.c = MS_DEFAULT +*/ extern 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. - */ -extern char *msg_delim; /* defined in sbr/m_msgdef.c = "" */ +** 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. +*/ +extern char *msg_delim; /* defined in sbr/m_msgdef.c = "" */ static unsigned char *fdelim; static unsigned char *delimend; static int fdelimlen; static unsigned char *edelim; static int edelimlen; -static int (*eom_action)() = NULL; +static int (*eom_action)(int) = NULL; #ifdef _FSTDIO -# define _ptr _p /* Gag */ -# define _cnt _r /* Retch */ -# define _filbuf __srget /* Puke */ +# define _ptr _p /* Gag */ +# define _cnt _r /* Retch */ +# define _filbuf __srget /* Puke */ +# define DEFINED__FILBUF_TO_SOMETHING_SPECIFIC #endif #ifdef SCO_5_STDIO @@ -191,524 +196,583 @@ static int (*eom_action)() = NULL; # define _cnt __cnt # define _base __base # define _filbuf(fp) ((fp)->__cnt = 0, __filbuf(fp)) +# define DEFINED__FILBUF_TO_SOMETHING_SPECIFIC +#endif + +#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) +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; - - 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)) - ; - if (c >= 0) - ungetc(c, iob); + register unsigned char *bp, *cp, *ep, *sp; + register int cnt, c, i, j; + + if ((c = getc(iob)) < 0) { + msg_count = 0; + *buf = 0; + return FILEEOF; } - msg_count = 0; - *buf = 0; - return FILEEOF; - } - - switch (state) { - case FLDEOF: - case BODYEOF: - case FLD: - if (c == '\n' || c == '-') { - /* we hit the header/body separator */ - while (c != '\n' && (c = Getc(iob)) >= 0) - ; - - if (c < 0 || (c = Getc(iob)) < 0 || eom (c, iob)) { - if (! eom_action) { + 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); - } - msg_count = 0; - *buf = 0; - return FILEEOF; + ungetc(c, iob); + } + msg_count = 0; + *buf = 0; + return FILEEOF; + } + + switch (state) { + case FLDEOF: + case BODYEOF: + case FLD: + if (c == '\n' || c == '-') { + /* we hit the header/body separator */ + while (c != '\n' && (c = getc(iob)) >= 0) + ; + + 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); + } + msg_count = 0; + *buf = 0; + return FILEEOF; + } + state = BODY; + goto body; } - state = BODY; - goto body; - } - /* - * get the name of this component. take characters up - * to a ':', a newline or NAMESZ-1 characters, whichever - * comes first. - */ - cp = name; - i = NAMESZ - 1; - for (;;) { + /* + ** get the name of this component. take characters up + ** to a ':', a newline or NAMESZ-1 characters, + ** whichever comes first. + */ + 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; + 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; + bp = sp = (unsigned char *) iob->_ptr - 1; + j = (cnt = iob->_cnt+1) < i ? cnt : i; #endif - while (--j >= 0 && (c = *bp++) != ':' && c != '\n') - *cp++ = c; + while (--j >= 0 && (c = *bp++) != ':' && c != '\n') + *cp++ = c; - j = bp - sp; - if ((cnt -= j) <= 0) { + j = bp - sp; + if ((cnt -= j) <= 0) { #ifdef LINUX_STDIO - iob->_IO_read_ptr = iob->_IO_read_end; - if (__underflow(iob) == EOF) { + iob->_IO_read_ptr = iob->_IO_read_end; + if (__underflow(iob) == EOF) { +#elif defined(__DragonFly__) + if (__srget(iob) == EOF) { #else - if (_filbuf(iob) == EOF) { + if (_filbuf(iob) == EOF) { #endif - *cp = *buf = 0; - advise (NULL, "eof encountered in field \"%s\"", name); - return FMTERR; - } + *cp = *buf = 0; + advise(NULL, "eof encountered in field \"%s\"", name); + return FMTERR; + } #ifdef LINUX_STDIO - iob->_IO_read_ptr++; /* NOT automatic in __underflow()! */ + iob->_IO_read_ptr++; /* NOT automatic in __underflow()! */ #endif - } else { + } else { #ifdef LINUX_STDIO - iob->_IO_read_ptr = bp + 1; + 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; + iob->_ptr = bp + 1; + iob->_cnt = cnt - 1; #endif + } + 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. + */ + *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'; + /* + ** mhparse.c:get_content wants to find + ** the position of the body start, but + ** it thinks there's a blank line between + ** the header and the body (naturally!), + ** so seek back so that things line up + ** even though we don't have that blank + ** line in this case. Simpler parsers + ** (e.g. mhl) get extra newlines, but + ** that should be harmless enough, right? + ** This is a corrupt message anyway. + */ + fseek(iob, ftell(iob) - 2, SEEK_SET); + return BODY; + } + if ((i -= j) <= 0) { + *cp = *buf = 0; + advise(NULL, "field name \"%s\" exceeds %d bytes", name, NAMESZ - 2); + state = LENERR; + goto finish; + } } - 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') { - *cp = *buf = 0; - advise (NULL, "eol encountered in field \"%s\"", name); - state = FMTERR; - goto finish; - } - if ((i -= j) <= 0) { - *cp = *buf = 0; - advise (NULL, "field name \"%s\" exceeds %d bytes", name, NAMESZ - 1); - state = LENERR; - goto finish; - } - } + while (isspace(*--cp) && cp >= name) + ; + *++cp = 0; + /* fall through */ - while (isspace (*--cp) && cp >= name) - ; - *++cp = 0; - /* fall through */ - - 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. - */ - cp = buf; i = bufsz-1; - for (;;) { + 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. + */ + 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; + 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; + cnt = iob->_cnt++; + bp = (unsigned char *) --iob->_ptr; #endif - c = cnt < i ? cnt : i; - while ((ep = locc( c, bp, '\n' ))) { - /* - * if we hit the end of this field, return. - */ - if ((j = *++ep) != ' ' && j != '\t') { + c = cnt < i ? cnt : i; + while ((ep = locc( c, bp, '\n' ))) { + /* + ** if we hit the end of this field, + ** 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; + 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; + j = ep - (unsigned char *) iob->_ptr; + memcpy(cp, iob->_ptr, j); + iob->_ptr = ep; + iob->_cnt -= j; #endif - cp += j; - state = FLD; - goto finish; - } - c -= ep - bp; - bp = ep; - } - /* - * end of input or dest buffer - copy what we've found. - */ + cp += j; + state = FLD; + goto finish; + } + c -= ep - bp; + bp = ep; + } + /* + ** 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); + 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); + c += bp - (unsigned char *) iob->_ptr; + memcpy(cp, iob->_ptr, c); #endif - i -= c; - cp += c; - if (i <= 0) { - /* the dest buffer is full */ + i -= c; + cp += c; + if (i <= 0) { + /* the dest buffer is full */ #ifdef LINUX_STDIO - iob->_IO_read_ptr += c; + 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; + 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. - */ - --i; + 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. + */ + --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! */ + *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); + *cp++ = j = *(iob->_ptr + c); + c = _filbuf(iob); #endif - if (c == EOF || - ((j == '\0' || j == '\n') && c != ' ' && c != '\t')) { - if (c != EOF) { + if (c == EOF || + ((j == '\0' || j == '\n') && c != ' ' && c != '\t')) { + if (c != EOF) { #ifdef LINUX_STDIO - --iob->_IO_read_ptr; + --iob->_IO_read_ptr; +#elif defined(__DragonFly__) + --((struct __FILE_public *)iob)->_p; + ++((struct __FILE_public *)iob)->_r; #else - --iob->_ptr; - ++iob->_cnt; + --iob->_ptr; + ++iob->_cnt; #endif - } - state = FLD; - break; + } + state = FLD; + break; + } } - } - break; + break; - case BODY: + case BODY: body: - /* - * get the message body up to bufsz characters or the - * end of the message. Sleazy hack: if bufsz is negative - * we assume that we were called to copy directly into - * the output buffer and we don't add an eos. - */ - i = (bufsz < 0) ? -bufsz : bufsz-1; + /* + ** get the message body up to bufsz characters or + ** the end of the message. Sleazy hack: if bufsz + ** is negative we assume that we were called to + ** copy directly into the output buffer and we + ** 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; + 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; + bp = (unsigned char *) --iob->_ptr; + cnt = ++iob->_cnt; #endif - c = (cnt < i ? cnt : i); - if (msg_style != MS_DEFAULT && c > 1) { - /* - * packed maildrop - only take up to the (possible) - * start of the next message. This "matchc" should - * probably be a Boyer-Moore matcher for non-vaxen, - * particularly since we have the alignment table - * all built for the end-of-buffer test (next). - * But our vax timings indicate that the "matchc" - * instruction is 50% faster than a carefully coded - * B.M. matcher for most strings. (So much for elegant - * 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 ))) - c = ep - bp + 1; - else { - /* - * There's no delim in the buffer but there may be - * a partial one at the end. If so, we want to leave - * it so the "eom" check on the next call picks it up. - * Use a modified Boyer-Moore matcher to make this - * check relatively cheap. The first "if" figures - * out what position in the pattern matches the last - * character in the buffer. The inner "while" matches - * the pattern against the buffer, backwards starting - * at that position. Note that unless the buffer - * 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])) { - do { - cp = sp; - while (*--ep == *--cp) - ; - if (cp < fdelim) { - if (ep >= bp) - /* - * ep < bp means that all the buffer - * contains is a prefix of delim. - * If this prefix is really a delim, the - * m_eom call at entry should have found - * it. Thus it's not a delim and we can - * take all of it. - */ - c = (ep - bp) + 2; - break; + c = (cnt < i ? cnt : i); + if (msg_style != MS_DEFAULT && c > 1) { + /* + ** packed maildrop - only take up to the (possible) + ** start of the next message. This "matchc" should + ** probably be a Boyer-Moore matcher for non-vaxen, + ** particularly since we have the alignment table + ** all built for the end-of-buffer test (next). + ** But our vax timings indicate that the "matchc" + ** instruction is 50% faster than a carefully coded + ** B.M. matcher for most strings. (So much for + ** elegant 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 ))) + c = ep - bp + 1; + else { + /* + ** There's no delim in the buffer but + ** there may be a partial one at the end. + ** If so, we want to leave it so the "eom" + ** check on the next call picks it up. Use a + ** modified Boyer-Moore matcher to make this + ** check relatively cheap. The first "if" + ** figures out what position in the pattern + ** matches the last character in the buffer. + ** The inner "while" matches the pattern + ** against the buffer, backwards starting + ** at that position. Note that unless the + ** buffer 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])) { + do { + /* + ** This if() is true unless + ** (a) the buffer is too + ** small to contain this + ** delimiter prefix, + ** or (b) it contains + ** exactly enough chars for + ** the delimiter prefix. + ** For case (a) obviously we + ** aren't going to match. + ** For case (b), if the + ** buffer really contained + ** exactly a delim prefix, + ** then the m_eom call + ** at entry should have + ** found it. Thus it's + ** not a delim and we know + ** we won't get a match. + */ + if (((sp - fdelim) + 2) <= c) { + cp = sp; + /* + ** Unfortunately although fdelim has a preceding NUL + ** we can't use this as a sentinel in case the buffer + ** contains a NUL in exactly the wrong place (this + ** would cause us to run off the front of fdelim). + */ + while (*--ep == *--cp) + if (cp < fdelim) + break; + if (cp < fdelim) { + /* we matched the entire delim prefix, + ** so only take the buffer up to there. + ** we know ep >= bp -- check above prevents underrun + */ + c = (ep - bp) + 2; + break; + } + } + /* try matching one less char of delim string */ + ep = bp + c - 1; + } while (--sp > fdelim); + } } - /* try matching one less char of delim string */ - ep = bp + c - 1; - } while (--sp > fdelim); - } } - } - memcpy( buf, bp, c ); + memcpy( buf, bp, c ); #ifdef LINUX_STDIO - iob->_IO_read_ptr += c; + 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; + iob->_cnt -= c; + iob->_ptr += c; #endif - if (bufsz < 0) { - msg_count = c; - return (state); - } - cp = buf + c; - break; - - default: - adios (NULL, "m_getfld() called with bogus state of %d", state); - } + if (bufsz < 0) { + msg_count = c; + return (state); + } + cp = buf + c; + break; + + default: + adios(NULL, "m_getfld() called with bogus state of %d", state); + } finish: - *cp = 0; - msg_count = cp - buf; - return (state); + *cp = 0; + msg_count = cp - buf; + return (state); } - -#ifdef RPATHS static char unixbuf[BUFSIZ] = ""; -#endif /* RPATHS */ void m_unknown(FILE *iob) { - register int c; - register long pos; - char text[10]; - register char *cp; - register char *delimstr; + register int c; + register long pos; + char text[10]; + register char *cp; + register 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 - * we say the style is MMDF and look for the delimiter string - * specified when nmh was built (or from the mts.conf file). - */ - - 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 "; -#ifndef RPATHS - while ((c = getc (iob)) != '\n' && c >= 0) - ; -#else /* RPATHS */ - cp = unixbuf; - while ((c = getc (iob)) != '\n' && cp - unixbuf < BUFSIZ - 1) - *cp++ = c; - *cp = 0; -#endif /* RPATHS */ - } else { - /* not a Unix style maildrop */ - fseek (iob, pos, SEEK_SET); - if (mmdlm2 == NULL || *mmdlm2 == 0) - mmdlm2 = "\001\001\001\001\n"; - delimstr = mmdlm2; - msg_style = MS_MMDF; - } - c = strlen (delimstr); - fdelim = (unsigned char *) malloc((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; - strcpy (msg_delim, delimstr); - delimend = (unsigned char *)msg_delim + edelimlen; - if (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 *)); - - for (cp = (char *) fdelim + 1; cp < (char *) delimend; cp++ ) - pat_map[*cp] = (unsigned char *) cp; - - if (msg_style == MS_MMDF) { - /* flush extra msg hdrs */ - while ((c = Getc(iob)) >= 0 && eom (c, iob)) - ; - if (c >= 0) - ungetc(c, iob); - } -} - - -void -m_eomsbr (int (*action)()) -{ - 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); - } +** 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. +*/ + + 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 = 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; + strcpy(msg_delim, delimstr); + delimend = (unsigned char *)msg_delim + edelimlen; + if (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 *)); + + for (cp = (char *) fdelim + 1; cp < (char *) delimend; cp++ ) + pat_map[(unsigned char)*cp] = (unsigned char *) cp; } /* - * test for msg delimiter string - */ +** test for msg delimiter string +*/ static int -m_Eom (int c, FILE *iob) +m_Eom(int c, FILE *iob) { - register long pos = 0L; - register int i; - char text[10]; -#ifdef RPATHS - register char *cp; -#endif /* RPATHS */ - - pos = ftell (iob); - if ((i = fread (text, sizeof *text, edelimlen, iob)) != edelimlen - || strncmp (text, (char *)edelim, edelimlen)) { - if (i == 0 && msg_style == MS_MBOX) - /* the final newline in the (brain damaged) unix-format - * maildrop is part of the delimitter - delete it. - */ - return 1; - -#if 0 - fseek (iob, pos, SEEK_SET); -#endif - - fseek (iob, (long)(pos-1), SEEK_SET); - getc (iob); /* should be OK */ - return 0; - } + register long pos = 0L; + register int i; + char text[10]; + register 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) + /* + ** 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 */ + return 0; + } - if (msg_style == MS_MBOX) { -#ifndef RPATHS - while ((c = getc (iob)) != '\n') - if (c < 0) - break; -#else /* RPATHS */ - cp = unixbuf; - while ((c = getc (iob)) != '\n' && c >= 0 && cp - unixbuf < BUFSIZ - 1) - *cp++ = c; - *cp = 0; -#endif /* RPATHS */ - } + 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 1; } -#ifdef RPATHS /* - * 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) - */ +** 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) +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; + 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; + } } - } - - /* - * 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", dp - cp, cp, bp - ap, ap); - } else { - /* return path for standard domain addressing */ - snprintf (rp, rplen, "%.*s\n", 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; + + /* + ** 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; } -#endif /* RPATHS */ static unsigned char * @@ -724,26 +788,27 @@ matchc(int patln, char *pat, int strln, char *str) 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) + if (pp >= ep) return ((unsigned char *)--str); } } /* - * Locate character "term" in the next "cnt" characters of "src". - * If found, return its address, otherwise return 0. - */ +** Locate character "term" in the next "cnt" characters of "src". +** If found, return its address, otherwise return 0. +*/ static unsigned char * locc(int cnt, unsigned char *src, unsigned char term) { - while (*src++ != term && --cnt > 0); + while (*src++ != term && --cnt > 0) + ; - return (cnt > 0 ? --src : (unsigned char *)0); + return (cnt > 0 ? --src : (unsigned char *)0); } -