X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/19b47ea980a98d01112d4bda1d220c7057818ff1..98782146f689a059d5e81636ff2ab55babc2e8ff:/uip/replsbr.c diff --git a/uip/replsbr.c b/uip/replsbr.c index a7616d35..9e3183e4 100644 --- a/uip/replsbr.c +++ b/uip/replsbr.c @@ -1,8 +1,4 @@ - -/* - * replsbr.c -- routines to help repl along... - * - * $Id$ +/* replsbr.c -- routines to help repl along... * * This code is Copyright (c) 2002, by the authors of nmh. See the * COPYRIGHT file in the root directory of the nmh distribution for @@ -12,6 +8,7 @@ #include #include #include +#include #include /* L_SET */ extern short ccto; /* from repl.c */ @@ -24,7 +21,8 @@ static int dftype=0; 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. @@ -35,14 +33,6 @@ static struct mailname mq = { NULL }; */ #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", @@ -63,22 +53,30 @@ static char *addrcomps[] = { * static prototypes */ static int insert (struct mailname *); -static void replfilter (FILE *, FILE *, char *); +static void replfilter (FILE *, FILE *, char *, int); +static char *replformataddr(char *, char *); +static char *replconcataddr(char *, char *); +static char *fix_addresses (char *); 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; - register char **ap; - register struct comp **savecomp; + int state, i; + struct comp *cptr; + char tmpbuf[SBUFSIZ]; + struct format *fmt; + char **ap; int char_read = 0, format_len, mask; - char name[NAMESZ], *scanl, *cp; + char name[NAMESZ], *cp; + charstring_t scanl; + static int dat[5]; /* aux. data for format routine */ + m_getfld_state_t gstate = 0; + struct fmt_callbacks cb; + FILE *out; + NMH_UNUSED (msg); mask = umask(~m_gmprot()); if ((out = fopen (drft, "w")) == NULL) @@ -91,53 +89,29 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen, 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. */ if (!ccto) { - FINDCOMP (cptr, "to"); + cptr = fmt_findcomp ("to"); if (cptr) - cptr->c_name = ""; + cptr->c_name = mh_xstrdup(""); } if (!cccc) { - FINDCOMP (cptr, "cc"); - if (cptr) - cptr->c_name = ""; - } - /* set up the "fcc" pseudo-component */ - if (fcc) { - FINDCOMP (cptr, "fcc"); - if (cptr) - cptr->c_text = getcpy (fcc); - } - if ((cp = getenv("USER"))) { - FINDCOMP (cptr, "user"); + cptr = fmt_findcomp("cc"); if (cptr) - cptr->c_text = getcpy(cp); + cptr->c_name = mh_xstrdup(""); } if (!ccme) ismymbox (NULL); @@ -145,58 +119,43 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen, /* * pick any interesting stuff out of msg "inb" */ - for (state = FLD;;) { - state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb); + for (;;) { + int msg_count = sizeof tmpbuf; + state = m_getfld (&gstate, name, tmpbuf, &msg_count, inb); switch (state) { - case FLD: - case FLDPLUS: + case FLD: + case FLDPLUS: /* * 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)])) - 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)); - - while (state == FLDPLUS) - state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb); + + i = fmt_addcomptext(name, tmpbuf); + if (i != -1) { + char_read += msg_count; + while (state == FLDPLUS) { + msg_count= sizeof tmpbuf; + state = m_getfld (&gstate, name, tmpbuf, &msg_count, inb); + fmt_appendcomp(i, name, tmpbuf); + char_read += msg_count; + } + } + + while (state == FLDPLUS) { + msg_count= sizeof tmpbuf; + state = m_getfld (&gstate, name, tmpbuf, &msg_count, inb); + } break; - case LENERR: - case FMTERR: - case BODY: + case LENERR: + case FMTERR: + case BODY: case FILEEOF: goto finished; - default: + default: adios (NULL, "m_getfld() returned %d", state); } } @@ -205,16 +164,35 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen, * format and output the header lines. */ finished: + m_getfld_state_destroy (&gstate); + + /* set up the "fcc" pseudo-component */ + cptr = fmt_findcomp ("fcc"); + if (cptr) { + mh_xfree(cptr->c_text); + if (fcc) + cptr->c_text = mh_xstrdup(fcc); + else + cptr->c_text = NULL; + } + cptr = fmt_findcomp ("user"); + if (cptr) { + mh_xfree(cptr->c_text); + if ((cp = getenv("USER"))) + cptr->c_text = mh_xstrdup(cp); + else + cptr = NULL; + } /* * 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; + char *sp = cp; for (;;) { - while (isspace(*cp)) + while (isspace((unsigned char) *cp)) cp++; if(uprf(cp, "re:")) cp += 3; @@ -224,19 +202,22 @@ finished: } if (sp != cptr->c_text) { cp = cptr->c_text; - cptr->c_text = getcpy (sp); + cptr->c_text = mh_xstrdup(sp); free (cp); } } i = format_len + char_read + 256; - scanl = malloc ((size_t) i + 2); + scanl = charstring_create (i + 2); dat[0] = 0; dat[1] = 0; dat[2] = 0; dat[3] = outputlinelen; dat[4] = 0; - fmt_scan (fmt, scanl, i, dat); - fputs (scanl, out); + memset(&cb, 0, sizeof(cb)); + cb.formataddr = replformataddr; + cb.concataddr = replconcataddr; + fmt_scan (fmt, scanl, i, dat, &cb); + fputs (charstring_buffer (scanl), out); if (badaddrs) { fputs ("\nrepl: bad addresses:\n", out); fputs ( badaddrs, out); @@ -247,24 +228,24 @@ finished: * 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); + charstring_free (scanl); + fmt_free(fmt, 1); } static char *buf; /* our current working buffer */ @@ -285,11 +266,9 @@ static unsigned int bufsiz=0; /* current size of buf */ 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;\ } @@ -305,22 +284,21 @@ static unsigned int bufsiz=0; /* current size of buf */ * don't call "getcpy") but still place no upper limit on the * length of the result string. */ -char * -formataddr (char *orig, char *str) +static char * +replformataddr (char *orig, char *str) { - register int len; + int len; char baddr[BUFSIZ], error[BUFSIZ]; - register int isgroup; - register char *dst; - register char *cp; - register char *sp; - register struct mailname *mp = NULL; + int isgroup; + char *dst; + char *cp; + char *sp; + struct mailname *mp = NULL; + char *fixed_str = fix_addresses (str); /* 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; @@ -341,8 +319,8 @@ formataddr (char *orig, char *str) } /* concatenate all the new addresses onto 'buf' */ - for (isgroup = 0; (cp = getname (str)); ) { - if ((mp = getm (cp, dfhost, dftype, AD_NAME, error)) == NULL) { + for (isgroup = 0; (cp = getname (fixed_str)); ) { + if ((mp = getm (cp, dfhost, dftype, error, sizeof(error))) == NULL) { snprintf (baddr, sizeof(baddr), "\t%s -- %s\n", cp, error); badaddrs = add (baddr, badaddrs); continue; @@ -368,6 +346,8 @@ formataddr (char *orig, char *str) } } + free (fixed_str); + if (isgroup) *dst++ = ';'; @@ -377,18 +357,46 @@ formataddr (char *orig, char *str) } +/* + * 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 replformataddr() + * 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 replformataddr(). + */ +static char * +replconcataddr(char *orig, char *str) +{ + char *cp; + + nodupcheck = 1; + cp = replformataddr(orig, str); + nodupcheck = 0; + return cp; +} + static int insert (struct mailname *np) { char buffer[BUFSIZ]; - register struct mailname *mp; + 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 (!strcasecmp (np->m_host ? np->m_host : "", + mp->m_next->m_host ? mp->m_next->m_host : "") && + !strcasecmp (np->m_mbox ? np->m_mbox : "", + mp->m_next->m_mbox ? mp->m_next->m_mbox : "")) return 0; } if (!ccme && ismymbox (np)) @@ -396,29 +404,29 @@ insert (struct mailname *np) if (querysw) { snprintf (buffer, sizeof(buffer), "Reply to %s? ", adrformat (np)); - if (!gans (buffer, anoyes)) + if (!read_switch (buffer, anoyes)) return 0; } 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; + int argnum; if (filter == NULL) return; @@ -426,30 +434,184 @@ replfilter (FILE *in, FILE *out, char *filter) if (access (filter, R_OK) == NOTOK) adios (filter, "unable to read"); - mhl = r1bindex (mhlproc, '/'); - rewind (in); lseek (fileno(in), (off_t) 0, SEEK_SET); - fflush (out); - switch (pid = vfork ()) { - case NOTOK: + arglist = argsplit(mhlproc, &mhl, &argnum); + + switch (pid = fork()) { + case NOTOK: adios ("fork", "unable to"); - case OK: + case OK: dup2 (fileno (in), fileno (stdin)); dup2 (fileno (out), fileno (stdout)); closefds (3); - execlp (mhlproc, mhl, "-form", filter, "-noclear", NULL); - fprintf (stderr, "unable to exec "); - perror (mhlproc); + /* + * We're not allocating the memory for the extra arguments, + * because we never call arglist_free(). But if we ever change + * that be sure to use getcpy() for the extra arguments. + */ + arglist[argnum++] = "-form"; + arglist[argnum++] = filter; + arglist[argnum++] = "-noclear"; + + switch (fmtproc) { + case 1: + arglist[argnum++] = "-fmtproc"; + arglist[argnum++] = formatproc; + break; + case 0: + arglist[argnum++] = "-nofmtproc"; + break; + } + + arglist[argnum++] = NULL; + + execvp (mhl, arglist); + errstr = strerror(errno); + if (write(2, "unable to exec ", 15) < 0 || + write(2, mhlproc, strlen(mhlproc)) < 0 || + write(2, ": ", 2) < 0 || + write(2, errstr, strlen(errstr)) < 0 || + write(2, "\n", 1) < 0) { + advise ("stderr", "write"); + } _exit (-1); - default: + default: if (pidXwait (pid, mhl)) done (1); fseek (out, 0L, SEEK_END); break; } } + + +static +char * +fix_addresses (char *str) { + char *fixed_str = NULL; + int fixed_address = 0; + + if (str) { + /* + * Attempt to parse each of the addresses in str. If any fail + * and can be fixed with escape_local_part(), do that. This + * is extra ugly because getm()'s state can only be reset by + * call getname(), and getname() needs to be called repeatedly + * until it returns NULL to reset its state. + */ + struct adr_node { + char *adr; + int escape_local_part; + int fixed; + struct adr_node *next; + } *adrs = NULL; + struct adr_node *np = adrs; + char *cp; + + /* + * First, put each of the addresses in a linked list. Note + * invalid addresses that might be fixed by escaping the + * local part. + */ + while ((cp = getname (str))) { + struct adr_node *adr_nodep; + char error[BUFSIZ]; + struct mailname *mp; + + NEW(adr_nodep); + adr_nodep->adr = mh_xstrdup (cp); + adr_nodep->escape_local_part = 0; + adr_nodep->fixed = 0; + adr_nodep->next = NULL; + + /* With AD_NAME, errors are not reported to user. */ + if ((mp = getm (cp, dfhost, dftype, error, + sizeof(error))) == NULL) { + const char *no_at_sign = "no at-sign after local-part"; + + adr_nodep->escape_local_part = + has_prefix(error, no_at_sign); + } else { + mnfree (mp); + } + + if (np) { + np = np->next = adr_nodep; + } else { + np = adrs = adr_nodep; + } + } + + /* + * Walk the list and try to fix broken addresses. + */ + for (np = adrs; np; np = np->next) { + char *display_name = mh_xstrdup (np->adr); + size_t len = strlen (display_name); + + if (np->escape_local_part) { + char *local_part_end = strrchr (display_name, '<'); + char *angle_addr = mh_xstrdup (local_part_end); + struct mailname *mp; + char *new_adr, *adr; + + *local_part_end = '\0'; + /* Trim any trailing whitespace. */ + while (local_part_end > display_name && + isspace ((unsigned char) *--local_part_end)) { + *local_part_end = '\0'; + } + escape_local_part (display_name, len); + new_adr = concat (display_name, " ", angle_addr, NULL); + adr = getname (new_adr); + if (adr != NULL && + (mp = getm (adr, dfhost, dftype, NULL, 0)) != NULL) { + fixed_address = 1; + mnfree (mp); + } + free (angle_addr); + free (new_adr); + free (np->adr); + np->adr = mh_xstrdup (adr); + + /* Need to flush getname() */ + while ((cp = getname (""))) continue; + } /* else the np->adr is OK, so use it as-is. */ + + free (display_name); + } + + /* + * If any addresses were repaired, build new address string, + * replacing broken addresses. + */ + for (np = adrs; np; ) { + struct adr_node *next = np->next; + + if (fixed_address) { + if (fixed_str) { + char *new_str = concat (fixed_str, ", ", np->adr, NULL); + + free (fixed_str); + fixed_str = new_str; + } else { + fixed_str = mh_xstrdup (np->adr); + } + } + + free (np->adr); + free (np); + np = next; + } + } + + if (fixed_address) { + return fixed_str; + } + free (fixed_str); + return str ? mh_xstrdup (str) : NULL; +}