Wrapped setjmp(), sigsetjmp(), and vfork() calls to silence gcc -Wclobbered for good...
[mmh] / uip / replsbr.c
1
2 /*
3  * replsbr.c -- routines to help repl along...
4  *
5  * This code is Copyright (c) 2002, by the authors of nmh.  See the
6  * COPYRIGHT file in the root directory of the nmh distribution for
7  * complete copyright information.
8  */
9
10 #include <h/mh.h>
11 #include <h/addrsbr.h>
12 #include <h/fmt_scan.h>
13 #include <h/utils.h>
14 #include <sys/file.h>           /* L_SET */
15 #include <errno.h>
16
17 extern short ccto;              /* from repl.c */
18 extern short cccc;
19 extern short ccme;
20 extern short querysw;
21
22 static int dftype=0;
23
24 static char *badaddrs = NULL;
25 static char *dfhost = NULL;
26
27 static struct mailname mq;
28 static int nodupcheck = 0;              /* If set, no check for duplicates */
29
30 /*
31  * Buffer size for content part of header fields.
32  * We want this to be large enough so that we don't
33  * do a lot of extra FLDPLUS calls on m_getfld but
34  * small enough so that we don't snarf the entire
35  * message body when we're not going to use any of it.
36  */
37 #define SBUFSIZ 256             
38
39 static struct format *fmt;
40
41 static int ncomps = 0;                  /* # of interesting components */
42 static char **compbuffers = NULL;       /* buffers for component text */
43 static struct comp **used_buf = NULL;   /* stack for comp that use buffers */
44
45 static int dat[5];                      /* aux. data for format routine */
46
47 static char *addrcomps[] = {
48     "from",
49     "sender",
50     "reply-to",
51     "to",
52     "cc",
53     "bcc",
54     "resent-from",
55     "resent-sender",
56     "resent-reply-to",
57     "resent-to",
58     "resent-cc",
59     "resent-bcc",
60     NULL
61 };
62
63 /*
64  * static prototypes
65  */
66 static int insert (struct mailname *);
67 static void replfilter (FILE *, FILE *, char *);
68
69
70 void
71 replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
72         int mime, char *form, char *filter, char *fcc)
73 {
74     NMH_UNUSED (msg);
75
76     register int state, i;
77     register struct comp *cptr;
78     register char *tmpbuf;
79     register char **nxtbuf;
80     register char **ap;
81     register struct comp **savecomp;
82     int char_read = 0, format_len, mask;
83     char name[NAMESZ], *scanl;
84     unsigned char *cp;
85     FILE *out;
86
87     mask = umask(~m_gmprot());
88     if ((out = fopen (drft, "w")) == NULL)
89         adios (drft, "unable to create");
90
91     umask(mask);
92
93     /* get new format string */
94     cp = new_fs (form, NULL, NULL);
95     format_len = strlen (cp);
96
97     /* compile format string */
98     ncomps = fmt_compile (cp, &fmt) + 1;
99
100     if (!(nxtbuf = compbuffers = (char **)
101             calloc((size_t) ncomps, sizeof(char *))))
102         adios (NULL, "unable to allocate component buffers");
103     if (!(savecomp = used_buf = (struct comp **)
104             calloc((size_t) (ncomps+1), sizeof(struct comp *))))
105         adios (NULL, "unable to allocate component buffer stack");
106     savecomp += ncomps + 1;
107     *--savecomp = NULL;         /* point at zero'd end minus 1 */
108
109     for (i = ncomps; i--; )
110         *nxtbuf++ = mh_xmalloc(SBUFSIZ);
111
112     nxtbuf = compbuffers;               /* point at start */
113     tmpbuf = *nxtbuf++;
114
115     for (ap = addrcomps; *ap; ap++) {
116         FINDCOMP (cptr, *ap);
117         if (cptr)
118             cptr->c_type |= CT_ADDR;
119     }
120
121     /*
122      * ignore any components killed by command line switches
123      */
124     if (!ccto) {
125         FINDCOMP (cptr, "to");
126         if (cptr)
127             cptr->c_name = "";
128     }
129     if (!cccc) {
130         FINDCOMP (cptr, "cc");
131         if (cptr)
132             cptr->c_name = "";
133     }
134     /* set up the "fcc" pseudo-component */
135     if (fcc) {
136         FINDCOMP (cptr, "fcc");
137         if (cptr)
138             cptr->c_text = getcpy (fcc);
139     }
140     if ((cp = getenv("USER"))) {
141         FINDCOMP (cptr, "user");
142         if (cptr)
143             cptr->c_text = getcpy(cp);
144     }
145     if (!ccme)
146         ismymbox (NULL);
147
148     /*
149      * pick any interesting stuff out of msg "inb"
150      */
151     for (state = FLD;;) {
152         state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb);
153         switch (state) {
154             case FLD: 
155             case FLDPLUS: 
156                 /*
157                  * if we're interested in this component, save a pointer
158                  * to the component text, then start using our next free
159                  * buffer as the component temp buffer (buffer switching
160                  * saves an extra copy of the component text).
161                  */
162                 if ((cptr = wantcomp[CHASH(name)]))
163                     do {
164                         if (!mh_strcasecmp(name, cptr->c_name)) {
165                             char_read += msg_count;
166                             if (! cptr->c_text) {
167                                 i = strlen(cptr->c_text = tmpbuf) - 1;
168                                 if (tmpbuf[i] == '\n')
169                                     tmpbuf[i] = '\0';
170                                 *--savecomp = cptr;
171                                 tmpbuf = *nxtbuf++;
172                             } else {
173                                 i = strlen (cp = cptr->c_text) - 1;
174                                 if (cp[i] == '\n') {
175                                     if (cptr->c_type & CT_ADDR) {
176                                         cp[i] = '\0';
177                                         cp = add (",\n\t", cp);
178                                     } else {
179                                         cp = add ("\t", cp);
180                                     }
181                                 }
182                                 cptr->c_text = add (tmpbuf, cp);
183                             }
184                             while (state == FLDPLUS) {
185                                 state = m_getfld (state, name, tmpbuf,
186                                                   SBUFSIZ, inb);
187                                 cptr->c_text = add (tmpbuf, cptr->c_text);
188                                 char_read += msg_count;
189                             }
190                             break;
191                         }
192                     } while ((cptr = cptr->c_next));
193
194                 while (state == FLDPLUS)
195                     state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb);
196                 break;
197
198             case LENERR: 
199             case FMTERR: 
200             case BODY: 
201             case FILEEOF:
202                 goto finished;
203
204             default: 
205                 adios (NULL, "m_getfld() returned %d", state);
206         }
207     }
208
209     /*
210      * format and output the header lines.
211      */
212 finished:
213
214     /*
215      * if there's a "Subject" component, strip any "Re:"s off it
216      */
217     FINDCOMP (cptr, "subject")
218     if (cptr && (cp = cptr->c_text)) {
219         register char *sp = cp;
220
221         for (;;) {
222             while (isspace(*cp))
223                 cp++;
224             if(uprf(cp, "re:"))
225                 cp += 3;
226             else
227                 break;
228             sp = cp;
229         }
230         if (sp != cptr->c_text) {
231             cp = cptr->c_text;
232             cptr->c_text = getcpy (sp);
233             free (cp);
234         }
235     }
236     i = format_len + char_read + 256;
237     scanl = mh_xmalloc ((size_t) i + 2);
238     dat[0] = 0;
239     dat[1] = 0;
240     dat[2] = 0;
241     dat[3] = outputlinelen;
242     dat[4] = 0;
243     fmt_scan (fmt, scanl, i, dat);
244     fputs (scanl, out);
245     if (badaddrs) {
246         fputs ("\nrepl: bad addresses:\n", out);
247         fputs ( badaddrs, out);
248     }
249
250     /*
251      * Check if we should filter the message
252      * or add mhn directives
253      */
254     if (filter) {
255         fflush(out);
256         if (ferror (out))
257             adios (drft, "error writing");
258         
259         replfilter (inb, out, filter);
260     } else if (mime && mp) {
261             fprintf (out, "#forw [original message] +%s %s\n",
262                      mp->foldpath, m_name (mp->lowsel));
263     }
264
265     fflush(out);
266     if (ferror (out))
267         adios (drft, "error writing");
268     fclose (out);
269
270     /* return dynamically allocated buffers */
271     free (scanl);
272     for (nxtbuf = compbuffers, i = ncomps; (cptr = *savecomp++); nxtbuf++, i--)
273         free (cptr->c_text);    /* if not nxtbuf, nxtbuf already freed */
274     while ( i-- > 0)
275         free (*nxtbuf++);       /* free unused nxtbufs */
276     free ((char *) compbuffers);
277     free ((char *) used_buf);
278 }
279
280 static char *buf;               /* our current working buffer */
281 static char *bufend;            /* end of working buffer */
282 static char *last_dst;          /* buf ptr at end of last call */
283 static unsigned int bufsiz=0;   /* current size of buf */
284
285 #define BUFINCR 512             /* how much to expand buf when if fills */
286
287 #define CPY(s) { cp = (s); while ((*dst++ = *cp++)) ; --dst; }
288
289 /*
290  * check if there's enough room in buf for str.
291  * add more mem if needed
292  */
293 #define CHECKMEM(str) \
294             if ((len = strlen (str)) >= bufend - dst) {\
295                 int i = dst - buf;\
296                 int n = last_dst - buf;\
297                 bufsiz += ((dst + len - bufend) / BUFINCR + 1) * BUFINCR;\
298                 buf = mh_xrealloc (buf, bufsiz);\
299                 dst = buf + i;\
300                 last_dst = buf + n;\
301                 bufend = buf + bufsiz;\
302             }
303
304
305 /*
306  * fmt_scan will call this routine if the user includes the function
307  * "(formataddr {component})" in a format string.  "orig" is the
308  * original contents of the string register.  "str" is the address
309  * string to be formatted and concatenated onto orig.  This routine
310  * returns a pointer to the concatenated address string.
311  *
312  * We try to not do a lot of malloc/copy/free's (which is why we
313  * don't call "getcpy") but still place no upper limit on the
314  * length of the result string.
315  */
316 char *
317 formataddr (char *orig, char *str)
318 {
319     register int len;
320     char baddr[BUFSIZ], error[BUFSIZ];
321     register int isgroup;
322     register char *dst;
323     register char *cp;
324     register char *sp;
325     register struct mailname *mp = NULL;
326
327     /* if we don't have a buffer yet, get one */
328     if (bufsiz == 0) {
329         buf = mh_xmalloc (BUFINCR);
330         last_dst = buf;         /* XXX */
331         bufsiz = BUFINCR - 6;  /* leave some slop */
332         bufend = buf + bufsiz;
333     }
334     /*
335      * If "orig" points to our buffer we can just pick up where we
336      * left off.  Otherwise we have to copy orig into our buffer.
337      */
338     if (orig == buf)
339         dst = last_dst;
340     else if (!orig || !*orig) {
341         dst = buf;
342         *dst = '\0';
343     } else {
344         dst = last_dst;         /* XXX */
345         CHECKMEM (orig);
346         CPY (orig);
347     }
348
349     /* concatenate all the new addresses onto 'buf' */
350     for (isgroup = 0; (cp = getname (str)); ) {
351         if ((mp = getm (cp, dfhost, dftype, AD_NAME, error)) == NULL) {
352             snprintf (baddr, sizeof(baddr), "\t%s -- %s\n", cp, error);
353             badaddrs = add (baddr, badaddrs);
354             continue;
355         }
356         if (isgroup && (mp->m_gname || !mp->m_ingrp)) {
357             *dst++ = ';';
358             isgroup = 0;
359         }
360         if (insert (mp)) {
361             /* if we get here we're going to add an address */
362             if (dst != buf) {
363                 *dst++ = ',';
364                 *dst++ = ' ';
365             }
366             if (mp->m_gname) {
367                 CHECKMEM (mp->m_gname);
368                 CPY (mp->m_gname);
369                 isgroup++;
370             }
371             sp = adrformat (mp);
372             CHECKMEM (sp);
373             CPY (sp);
374         }
375     }
376
377     if (isgroup)
378         *dst++ = ';';
379
380     *dst = '\0';
381     last_dst = dst;
382     return (buf);
383 }
384
385
386 /*
387  * fmt_scan will call this routine if the user includes the function
388  * "(concataddr {component})" in a format string.  This behaves exactly
389  * like formataddr, except that it does NOT suppress duplicate addresses
390  * between calls.
391  *
392  * As an implementation detail: I thought about splitting out formataddr()
393  * into the generic part and duplicate-suppressing part, but the call to
394  * insert() was buried deep within a couple of loops and I didn't see a
395  * way to do it easily.  So instead we simply set a special flag to stop
396  * the duplicate check and call formataddr().
397  */
398 char *
399 concataddr(char *orig, char *str)
400 {
401     char *cp;
402
403     nodupcheck = 1;
404     cp = formataddr(orig, str);
405     nodupcheck = 0;
406     return cp;
407 }
408
409 static int
410 insert (struct mailname *np)
411 {
412     char buffer[BUFSIZ];
413     register struct mailname *mp;
414
415     if (nodupcheck)
416         return 1;
417
418     if (np->m_mbox == NULL)
419         return 0;
420
421     for (mp = &mq; mp->m_next; mp = mp->m_next) {
422         if (!mh_strcasecmp (np->m_host, mp->m_next->m_host)
423                 && !mh_strcasecmp (np->m_mbox, mp->m_next->m_mbox))
424             return 0;
425     }
426     if (!ccme && ismymbox (np))
427         return 0;
428
429     if (querysw) {
430         snprintf (buffer, sizeof(buffer), "Reply to %s? ", adrformat (np));
431         if (!gans (buffer, anoyes))
432         return 0;
433     }
434     mp->m_next = np;
435
436 #ifdef ISI
437     if (ismymbox (np))
438         ccme = 0;
439 #endif
440
441     return 1;
442 }
443
444
445 /*
446  * Call the mhlproc
447  *
448  * This function expects that argument out has been fflushed by the caller.
449  */
450
451 static void
452 replfilter (FILE *in, FILE *out, char *filter)
453 {
454     int pid;
455     char *mhl;
456     char *errstr;
457
458     if (filter == NULL)
459         return;
460
461     if (access (filter, R_OK) == NOTOK)
462         adios (filter, "unable to read");
463
464     mhl = r1bindex (mhlproc, '/');
465
466     rewind (in);
467     lseek (fileno(in), (off_t) 0, SEEK_SET);
468
469     switch (pid = m_vfork()) {
470         case NOTOK: 
471             adios ("fork", "unable to");
472
473         case OK: 
474             dup2 (fileno (in), fileno (stdin));
475             dup2 (fileno (out), fileno (stdout));
476             closefds (3);
477
478             execlp (mhlproc, mhl, "-form", filter, "-noclear", NULL);
479             errstr = strerror(errno);
480             write(2, "unable to exec ", 15);
481             write(2, mhlproc, strlen(mhlproc));
482             write(2, ": ", 2);
483             write(2, errstr, strlen(errstr));
484             write(2, "\n", 1);
485             _exit (-1);
486
487         default: 
488             if (pidXwait (pid, mhl))
489                 done (1);
490             fseek (out, 0L, SEEK_END);
491             break;
492     }
493 }