static void
seq_public (struct msgs *mp, int lockflag)
{
int state;
char *cp, seqfile[PATH_MAX];
char name[NAMESZ], field[BUFSIZ];
FILE *fp;
m_getfld_state_t gstate = 0;
/*
* If mh_seq == NULL or if *mh_seq == '\0' (the user has defined
* the "mh-sequences" profile entry, but left it empty),
* then just return, and do not initialize any public sequences.
*/
if (mh_seq == NULL || *mh_seq == '\0')
return;
/* get filename of sequence file */
snprintf (seqfile, sizeof(seqfile), "%s/%s", mp->foldpath, mh_seq);
if ((fp = lkfopendata (seqfile, lockflag ? "r+" : "r")) == NULL)
return;
/* Use m_getfld to scan sequence file */
for (;;) {
int fieldsz = sizeof field;
switch (state = m_getfld (&gstate, name, field, &fieldsz, fp)) {
case FLD:
case FLDPLUS:
if (state == FLDPLUS) {
cp = getcpy (field);
while (state == FLDPLUS) {
fieldsz = sizeof field;
state = m_getfld (&gstate, name, field, &fieldsz, fp);
cp = add (field, cp);
}
seq_init (mp, getcpy (name), trimcpy (cp));
free (cp);
} else {
seq_init (mp, getcpy (name), trimcpy (field));
}
continue;
case BODY:
lkfclosedata (fp, seqfile);
adios (NULL, "no blank lines are permitted in %s", seqfile);
/* fall */
case FILEEOF:
break;
default:
lkfclosedata (fp, seqfile);
adios (NULL, "%s is poorly formatted", seqfile);
}
break; /* break from for loop */
}
m_getfld_state_destroy (&gstate);
if (lockflag) {
mp->seqhandle = fp;
mp->seqname = getcpy(seqfile);
} else {
lkfclosedata (fp, seqfile);
}
}
int
scan (FILE *inb, int innum, int outnum, char *nfs, int width, int curflg,
int unseen, char *folder, long size, int noisy)
{
int i, compnum, encrypted, state;
char *cp, *tmpbuf, *startbody, **nxtbuf;
char *saved_c_text = NULL;
struct comp *cptr;
struct comp **savecomp;
char *scnmsg = NULL;
FILE *scnout = NULL;
char name[NAMESZ];
int bufsz;
static int rlwidth, slwidth;
static size_t scanl_size;
/* 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;
/* Arbitrarily allocate 20 * slwidth to provide room for lots
of escape sequences. */
scanl_size = SCAN_CHARWIDTH * (20 * slwidth + 2);
scanl = (char *) mh_xmalloc (scanl_size);
if (outnum)
umask(~m_gmprot());
/* Compile format string */
ncomps = fmt_compile (nfs, &fmt, 1) + 2;
bodycomp = fmt_findcomp("body");
datecomp = fmt_findcomp("date");
cptr = fmt_findcomp("folder");
if (cptr && folder)
cptr->c_text = getcpy(folder);
if (fmt_addcompentry("encrypted")) {
ncomps++;
}
cptr = fmt_findcomp("dtimenow");
if (cptr)
cptr->c_text = getcpy(dtimenow (0));
/*
* In other programs I got rid of this complicated buffer switching,
* but since scan reads lots of messages at once and this complicated
* memory management, I decided to keep it; otherwise there was
* the potential for a lot of malloc() and free()s, and I could
* see the malloc() pool really getting fragmented. Maybe it
* wouldn't be an issue in practice; perhaps this will get
* revisited someday.
*
* So, some notes for what's going on:
*
* nxtbuf is an array of pointers that contains malloc()'d buffers
* to hold our component text. used_buf is an array of struct comp
* pointers that holds pointers to component structures we found while
* processing a message.
*
* We read in the message with m_getfld(), using "tmpbuf" as our
* input buffer. tmpbuf is set at the start of message processing
* to the first buffer in our buffer pool (nxtbuf).
*
* Every time we find a component we care about, we set that component's
* text buffer to the current value of tmpbuf, and then switch tmpbuf
* to the next buffer in our pool. We also add that component to
* our used_buf pool.
*
* When we're done, we go back and zero out all of the component
* text buffer pointers that we saved in used_buf.
*
* Note that this means c_text memory is NOT owned by the fmt_module
* and it's our responsibility to free it.
*/
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;
rlwidth = bodycomp && (width > SBUFSIZ) ? width : SBUFSIZ;
for (i = ncomps; i--; )
*nxtbuf++ = mh_xmalloc(rlwidth);
}
/*
* each-message initialization
*/
nxtbuf = compbuffers;
savecomp = used_buf;
tmpbuf = *nxtbuf++;
startbody = NULL;
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.
*/
bufsz = rlwidth;
m_getfld_state_reset (&gstate);
if ((state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb)) == FILEEOF) {
if (ferror(inb)) {
advise("read", "unable to"); /* "read error" */
return SCNFAT;
} else {
return SCNEOF;
}
}
if (outnum) {
if (outnum > 0) {
scnmsg = m_name (outnum);
if (*scnmsg == '?') /* msg num out of range */
return SCNNUM;
} else {
scnmsg = "/dev/null";
}
if ((scnout = fopen (scnmsg, "w")) == NULL)
adios (scnmsg, "unable to write");
}
/* scan - main loop */
for (compnum = 1; ;
bufsz = rlwidth, state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb)) {
switch (state) {
case FLD:
case FLDPLUS:
compnum++;
if (outnum) {
FPUTS (name);
if ( putc (':', scnout) == EOF) DIEWRERR();
FPUTS (tmpbuf);
}
/*
* 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 = fmt_findcasecomp(name))) {
if (! cptr->c_text) {
cptr->c_text = tmpbuf;
for (cp = tmpbuf + strlen (tmpbuf) - 1;
cp >= tmpbuf; cp--)
if (isspace ((unsigned char) *cp))
*cp = 0;
else
break;
*--savecomp = cptr;
tmpbuf = *nxtbuf++;
}
}
while (state == FLDPLUS) {
bufsz = rlwidth;
state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb);
if (outnum)
FPUTS (tmpbuf);
}
break;
case BODY:
compnum = -1;
/*
* A slight hack ... if we have less than rlwidth characters
* in the buffer, call m_getfld again.
*/
if ((i = strlen(tmpbuf)) < rlwidth) {
bufsz = rlwidth - i;
state = m_getfld (&gstate, name, tmpbuf + i, &bufsz, inb);
}
if (! outnum) {
state = FILEEOF; /* stop now if scan cmd */
if (bodycomp && startbody == NULL)
startbody = tmpbuf;
goto finished;
}
if (putc ('\n', scnout) == EOF) DIEWRERR();
FPUTS (tmpbuf);
/*
* The previous code here used to call m_getfld() using
* pointers to the underlying output stdio buffers to
* avoid the extra copy. Tests by Markus Schnalke show
* no noticable performance loss on larger mailboxes
* if we incur an extra copy, and messing around with
* internal stdio buffers is becoming more and more
* unportable as times go on. So from now on just deal
* with the overhead of an extra copy.
*
* Subtle change - with the previous code tmpbuf wasn't
* used, so we could reuse it for the {body} component.
* Now since we're using tmpbuf as our read buffer we
* need to save the beginning of the body for later.
* See the above (and below) use of startbody.
*/
body:;
if (bodycomp && startbody == NULL) {
startbody = tmpbuf;
tmpbuf = *nxtbuf++;
}
while (state == BODY) {
bufsz = rlwidth;
state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb);
FPUTS(tmpbuf);
}
goto finished;
case LENERR:
case FMTERR:
if (innum)
fprintf (stderr, "??Format error (message %d) in ",
outnum ? outnum : innum);
else
fprintf (stderr, "??Format error in ");
fprintf (stderr, "component %d\n", compnum);
if (outnum) {
FPUTS ("\n\nBAD MSG:\n");
FPUTS (name);
if (putc ('\n', scnout) == EOF) DIEWRERR();
state = BODY;
goto body;
}
/* fall through */
case FILEEOF:
goto finished;
default:
adios (NULL, "getfld() returned %d", state);
}
}
/*
* format and output the scan line.
*/
finished:
if (ferror(inb)) {
advise("read", "unable to"); /* "read error" */
return SCNFAT;
}
/* Save and restore buffer so we don't trash our dynamic pool! */
if (bodycomp) {
saved_c_text = bodycomp->c_text;
bodycomp->c_text = startbody;
}
if (size)
dat[2] = size;
else if (outnum > 0)
{
dat[2] = ftell(scnout);
if (dat[2] == EOF) DIEWRERR();
}
if ((datecomp && !datecomp->c_text) || (!size && !outnum)) {
struct stat st;
fstat (fileno(inb), &st);
if (!size && !outnum)
dat[2] = st.st_size;
if (datecomp) {
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");
*datecomp->c_tws = *dlocaltime ((time_t *) &st.st_mtime);
datecomp->c_flags |= CF_DATEFAB|CF_TRUE;
} else {
datecomp->c_flags &= ~CF_DATEFAB;
}
}
}
fmt_scan (fmt, scanl, scanl_size, slwidth, dat, NULL);
if (bodycomp)
bodycomp->c_text = saved_c_text;
if (noisy)
fputs (scanl, stdout);
cptr = fmt_findcomp ("encrypted");
encrypted = cptr && cptr->c_text;
/* return dynamically allocated buffers to pool */
while ((cptr = *savecomp++)) {
cptr->c_text = NULL;
}
if (outnum && (ferror(scnout) || fclose (scnout) == EOF))
DIEWRERR();
return (state != FILEEOF ? SCNERR : encrypted ? SCNENC : SCNMSG);
}
void
readconfig (struct node **npp, FILE *ib, char *file, int ctx)
{
register int state;
register char *cp;
char name[NAMESZ], field[BUFSIZ];
register struct node *np;
register struct procstr *ps;
if (npp == NULL && (npp = opp) == NULL) {
admonish (NULL, "bug: readconfig called but pump not primed");
return;
}
for (state = FLD;;) {
switch (state = m_getfld (state, name, field, sizeof(field), ib)) {
case FLD:
case FLDPLUS:
case FLDEOF:
np = (struct node *) mh_xmalloc (sizeof(*np));
*npp = np;
*(npp = &np->n_next) = NULL;
np->n_name = getcpy (name);
if (state == FLDPLUS) {
cp = getcpy (field);
while (state == FLDPLUS) {
state = m_getfld (state, name, field, sizeof(field), ib);
cp = add (field, cp);
}
np->n_field = trimcpy (cp);
free (cp);
} else {
np->n_field = trimcpy (field);
}
np->n_context = ctx;
/*
* Now scan the list of `procs' and link in the
* field value to the global variable.
*/
for (ps = procs; ps->procname; ps++)
if (strcmp (np->n_name, ps->procname) == 0) {
*ps->procnaddr = np->n_field;
break;
}
if (state == FLDEOF)
break;
continue;
case BODY:
case BODYEOF:
adios (NULL, "no blank lines are permitted in %s", file);
case FILEEOF:
break;
default:
adios (NULL, "%s is poorly formatted", file);
}
break;
}
opp = npp;
}
