X-Git-Url: http://git.marmaro.de/?p=mmh;a=blobdiff_plain;f=uip%2Fscansbr.c;h=48837d76033fa45a2ac45c0b4258d74c92f8a034;hp=b15c908e368fa517a7c96ed05dd2436150c60072;hb=6e9577f324bef90765a5edc02044eb111ec48072;hpb=c6615b2fbf66e8c99a00330e23747787fb6c35cc diff --git a/uip/scansbr.c b/uip/scansbr.c index b15c908..48837d7 100644 --- a/uip/scansbr.c +++ b/uip/scansbr.c @@ -12,36 +12,16 @@ #include #include #include - -#ifdef _FSTDIO -# define _ptr _p /* Gag */ -# define _cnt _w /* Wretch */ -#endif - -#ifdef SCO_5_STDIO -# define _ptr __ptr -# define _cnt __cnt -# define _base __base -# define _filbuf(fp) ((fp)->__cnt = 0, __filbuf(fp)) -#endif +#include +#include +#include #define MAXSCANL 256 /* longest possible scan line */ -/* -** Buffer size for content part of header fields. We want this -** to be large enough so that we don't do a lot of extra FLDPLUS -** calls on m_getfld but small enough so that we don't snarf -** the entire message body when we're only going to display 30 -** characters of it. -*/ -#define SBUFSIZ 512 - static struct format *fmt; static struct comp *datecomp; /* pntr to "date" comp */ static int ncomps = 0; /* # of interesting components */ -static char **compbuffers = NULL; /* buffers for component text */ -static struct comp **used_buf = NULL; /* stack for comp that use buffers */ static int dat[5]; /* aux. data for format routine */ @@ -49,7 +29,7 @@ char *scanl = NULL; /* text of most recent scanline */ #define FPUTS(buf) {\ if (fputs(buf, scnout) == EOF)\ - adios(scnmsg, "write error on");\ + adios(EX_IOERR, scnmsg, "write error on");\ } /* @@ -67,208 +47,191 @@ int scan(FILE *inb, int innum, int outnum, char *fmtstr, int width, int curflg, int unseen) { - int i, compnum, state; - unsigned char *cp, *tmpbuf; - char **nxtbuf; + static int slwidth; + int compnum, i; + enum state state; + struct field f = {{0}}; + char *cp; struct comp *cptr; - struct comp **savecomp; char *scnmsg = NULL; FILE *scnout = NULL; - char name[NAMESZ]; - static int slwidth; - char returnpath[BUFSIZ]; - char deliverydate[BUFSIZ]; - int incing = (outnum > 0); - int scanfolder = (outnum == 0); + int incing = (outnum != SCN_MBOX && outnum != SCN_FOLD); + int scanfolder = (outnum == SCN_FOLD); + long fpos; + struct stat st; + int blankline; /* first-time only initialization */ if (!scanl) { - if (width == 0) { - if ((width = sc_width()) < WIDTH/2) - width = WIDTH/2; - else if (width > MAXSCANL) - width = MAXSCANL; - } - dat[3] = slwidth = width; - scanl = (char *) mh_xmalloc((size_t) SCAN_CHARWIDTH * - (slwidth + 2) ); if (incing) umask(~m_gmprot()); - /* Compile format string */ - ncomps = fmt_compile(fmtstr, &fmt) + 1; + if (fmtstr) { + if (width == 0) { + if ((width = sc_width()) < WIDTH/2) + width = WIDTH/2; + else if (width > MAXSCANL) + width = MAXSCANL; + } + dat[3] = slwidth = width; + scanl = mh_xcalloc(slwidth + 2, SCAN_CHARWIDTH); /* probably for \n and \0 */ + /* Compile format string */ + ncomps = fmt_compile(fmtstr, &fmt) + 1; + FINDCOMP(datecomp, "date"); + } else { + ncomps = 1; + datecomp = NULL; + } + } - FINDCOMP(datecomp, "date"); - nxtbuf = compbuffers = (char **) calloc((size_t) ncomps, - sizeof(char *)); - if (nxtbuf == NULL) - adios(NULL, "unable to allocate component buffers"); - used_buf = (struct comp **) calloc((size_t) (ncomps+1), - sizeof(struct comp *)); - if (used_buf == NULL) - adios(NULL, "unable to allocate component buffer stack"); - used_buf += ncomps+1; *--used_buf = 0; - for (i = ncomps; i--; ) - *nxtbuf++ = mh_xmalloc(SBUFSIZ); + if (feof(inb)) { + return SCNEOF; } /* ** each-message initialization */ - nxtbuf = compbuffers; - savecomp = used_buf; - tmpbuf = *nxtbuf++; dat[0] = innum ? innum : outnum; dat[1] = curflg; dat[4] = unseen; - - /* - ** Get the first field. If the message is non-empty - ** and we're doing an "inc", open the output file. - */ - if ((state = m_getfld(FLD, name, tmpbuf, SBUFSIZ, inb)) == FILEEOF) { - if (ferror(inb)) { - advise("read", "unable to"); /* "read error" */ - return SCNFAT; - } else { - return SCNEOF; - } - } + fpos = ftell(inb); if (incing) { scnmsg = m_name(outnum); if (*scnmsg == '?') /* msg num out of range */ return SCNNUM; - if ((scnout = fopen(scnmsg, "w")) == NULL) - adios(scnmsg, "unable to write"); - /* - ** Add the Return-Path and Delivery-Date - ** header fields to message. - */ - if (get_returnpath(returnpath, sizeof(returnpath), - deliverydate, sizeof(deliverydate))) { - FPUTS("Return-Path: "); - FPUTS(returnpath); - FPUTS("Delivery-Date: "); - FPUTS(deliverydate); - } + if (!(scnout = fopen(scnmsg, "w"))) + adios(EX_IOERR, scnmsg, "unable to write"); } - /* scan - main loop */ - for (compnum = 1; ; - state = m_getfld(state, name, tmpbuf, SBUFSIZ, inb)) { + for (compnum = 1, state = FLD2; ; ) { + state = m_getfld2(state, &f, inb); switch (state) { - case FLD: - case FLDPLUS: + case LENERR2: + state = FLD2; + /* FALL */ + case FLD2: compnum++; if (incing) { - FPUTS(name); + FPUTS(f.name); FPUTS(":"); - FPUTS(tmpbuf); + FPUTS(f.value); } - /* - ** if we're interested in this component, save - ** a pointer to the component text, then start - ** using our next free buffer as the component - ** temp buffer (buffer switching saves an extra - ** copy of the component text). - */ - if ((cptr = wantcomp[CHASH(name)])) { + if (fmtstr && (cptr = wantcomp[CHASH(f.name)])) { + /* + ** we're interested in this component, + ** but find the right one in the hash + ** collision chain ... + */ do { - if (!mh_strcasecmp(name, cptr->c_name)) { - if (! cptr->c_text) { - cptr->c_text = tmpbuf; - for (cp = tmpbuf + strlen(tmpbuf) - 1; cp >= tmpbuf; cp--) - if (isspace(*cp)) - *cp = 0; - else - break; - *--savecomp = cptr; - tmpbuf = *nxtbuf++; + if (mh_strcasecmp(f.name, cptr->c_name)!=0) { + continue; + } + if (cptr->c_text) { + free(cptr->c_text); + cptr->c_text = NULL; + } + cptr->c_text = mh_xstrdup(f.value); + cp = cptr->c_text + strlen(cptr->c_text) - 1; + for (; cp >= cptr->c_text; cp--) { + if (isspace(*cp)) { + *cp = '\0'; + } else { + break; } - break; } + break; } while ((cptr = cptr->c_next)); } - - while (state == FLDPLUS) { - state = m_getfld(state, name, tmpbuf, SBUFSIZ, - inb); - if (incing) - FPUTS(tmpbuf); - } break; - case BODY: + case BODY2: compnum = -1; - if (!incing) { - state = FILEEOF; /* stop here if scan cmd */ + if (scanfolder) { + /* stop here if we scan a msg in a folder */ + state = FILEEOF2; + goto finished; + } + /* otherwise (mbox): snarf the body */ + if (strncmp("From ", f.value, 5)==0) { + state = FILEEOF2; goto finished; } - FPUTS("\n"); - FPUTS(tmpbuf); - /* - ** performance hack: some people like to run "inc" - ** on things like net.sources or large digests. - ** We do a copy directly into the output buffer - ** rather than going through an intermediate buffer. - ** - ** We need the amount of data m_getfld found & - ** don't want to do a strlen on the long buffer so - ** there's a hack in m_getfld to save the amount - ** of data it returned in the global "msg_count". - */ + if (incing) { + FPUTS("\n"); + FPUTS(f.value); + } body:; - while (state == BODY) { -#ifdef LINUX_STDIO - if (scnout->_IO_write_ptr == scnout->_IO_write_end) { -#elif defined(__DragonFly__) - if (((struct __FILE_public *)scnout)->_w <= 0) { -#else - if (scnout->_cnt <= 0) { -#endif - if (fflush(scnout) == EOF) - adios(scnmsg, "write error on"); + blankline = 0; + while ((state = m_getfld2(state, &f, inb)) == BODY2) { + /* + ** recognize From lines without blank lines + ** before them as well. + */ + if (strncmp("From ", f.value, 5)==0) { + state = FILEEOF2; + goto finished; + } + /* + ** delay the printing of blank lines + ** because if it's the end of the message, + ** then we must omit the blank line, + ** as it is not part of the message but + ** part of the mbox format + */ + if (blankline) { + /* print the delayed blank line */ + FPUTS("\n"); + blankline = 0; + } + if (strcmp(f.value, "\n")==0) { + blankline = 1; + continue; + } + if (incing) { + FPUTS(f.value); } -#ifdef LINUX_STDIO - state = m_getfld(state, name, scnout->_IO_write_ptr, (long)scnout->_IO_write_ptr-(long)scnout->_IO_write_end , inb); - scnout->_IO_write_ptr += msg_count; -#elif defined(__DragonFly__) - state = m_getfld(state, name, ((struct __FILE_public *)scnout)->_p, -(((struct __FILE_public *)scnout)->_w), inb); - ((struct __FILE_public *)scnout)->_w -= msg_count; - ((struct __FILE_public *)scnout)->_p += msg_count; -#else - state = m_getfld(state, name, scnout->_ptr, -(scnout->_cnt), inb); - scnout->_cnt -= msg_count; - scnout->_ptr += msg_count; -#endif } goto finished; - case LENERR: - case FMTERR: - fprintf(stderr, innum ? "??Format error (message %d) in " : "??Format error in ", outnum ? outnum : innum); + case FMTERR2: + if (strncmp("From ", f.value, 5)==0) { + state = FILEEOF2; + goto finished; + } + state = FLD2; + fprintf(stderr, innum ? + "??Format error (message %d) in " : + "??Format error in ", + outnum ? outnum : innum); + fprintf(stderr, "component %d\n", compnum); + continue; + + case IOERR2: + fprintf(stderr, innum ? + "??Format error (message %d) in " : + "??Format error in ", + outnum ? outnum : innum); fprintf(stderr, "component %d\n", compnum); if (incing) { FPUTS("\n\nBAD MSG:\n"); - FPUTS(name); + FPUTS(f.name); /* XXX use f.field? */ FPUTS("\n"); - state = BODY; + state = BODY2; goto body; } /* fall through if we scan only */ - case FILEEOF: + case FILEEOF2: goto finished; default: - adios(NULL, "getfld() returned %d", state); + adios(EX_SOFTWARE, NULL, "getfld() returned %d", state); } } finished: - /* Format and output the scan line. */ if (ferror(inb)) { advise("read", "unable to"); @@ -277,43 +240,48 @@ finished: if (incing) { if ((dat[2] = ftell(scnout)) == EOF) - adios(scnmsg, "write error on"); + adios(EX_IOERR, scnmsg, "write error on"); + } else if (!scanfolder) { + if ((dat[2] = ftell(inb)) == EOF) + adios(EX_IOERR, scnmsg, "write error on"); + dat[2] -= fpos; } - if ((datecomp && !datecomp->c_text) || scanfolder) { - struct stat st; - + if (fmtstr) { fstat(fileno(inb), &st); - if (scanfolder) + if (scanfolder) { dat[2] = st.st_size; - if (datecomp) { + } + if (datecomp && !datecomp->c_text) { if (!datecomp->c_text) { - if (datecomp->c_tws == NULL) - datecomp->c_tws = (struct tws *) calloc((size_t) 1, sizeof(*datecomp->c_tws)); - if (datecomp->c_tws == NULL) - adios(NULL, "unable to allocate tws buffer"); + if (!datecomp->c_tws) + datecomp->c_tws = mh_xcalloc(1, sizeof(*datecomp->c_tws)); + if (!datecomp->c_tws) + adios(EX_OSERR, NULL, "unable to allocate tws buffer"); *datecomp->c_tws = *dlocaltime((time_t *) &st.st_mtime); datecomp->c_flags |= CF_DATEFAB|CF_TRUE; } else { datecomp->c_flags &= ~CF_DATEFAB; } } - } - /* print the scan line */ - fmt_scan(fmt, scanl, slwidth, dat); - if (fmtstr) + /* print the scan line */ + fmt_scan(fmt, scanl, slwidth, dat); fputs(scanl, stdout); + } - /* return dynamically allocated buffers to pool */ - while ((cptr = *savecomp++)) { - *--nxtbuf = cptr->c_text; - cptr->c_text = NULL; + /* clean up old values */ + for (i=0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++) { + for (cptr=wantcomp[i]; cptr; cptr=cptr->c_next) { + if (cptr->c_text) { + free(cptr->c_text); + cptr->c_text = NULL; + } + } } - *--nxtbuf = tmpbuf; if (incing && (ferror(scnout) || fclose(scnout) == EOF)) - adios(scnmsg, "write error on"); + adios(EX_IOERR, scnmsg, "write error on"); - return (state != FILEEOF ? SCNERR : SCNMSG); + return (state == FILEEOF2 ? SCNMSG : SCNERR); }