3 * replsbr.c -- routines to help repl along...
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.
11 #include <h/addrsbr.h>
12 #include <h/fmt_scan.h>
14 #include <sys/file.h> /* L_SET */
17 extern short ccto; /* from repl.c */
24 static char *badaddrs = NULL;
25 static char *dfhost = NULL;
27 static struct mailname mq;
28 static int nodupcheck = 0; /* If set, no check for duplicates */
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.
39 static struct format *fmt;
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 */
45 static int dat[5]; /* aux. data for format routine */
47 static char *addrcomps[] = {
66 static int insert (struct mailname *);
67 static void replfilter (FILE *, FILE *, char *, int);
71 replout (FILE *inb, char *msg, char *drft, struct msgs *mp, int outputlinelen,
72 int mime, char *form, char *filter, char *fcc, int fmtproc)
74 register int state, i;
75 register struct comp *cptr;
76 register char *tmpbuf;
77 register char **nxtbuf;
79 register struct comp **savecomp;
80 int char_read = 0, format_len, mask;
81 char name[NAMESZ], *scanl;
86 mask = umask(~m_gmprot());
87 if ((out = fopen (drft, "w")) == NULL)
88 adios (drft, "unable to create");
92 /* get new format string */
93 cp = new_fs (form, NULL, NULL);
94 format_len = strlen (cp);
96 /* compile format string */
97 ncomps = fmt_compile (cp, &fmt) + 1;
99 if (!(nxtbuf = compbuffers = (char **)
100 calloc((size_t) ncomps, sizeof(char *))))
101 adios (NULL, "unable to allocate component buffers");
102 if (!(savecomp = used_buf = (struct comp **)
103 calloc((size_t) (ncomps+1), sizeof(struct comp *))))
104 adios (NULL, "unable to allocate component buffer stack");
105 savecomp += ncomps + 1;
106 *--savecomp = NULL; /* point at zero'd end minus 1 */
108 for (i = ncomps; i--; )
109 *nxtbuf++ = mh_xmalloc(SBUFSIZ);
111 nxtbuf = compbuffers; /* point at start */
114 for (ap = addrcomps; *ap; ap++) {
115 FINDCOMP (cptr, *ap);
117 cptr->c_type |= CT_ADDR;
121 * ignore any components killed by command line switches
124 FINDCOMP (cptr, "to");
129 FINDCOMP (cptr, "cc");
133 /* set up the "fcc" pseudo-component */
135 FINDCOMP (cptr, "fcc");
137 cptr->c_text = getcpy (fcc);
139 if ((cp = getenv("USER"))) {
140 FINDCOMP (cptr, "user");
142 cptr->c_text = getcpy(cp);
148 * pick any interesting stuff out of msg "inb"
150 for (state = FLD;;) {
151 state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb);
156 * if we're interested in this component, save a pointer
157 * to the component text, then start using our next free
158 * buffer as the component temp buffer (buffer switching
159 * saves an extra copy of the component text).
161 if ((cptr = wantcomp[CHASH(name)]))
163 if (!mh_strcasecmp(name, cptr->c_name)) {
164 char_read += msg_count;
165 if (! cptr->c_text) {
166 cptr->c_text = tmpbuf;
170 i = strlen (cp = cptr->c_text) - 1;
172 if (cptr->c_type & CT_ADDR) {
174 cp = add (",\n\t", cp);
179 cptr->c_text = add (tmpbuf, cp);
181 while (state == FLDPLUS) {
182 state = m_getfld (state, name, tmpbuf,
184 cptr->c_text = add (tmpbuf, cptr->c_text);
185 char_read += msg_count;
189 } while ((cptr = cptr->c_next));
191 while (state == FLDPLUS)
192 state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb);
202 adios (NULL, "m_getfld() returned %d", state);
207 * format and output the header lines.
212 * if there's a "Subject" component, strip any "Re:"s off it
214 FINDCOMP (cptr, "subject")
215 if (cptr && (cp = cptr->c_text)) {
216 register char *sp = cp;
227 if (sp != cptr->c_text) {
229 cptr->c_text = getcpy (sp);
233 i = format_len + char_read + 256;
234 scanl = mh_xmalloc ((size_t) i + 2);
238 dat[3] = outputlinelen;
240 fmt_scan (fmt, scanl, i, dat);
243 fputs ("\nrepl: bad addresses:\n", out);
244 fputs ( badaddrs, out);
248 * Check if we should filter the message
249 * or add mhn directives
254 adios (drft, "error writing");
256 replfilter (inb, out, filter, fmtproc);
257 } else if (mime && mp) {
258 fprintf (out, "#forw [original message] +%s %s\n",
259 mp->foldpath, m_name (mp->lowsel));
264 adios (drft, "error writing");
267 /* return dynamically allocated buffers */
269 for (nxtbuf = compbuffers, i = ncomps; (cptr = *savecomp++); nxtbuf++, i--)
270 free (cptr->c_text); /* if not nxtbuf, nxtbuf already freed */
272 free (*nxtbuf++); /* free unused nxtbufs */
273 free ((char *) compbuffers);
274 free ((char *) used_buf);
277 static char *buf; /* our current working buffer */
278 static char *bufend; /* end of working buffer */
279 static char *last_dst; /* buf ptr at end of last call */
280 static unsigned int bufsiz=0; /* current size of buf */
282 #define BUFINCR 512 /* how much to expand buf when if fills */
284 #define CPY(s) { cp = (s); while ((*dst++ = *cp++)) ; --dst; }
287 * check if there's enough room in buf for str.
288 * add more mem if needed
290 #define CHECKMEM(str) \
291 if ((len = strlen (str)) >= bufend - dst) {\
293 int n = last_dst - buf;\
294 bufsiz += ((dst + len - bufend) / BUFINCR + 1) * BUFINCR;\
295 buf = mh_xrealloc (buf, bufsiz);\
298 bufend = buf + bufsiz;\
303 * fmt_scan will call this routine if the user includes the function
304 * "(formataddr {component})" in a format string. "orig" is the
305 * original contents of the string register. "str" is the address
306 * string to be formatted and concatenated onto orig. This routine
307 * returns a pointer to the concatenated address string.
309 * We try to not do a lot of malloc/copy/free's (which is why we
310 * don't call "getcpy") but still place no upper limit on the
311 * length of the result string.
314 formataddr (char *orig, char *str)
317 char baddr[BUFSIZ], error[BUFSIZ];
318 register int isgroup;
322 register struct mailname *mp = NULL;
324 /* if we don't have a buffer yet, get one */
326 buf = mh_xmalloc (BUFINCR);
327 last_dst = buf; /* XXX */
328 bufsiz = BUFINCR - 6; /* leave some slop */
329 bufend = buf + bufsiz;
332 * If "orig" points to our buffer we can just pick up where we
333 * left off. Otherwise we have to copy orig into our buffer.
337 else if (!orig || !*orig) {
341 dst = last_dst; /* XXX */
346 /* concatenate all the new addresses onto 'buf' */
347 for (isgroup = 0; (cp = getname (str)); ) {
348 if ((mp = getm (cp, dfhost, dftype, AD_NAME, error)) == NULL) {
349 snprintf (baddr, sizeof(baddr), "\t%s -- %s\n", cp, error);
350 badaddrs = add (baddr, badaddrs);
353 if (isgroup && (mp->m_gname || !mp->m_ingrp)) {
358 /* if we get here we're going to add an address */
364 CHECKMEM (mp->m_gname);
384 * fmt_scan will call this routine if the user includes the function
385 * "(concataddr {component})" in a format string. This behaves exactly
386 * like formataddr, except that it does NOT suppress duplicate addresses
389 * As an implementation detail: I thought about splitting out formataddr()
390 * into the generic part and duplicate-suppressing part, but the call to
391 * insert() was buried deep within a couple of loops and I didn't see a
392 * way to do it easily. So instead we simply set a special flag to stop
393 * the duplicate check and call formataddr().
396 concataddr(char *orig, char *str)
401 cp = formataddr(orig, str);
407 insert (struct mailname *np)
410 register struct mailname *mp;
415 if (np->m_mbox == NULL)
418 for (mp = &mq; mp->m_next; mp = mp->m_next) {
419 if (!mh_strcasecmp (np->m_host, mp->m_next->m_host)
420 && !mh_strcasecmp (np->m_mbox, mp->m_next->m_mbox))
423 if (!ccme && ismymbox (np))
427 snprintf (buffer, sizeof(buffer), "Reply to %s? ", adrformat (np));
428 if (!gans (buffer, anoyes))
445 * This function expects that argument out has been fflushed by the caller.
449 replfilter (FILE *in, FILE *out, char *filter, int fmtproc)
459 if (access (filter, R_OK) == NOTOK)
460 adios (filter, "unable to read");
462 mhl = r1bindex (mhlproc, '/');
465 lseek (fileno(in), (off_t) 0, SEEK_SET);
467 switch (pid = vfork()) {
469 adios ("fork", "unable to");
472 dup2 (fileno (in), fileno (stdin));
473 dup2 (fileno (out), fileno (stdout));
477 arglist[1] = "-form";
479 arglist[3] = "-noclear";
483 arglist[4] = "-fmtproc";
484 arglist[5] = formatproc;
488 arglist[4] = "-nofmtproc";
495 execvp (mhlproc, arglist);
496 errstr = strerror(errno);
497 write(2, "unable to exec ", 15);
498 write(2, mhlproc, strlen(mhlproc));
500 write(2, errstr, strlen(errstr));
505 if (pidXwait (pid, mhl))
507 fseek (out, 0L, SEEK_END);