X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/2c9ef70f084977c3a34a64072adcb2d474aff44a..bf982b40ca8495e7a8d14513aedcc2fe15f09a93:/uip/replsbr.c diff --git a/uip/replsbr.c b/uip/replsbr.c index 3dbc3031..c4ca0c4b 100644 --- a/uip/replsbr.c +++ b/uip/replsbr.c @@ -12,7 +12,6 @@ #include #include #include /* L_SET */ -#include extern short ccto; /* from repl.c */ extern short cccc; @@ -57,6 +56,9 @@ static char *addrcomps[] = { */ static int insert (struct mailname *); static void replfilter (FILE *, FILE *, char *, int); +static char *replformataddr(char *, char *); +static char *replconcataddr(char *, char *); +static char *fix_addresses (char *); void @@ -69,9 +71,11 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen, struct format *fmt; register char **ap; int char_read = 0, format_len, mask; - char name[NAMESZ], *scanl; - unsigned char *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); @@ -131,8 +135,9 @@ 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, sizeof(tmpbuf), inb); + for (;;) { + int msg_count = sizeof tmpbuf; + state = m_getfld (&gstate, name, tmpbuf, &msg_count, inb); switch (state) { case FLD: case FLDPLUS: @@ -147,15 +152,17 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen, if (i != -1) { char_read += msg_count; while (state == FLDPLUS) { - state = m_getfld(state, name, tmpbuf, - sizeof(tmpbuf), inb); + 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) - state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb); + while (state == FLDPLUS) { + msg_count= sizeof tmpbuf; + state = m_getfld (&gstate, name, tmpbuf, &msg_count, inb); + } break; case LENERR: @@ -173,6 +180,7 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen, * format and output the header lines. */ finished: + m_getfld_state_destroy (&gstate); /* * if there's a "Subject" component, strip any "Re:"s off it @@ -182,7 +190,7 @@ finished: register char *sp = cp; for (;;) { - while (isspace(*cp)) + while (isspace((unsigned char) *cp)) cp++; if(uprf(cp, "re:")) cp += 3; @@ -197,14 +205,17 @@ finished: } } i = format_len + char_read + 256; - scanl = mh_xmalloc ((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 + 1, 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); @@ -231,7 +242,7 @@ finished: fclose (out); /* return dynamically allocated buffers */ - free (scanl); + charstring_free (scanl); fmt_free(fmt, 1); } @@ -271,8 +282,8 @@ 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; char baddr[BUFSIZ], error[BUFSIZ]; @@ -281,6 +292,7 @@ formataddr (char *orig, char *str) register char *cp; register char *sp; register struct mailname *mp = NULL; + char *fixed_str = fix_addresses (str); /* if we don't have a buffer yet, get one */ if (bufsiz == 0) { @@ -305,8 +317,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; @@ -332,6 +344,8 @@ formataddr (char *orig, char *str) } } + free (fixed_str); + if (isgroup) *dst++ = ';'; @@ -347,19 +361,19 @@ formataddr (char *orig, char *str) * like formataddr, except that it does NOT suppress duplicate addresses * between calls. * - * As an implementation detail: I thought about splitting out formataddr() + * 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 formataddr(). + * the duplicate check and call replformataddr(). */ -char * -concataddr(char *orig, char *str) +static char * +replconcataddr(char *orig, char *str) { char *cp; nodupcheck = 1; - cp = formataddr(orig, str); + cp = replformataddr(orig, str); nodupcheck = 0; return cp; } @@ -377,8 +391,10 @@ insert (struct mailname *np) return 0; for (mp = &mq; mp->m_next; mp = mp->m_next) { - if (!mh_strcasecmp (np->m_host, mp->m_next->m_host) - && !mh_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)) @@ -407,7 +423,8 @@ replfilter (FILE *in, FILE *out, char *filter, int fmtproc) int pid; char *mhl; char *errstr; - char *arglist[7]; + char **arglist; + int argnum; if (filter == NULL) return; @@ -415,12 +432,12 @@ replfilter (FILE *in, FILE *out, char *filter, int fmtproc) if (access (filter, R_OK) == NOTOK) adios (filter, "unable to read"); - mhl = r1bindex (mhlproc, '/'); - rewind (in); lseek (fileno(in), (off_t) 0, SEEK_SET); - switch (pid = vfork()) { + arglist = argsplit(mhlproc, &mhl, &argnum); + + switch (pid = fork()) { case NOTOK: adios ("fork", "unable to"); @@ -429,32 +446,36 @@ replfilter (FILE *in, FILE *out, char *filter, int fmtproc) dup2 (fileno (out), fileno (stdout)); closefds (3); - arglist[0] = mhl; - arglist[1] = "-form"; - arglist[2] = filter; - arglist[3] = "-noclear"; + /* + * 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[4] = "-fmtproc"; - arglist[5] = formatproc; - arglist[6] = NULL; + arglist[argnum++] = "-fmtproc"; + arglist[argnum++] = formatproc; break; case 0: - arglist[4] = "-nofmtproc"; - arglist[5] = NULL; + arglist[argnum++] = "-nofmtproc"; break; - default: - arglist[4] = NULL; } - execvp (mhlproc, arglist); + arglist[argnum++] = NULL; + + execvp (mhl, 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); + 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: @@ -464,3 +485,131 @@ replfilter (FILE *in, FILE *out, char *filter, int fmtproc) 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 = mh_xmalloc (sizeof *adr_nodep); + char error[BUFSIZ]; + struct mailname *mp; + + adr_nodep->adr = strdup (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 = + ! strncmp (error, no_at_sign, strlen (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 = strdup (np->adr); + size_t len = strlen (display_name); + + if (np->escape_local_part) { + char *local_part_end = strrchr (display_name, '<'); + char *angle_addr = strdup (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 = strdup (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 = strdup (np->adr); + } + } + + free (np->adr); + free (np); + np = next; + } + } + + if (fixed_address) { + return fixed_str; + } else { + free (fixed_str); + return str ? strdup (str) : NULL; + } +}