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