/*
* replsbr.c -- routines to help repl along...
*
- * $Id$
+ * 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 <h/mh.h>
#include <h/addrsbr.h>
#include <h/fmt_scan.h>
+#include <h/utils.h>
#include <sys/file.h> /* L_SET */
+#include <errno.h>
extern short ccto; /* from repl.c */
extern short cccc;
static char *badaddrs = NULL;
static char *dfhost = NULL;
-static struct mailname mq = { NULL };
+static struct mailname mq;
+static int nodupcheck = 0; /* If set, no check for duplicates */
/*
* Buffer size for content part of header fields.
*/
#define SBUFSIZ 256
-static struct format *fmt;
-
-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 */
-
static char *addrcomps[] = {
"from",
"sender",
* static prototypes
*/
static int insert (struct mailname *);
-static void replfilter (FILE *, FILE *, char *);
+static void replfilter (FILE *, FILE *, char *, int);
void
replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
- int mime, char *form, char *filter, char *fcc)
+ int mime, char *form, char *filter, char *fcc, int fmtproc)
{
register int state, i;
register struct comp *cptr;
- register char *tmpbuf;
- register char **nxtbuf;
+ char tmpbuf[SBUFSIZ];
+ struct format *fmt;
register char **ap;
- register struct comp **savecomp;
- int char_read = 0, format_len;
- char name[NAMESZ], *scanl, *cp;
+ int char_read = 0, format_len, mask;
+ char name[NAMESZ], *scanl;
+ unsigned char *cp;
+ static int dat[5]; /* aux. data for format routine */
+
FILE *out;
+ NMH_UNUSED (msg);
- umask(~m_gmprot());
+ mask = umask(~m_gmprot());
if ((out = fopen (drft, "w")) == NULL)
adios (drft, "unable to create");
+ umask(mask);
+
/* get new format string */
cp = new_fs (form, NULL, NULL);
format_len = strlen (cp);
/* compile format string */
- ncomps = fmt_compile (cp, &fmt) + 1;
-
- if (!(nxtbuf = compbuffers = (char **)
- calloc((size_t) ncomps, sizeof(char *))))
- adios (NULL, "unable to allocate component buffers");
- if (!(savecomp = used_buf = (struct comp **)
- calloc((size_t) (ncomps+1), sizeof(struct comp *))))
- adios (NULL, "unable to allocate component buffer stack");
- savecomp += ncomps + 1;
- *--savecomp = NULL; /* point at zero'd end minus 1 */
-
- for (i = ncomps; i--; )
- if (!(*nxtbuf++ = malloc(SBUFSIZ)))
- adios (NULL, "unable to allocate component buffer");
-
- nxtbuf = compbuffers; /* point at start */
- tmpbuf = *nxtbuf++;
+ fmt_compile (cp, &fmt, 1);
for (ap = addrcomps; *ap; ap++) {
- FINDCOMP (cptr, *ap);
+ cptr = fmt_findcomp (*ap);
if (cptr)
cptr->c_type |= CT_ADDR;
}
/*
* ignore any components killed by command line switches
+ *
+ * This prevents the component from being found via fmt_findcomp(),
+ * which makes sure no text gets added to it when the message is processed.
+ *
+ * getcpy(NULL) returns a malloc'd zero-length string, so it can safely
+ * be free()'d later.
*/
if (!ccto) {
- FINDCOMP (cptr, "to");
+ cptr = fmt_findcomp ("to");
if (cptr)
- cptr->c_name = "";
+ cptr->c_name = getcpy(NULL);
}
if (!cccc) {
- FINDCOMP (cptr, "cc");
+ cptr = fmt_findcomp("cc");
if (cptr)
- cptr->c_name = "";
+ cptr->c_name = getcpy(NULL);
}
/* set up the "fcc" pseudo-component */
if (fcc) {
- FINDCOMP (cptr, "fcc");
+ cptr = fmt_findcomp ("fcc");
if (cptr)
cptr->c_text = getcpy (fcc);
}
if ((cp = getenv("USER"))) {
- FINDCOMP (cptr, "user");
+ cptr = fmt_findcomp ("user");
if (cptr)
cptr->c_text = getcpy(cp);
}
* pick any interesting stuff out of msg "inb"
*/
for (state = FLD;;) {
- state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb);
+ state = m_getfld (state, name, tmpbuf, sizeof(tmpbuf), inb);
switch (state) {
case FLD:
case FLDPLUS:
* buffer as the component temp buffer (buffer switching
* saves an extra copy of the component text).
*/
- if ((cptr = wantcomp[CHASH(name)]))
- do {
- if (!strcasecmp(name, cptr->c_name)) {
- char_read += msg_count;
- if (! cptr->c_text) {
- cptr->c_text = tmpbuf;
- *--savecomp = cptr;
- tmpbuf = *nxtbuf++;
- } else {
- i = strlen (cp = cptr->c_text) - 1;
- if (cp[i] == '\n') {
- if (cptr->c_type & CT_ADDR) {
- cp[i] = '\0';
- cp = add (",\n\t", cp);
- } else {
- cp = add ("\t", cp);
- }
- }
- cptr->c_text = add (tmpbuf, cp);
- }
- while (state == FLDPLUS) {
- state = m_getfld (state, name, tmpbuf,
- SBUFSIZ, inb);
- cptr->c_text = add (tmpbuf, cptr->c_text);
- char_read += msg_count;
- }
- break;
- }
- } while ((cptr = cptr->c_next));
+
+ i = fmt_addcomptext(name, tmpbuf);
+ if (i != -1) {
+ char_read += msg_count;
+ while (state == FLDPLUS) {
+ state = m_getfld(state, name, tmpbuf,
+ sizeof(tmpbuf), inb);
+ fmt_appendcomp(i, name, tmpbuf);
+ char_read += msg_count;
+ }
+ }
while (state == FLDPLUS)
state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb);
/*
* if there's a "Subject" component, strip any "Re:"s off it
*/
- FINDCOMP (cptr, "subject")
+ cptr = fmt_findcomp ("subject");
if (cptr && (cp = cptr->c_text)) {
register char *sp = cp;
}
}
i = format_len + char_read + 256;
- scanl = malloc ((size_t) i + 2);
+ scanl = mh_xmalloc ((size_t) i + 2);
dat[0] = 0;
dat[1] = 0;
dat[2] = 0;
dat[3] = outputlinelen;
dat[4] = 0;
- fmt_scan (fmt, scanl, i, dat);
+ fmt_scan (fmt, scanl, i + 1, i, dat);
fputs (scanl, out);
if (badaddrs) {
fputs ("\nrepl: bad addresses:\n", out);
* or add mhn directives
*/
if (filter) {
- replfilter (inb, out, filter);
+ fflush(out);
+ if (ferror (out))
+ adios (drft, "error writing");
+
+ replfilter (inb, out, filter, fmtproc);
} else if (mime && mp) {
fprintf (out, "#forw [original message] +%s %s\n",
mp->foldpath, m_name (mp->lowsel));
}
+ fflush(out);
if (ferror (out))
adios (drft, "error writing");
fclose (out);
/* return dynamically allocated buffers */
free (scanl);
- for (nxtbuf = compbuffers, i = ncomps; (cptr = *savecomp++); nxtbuf++, i--)
- free (cptr->c_text); /* if not nxtbuf, nxtbuf already freed */
- while ( i-- > 0)
- free (*nxtbuf++); /* free unused nxtbufs */
- free ((char *) compbuffers);
- free ((char *) used_buf);
+ fmt_free(fmt, 1);
}
static char *buf; /* our current working buffer */
int i = dst - buf;\
int n = last_dst - buf;\
bufsiz += ((dst + len - bufend) / BUFINCR + 1) * BUFINCR;\
- buf = realloc (buf, bufsiz);\
+ buf = mh_xrealloc (buf, bufsiz);\
dst = buf + i;\
last_dst = buf + n;\
- if (! buf)\
- adios (NULL, "formataddr: couldn't get buffer space");\
bufend = buf + bufsiz;\
}
/* if we don't have a buffer yet, get one */
if (bufsiz == 0) {
- buf = malloc (BUFINCR);
- if (! buf)
- adios (NULL, "formataddr: couldn't allocate buffer space");
+ buf = mh_xmalloc (BUFINCR);
last_dst = buf; /* XXX */
bufsiz = BUFINCR - 6; /* leave some slop */
bufend = buf + bufsiz;
}
+/*
+ * fmt_scan will call this routine if the user includes the function
+ * "(concataddr {component})" in a format string. This behaves exactly
+ * like formataddr, except that it does NOT suppress duplicate addresses
+ * between calls.
+ *
+ * As an implementation detail: I thought about splitting out formataddr()
+ * into the generic part and duplicate-suppressing part, but the call to
+ * insert() was buried deep within a couple of loops and I didn't see a
+ * way to do it easily. So instead we simply set a special flag to stop
+ * the duplicate check and call formataddr().
+ */
+char *
+concataddr(char *orig, char *str)
+{
+ char *cp;
+
+ nodupcheck = 1;
+ cp = formataddr(orig, str);
+ nodupcheck = 0;
+ return cp;
+}
+
static int
insert (struct mailname *np)
{
char buffer[BUFSIZ];
register struct mailname *mp;
+ if (nodupcheck)
+ return 1;
+
if (np->m_mbox == NULL)
return 0;
for (mp = &mq; mp->m_next; mp = mp->m_next) {
- if (!strcasecmp (np->m_host, mp->m_next->m_host)
- && !strcasecmp (np->m_mbox, mp->m_next->m_mbox))
+ if (!mh_strcasecmp (np->m_host, mp->m_next->m_host)
+ && !mh_strcasecmp (np->m_mbox, mp->m_next->m_mbox))
return 0;
}
if (!ccme && ismymbox (np))
}
mp->m_next = np;
-#ifdef ISI
- if (ismymbox (np))
- ccme = 0;
-#endif
-
return 1;
}
/*
* Call the mhlproc
+ *
+ * This function expects that argument out has been fflushed by the caller.
*/
static void
-replfilter (FILE *in, FILE *out, char *filter)
+replfilter (FILE *in, FILE *out, char *filter, int fmtproc)
{
int pid;
char *mhl;
+ char *errstr;
+ char *arglist[7];
if (filter == NULL)
return;
rewind (in);
lseek (fileno(in), (off_t) 0, SEEK_SET);
- fflush (out);
- switch (pid = vfork ()) {
+ switch (pid = vfork()) {
case NOTOK:
adios ("fork", "unable to");
dup2 (fileno (out), fileno (stdout));
closefds (3);
- execlp (mhlproc, mhl, "-form", filter, "-noclear", NULL);
- fprintf (stderr, "unable to exec ");
- perror (mhlproc);
+ arglist[0] = mhl;
+ arglist[1] = "-form";
+ arglist[2] = filter;
+ arglist[3] = "-noclear";
+
+ switch (fmtproc) {
+ case 1:
+ arglist[4] = "-fmtproc";
+ arglist[5] = formatproc;
+ arglist[6] = NULL;
+ break;
+ case 0:
+ arglist[4] = "-nofmtproc";
+ arglist[5] = NULL;
+ break;
+ default:
+ arglist[4] = NULL;
+ }
+
+ execvp (mhlproc, arglist);
+ errstr = strerror(errno);
+ write(2, "unable to exec ", 15);
+ write(2, mhlproc, strlen(mhlproc));
+ write(2, ": ", 2);
+ write(2, errstr, strlen(errstr));
+ write(2, "\n", 1);
_exit (-1);
default:
projects / mmh / blobdiff