X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/da35ab7c7664b221aba2d761d0f051c57313e16e..1e424a2249aa6b911fd3be973de00cee413342eb:/uip/replsbr.c

diff --git a/uip/replsbr.c b/uip/replsbr.c
index 1aff02e6..a9a65969 100644
--- a/uip/replsbr.c
+++ b/uip/replsbr.c
@@ -12,7 +12,6 @@
 #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;
@@ -59,19 +58,21 @@ 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
 replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
 	int mime, char *form, char *filter, char *fcc, int fmtproc)
 {
-    register int state, i;
-    register struct comp *cptr;
+    int state, i;
+    struct comp *cptr;
     char tmpbuf[SBUFSIZ];
     struct format *fmt;
-    register char **ap;
+    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;
@@ -110,23 +111,23 @@ replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
     if (!ccto) {
 	cptr = fmt_findcomp ("to");
 	if (cptr)
-	    cptr->c_name = getcpy(NULL);
+	    cptr->c_name = mh_xstrdup("");
     }
     if (!cccc) {
 	 cptr = fmt_findcomp("cc");
 	if (cptr)
-	    cptr->c_name = getcpy(NULL);
+	    cptr->c_name = mh_xstrdup("");
     }
     /* set up the "fcc" pseudo-component */
     if (fcc) {
 	cptr = fmt_findcomp ("fcc");
 	if (cptr)
-	    cptr->c_text = getcpy (fcc);
+	    cptr->c_text = mh_xstrdup(fcc);
     }
     if ((cp = getenv("USER"))) {
 	cptr = fmt_findcomp ("user");
 	if (cptr)
-	    cptr->c_text = getcpy(cp);
+	    cptr->c_text = mh_xstrdup(cp);
     }
     if (!ccme)
 	ismymbox (NULL);
@@ -186,7 +187,7 @@ finished:
      */
     cptr = fmt_findcomp ("subject");
     if (cptr && (cp = cptr->c_text)) {
-	register char *sp = cp;
+	char *sp = cp;
 
 	for (;;) {
 	    while (isspace((unsigned char) *cp))
@@ -199,12 +200,12 @@ 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 = mh_xmalloc ((size_t) i + 2);
+    scanl = charstring_create (i + 2);
     dat[0] = 0;
     dat[1] = 0;
     dat[2] = 0;
@@ -213,8 +214,8 @@ finished:
     memset(&cb, 0, sizeof(cb));
     cb.formataddr = replformataddr;
     cb.concataddr = replconcataddr;
-    fmt_scan (fmt, scanl, i + 1, i, dat, &cb);
-    fputs (scanl, out);
+    fmt_scan (fmt, scanl, i, dat, &cb);
+    fputs (charstring_buffer (scanl), out);
     if (badaddrs) {
 	fputs ("\nrepl: bad addresses:\n", out);
 	fputs ( badaddrs, out);
@@ -241,7 +242,7 @@ finished:
     fclose (out);
 
     /* return dynamically allocated buffers */
-    free (scanl);
+    charstring_free (scanl);
     fmt_free(fmt, 1);
 }
 
@@ -284,13 +285,14 @@ static unsigned int bufsiz=0;	/* current size of buf */
 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) {
@@ -315,8 +317,8 @@ replformataddr (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;
@@ -342,6 +344,8 @@ replformataddr (char *orig, char *str)
 	}
     }
 
+    free (fixed_str);
+
     if (isgroup)
 	*dst++ = ';';
 
@@ -378,7 +382,7 @@ static int
 insert (struct mailname *np)
 {
     char buffer[BUFSIZ];
-    register struct mailname *mp;
+    struct mailname *mp;
 
     if (nodupcheck)
 	return 1;
@@ -398,7 +402,7 @@ 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;
@@ -431,6 +435,8 @@ replfilter (FILE *in, FILE *out, char *filter, int fmtproc)
     rewind (in);
     lseek (fileno(in), (off_t) 0, SEEK_SET);
 
+    arglist = argsplit(mhlproc, &mhl, &argnum);
+
     switch (pid = fork()) {
 	case NOTOK: 
 	    adios ("fork", "unable to");
@@ -445,7 +451,6 @@ replfilter (FILE *in, FILE *out, char *filter, int fmtproc)
 	     * because we never call arglist_free().  But if we ever change
 	     * that be sure to use getcpy() for the extra arguments.
 	     */
-	    arglist = argsplit(mhlproc, &mhl, &argnum);
 	    arglist[argnum++] = "-form";
 	    arglist[argnum++] = filter;
 	    arglist[argnum++] = "-noclear";
@@ -464,11 +469,13 @@ replfilter (FILE *in, FILE *out, char *filter, int fmtproc)
 
 	    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: 
@@ -478,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;
+            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;
+}