Alter HasSuffixC()'s char * to be const.

[nmh] / uip / replsbr.c

diff --git a/uip/replsbr.c b/uip/replsbr.c
index 1ea411c26233ef44c738bdd3770554822689a765..a9a659696ce147e52553e856d65079ff559148eb 100644 (file)
--- a/uip/replsbr.c
+++ b/uip/replsbr.c
@@ -2,8 +2,6 @@
 /*
  * replsbr.c -- routines to help repl along...
  *
 /*
  * 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.
  * 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.


@@ -12,6 +10,7 @@
 #include <h/mh.h>
 #include <h/addrsbr.h>
 #include <h/fmt_scan.h>
 #include <h/mh.h>
 #include <h/addrsbr.h>
 #include <h/fmt_scan.h>

+#include <h/utils.h>

 #include <sys/file.h>          /* L_SET */
 
 extern short ccto;             /* from repl.c */
 #include <sys/file.h>          /* L_SET */
 
 extern short ccto;             /* from repl.c */


@@ -24,7 +23,8 @@ static int dftype=0;
 static char *badaddrs = NULL;
 static char *dfhost = NULL;
 
 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.
 
 /*
  * Buffer size for content part of header fields.


@@ -35,14 +35,6 @@ static struct mailname mq = { NULL };
  */
 #define SBUFSIZ 256            
 
  */
 #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 char *addrcomps[] = {
     "from",
     "sender",


@@ -63,79 +55,79 @@ static char *addrcomps[] = {
  * static prototypes
  */
 static int insert (struct mailname *);
  * 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,
 
 
 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        char_read = 0, format_len;
-    char name[NAMESZ], *scanl, *cp;
+    int state, i;
+    struct comp *cptr;
+    char tmpbuf[SBUFSIZ];
+    struct format *fmt;
+    char **ap;
+    int        char_read = 0, format_len, mask;
+    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;
     FILE *out;

+    NMH_UNUSED (msg);

 
 

-    umask(~m_gmprot());
+    mask = umask(~m_gmprot());

     if ((out = fopen (drft, "w")) == NULL)
        adios (drft, "unable to create");
 
     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 */
     /* 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++) {
 
     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
        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) {
      */
     if (!ccto) {

-       FINDCOMP (cptr, "to");
+       cptr = fmt_findcomp ("to");

        if (cptr)
        if (cptr)

-           cptr->c_name = "";
+           cptr->c_name = mh_xstrdup("");

     }
     if (!cccc) {
     }
     if (!cccc) {

-       FINDCOMP (cptr, "cc");
+        cptr = fmt_findcomp("cc");

        if (cptr)
        if (cptr)

-           cptr->c_name = "";
+           cptr->c_name = mh_xstrdup("");

     }
     /* set up the "fcc" pseudo-component */
     if (fcc) {
     }
     /* set up the "fcc" pseudo-component */
     if (fcc) {

-       FINDCOMP (cptr, "fcc");
+       cptr = fmt_findcomp ("fcc");

        if (cptr)
        if (cptr)

-           cptr->c_text = getcpy (fcc);
+           cptr->c_text = mh_xstrdup(fcc);

     }
     if ((cp = getenv("USER"))) {
     }
     if ((cp = getenv("USER"))) {

-       FINDCOMP (cptr, "user");
+       cptr = fmt_findcomp ("user");

        if (cptr)
        if (cptr)

-           cptr->c_text = getcpy(cp);
+           cptr->c_text = mh_xstrdup(cp);

     }
     if (!ccme)
        ismymbox (NULL);
     }
     if (!ccme)
        ismymbox (NULL);


@@ -143,8 +135,9 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
     /*
      * pick any interesting stuff out of msg "inb"
      */
     /*
      * 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: 
        switch (state) {
            case FLD: 
            case FLDPLUS: 


@@ -154,38 +147,22 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
                 * buffer as the component temp buffer (buffer switching
                 * saves an extra copy of the component text).
                 */
                 * 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: 
                break;
 
            case LENERR: 


@@ -203,16 +180,17 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
      * format and output the header lines.
      */
 finished:
      * format and output the header lines.
      */
 finished:

+    m_getfld_state_destroy (&gstate);

 
     /*
      * if there's a "Subject" component, strip any "Re:"s off it
      */
 
     /*
      * 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)) {
     if (cptr && (cp = cptr->c_text)) {

-       register char *sp = cp;
+       char *sp = cp;

 
        for (;;) {
 
        for (;;) {

-           while (isspace(*cp))
+           while (isspace((unsigned char) *cp))

                cp++;
            if(uprf(cp, "re:"))
                cp += 3;
                cp++;
            if(uprf(cp, "re:"))
                cp += 3;


@@ -222,19 +200,22 @@ finished:
        }
        if (sp != cptr->c_text) {
            cp = cptr->c_text;
        }
        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;
            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;
     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);
     if (badaddrs) {
        fputs ("\nrepl: bad addresses:\n", out);
        fputs ( badaddrs, out);


@@ -245,24 +226,24 @@ finished:
      * or add mhn directives
      */
     if (filter) {
      * 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));
     }
 
     } 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 */
     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 */
 }
 
 static char *buf;              /* our current working buffer */


@@ -283,11 +264,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;\
                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;\
                dst = buf + i;\
                last_dst = buf + n;\

-               if (! buf)\
-                   adios (NULL, "formataddr: couldn't get buffer space");\

                bufend = buf + bufsiz;\
            }
 
                bufend = buf + bufsiz;\
            }
 


@@ -303,22 +282,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.
  */
  * 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];
     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) {
 
     /* 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;
        last_dst = buf;         /* XXX */
        bufsiz = BUFINCR - 6;  /* leave some slop */
        bufend = buf + bufsiz;


@@ -339,8 +317,8 @@ formataddr (char *orig, char *str)
     }
 
     /* concatenate all the new addresses onto 'buf' */
     }
 
     /* 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;
            snprintf (baddr, sizeof(baddr), "\t%s -- %s\n", cp, error);
            badaddrs = add (baddr, badaddrs);
            continue;


@@ -366,6 +344,8 @@ formataddr (char *orig, char *str)
        }
     }
 
        }
     }
 

+    free (fixed_str);
+

     if (isgroup)
        *dst++ = ';';
 
     if (isgroup)
        *dst++ = ';';
 


@@ -375,18 +355,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];
 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 (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))
            return 0;
     }
     if (!ccme && ismymbox (np))


@@ -394,29 +402,29 @@ insert (struct mailname *np)
 
     if (querysw) {
        snprintf (buffer, sizeof(buffer), "Reply to %s? ", adrformat (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;
 
        return 0;
     }
     mp->m_next = np;
 

-#ifdef ISI
-    if (ismymbox (np))
-       ccme = 0;
-#endif
-

     return 1;
 }
 
 
 /*
  * Call the mhlproc
     return 1;
 }
 
 
 /*
  * Call the mhlproc

+ *
+ * This function expects that argument out has been fflushed by the caller.

  */
 
 static void
  */
 
 static void

-replfilter (FILE *in, FILE *out, char *filter)
+replfilter (FILE *in, FILE *out, char *filter, int fmtproc)

 {
     int        pid;
     char *mhl;
 {
     int        pid;
     char *mhl;

+    char *errstr;
+    char **arglist;
+    int argnum;

 
     if (filter == NULL)
        return;
 
     if (filter == NULL)
        return;


@@ -424,13 +432,12 @@ replfilter (FILE *in, FILE *out, char *filter)
     if (access (filter, R_OK) == NOTOK)
        adios (filter, "unable to read");
 
     if (access (filter, R_OK) == NOTOK)
        adios (filter, "unable to read");
 

-    mhl = r1bindex (mhlproc, '/');
-

     rewind (in);
     lseek (fileno(in), (off_t) 0, SEEK_SET);
     rewind (in);
     lseek (fileno(in), (off_t) 0, SEEK_SET);

-    fflush (out);

 
 

-    switch (pid = vfork ()) {
+    arglist = argsplit(mhlproc, &mhl, &argnum);
+
+    switch (pid = fork()) {

        case NOTOK: 
            adios ("fork", "unable to");
 
        case NOTOK: 
            adios ("fork", "unable to");
 


@@ -439,9 +446,36 @@ replfilter (FILE *in, FILE *out, char *filter)
            dup2 (fileno (out), fileno (stdout));
            closefds (3);
 
            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: 
            _exit (-1);
 
        default: 


@@ -451,3 +485,131 @@ replfilter (FILE *in, FILE *out, char *filter)
            break;
     }
 }
            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 = 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;
+    }
+    free (fixed_str);
+    return str  ?  strdup (str)  :  NULL;
+}