X-Git-Url: http://git.marmaro.de/?a=blobdiff_plain;f=uip%2Fmhlsbr.c;h=45d99b037d1f1e585d34187dfd881ce2c7ac6661;hb=e69044f7624abe5cb2cb796d528c0cc5f29515f7;hp=58b297835afe55d678a97c160f25754a27477a57;hpb=5dd6771b28c257af405d7248639ed0e3bcdce38b;p=mmh diff --git a/uip/mhlsbr.c b/uip/mhlsbr.c index 58b2978..45d99b0 100644 --- a/uip/mhlsbr.c +++ b/uip/mhlsbr.c @@ -15,6 +15,9 @@ #include #include #include +#include +#include +#include /* * MAJOR BUG: @@ -50,44 +53,44 @@ static struct swit mhlswitches[] = { { "clear", 0 }, #define NCLRSW 3 { "noclear", 0 }, -#define FACESW 4 - { "faceproc program", 0 }, -#define NFACESW 5 - { "nofaceproc", 0 }, -#define FOLDSW 6 +#define FOLDSW 4 { "folder +folder", 0 }, -#define FORMSW 7 +#define FORMSW 5 { "form formfile", 0 }, -#define PROGSW 8 +#define PROGSW 6 { "moreproc program", 0 }, -#define NPROGSW 9 +#define NPROGSW 7 { "nomoreproc", 0 }, -#define LENSW 10 +#define LENSW 8 { "length lines", 0 }, -#define WIDTHSW 11 +#define WIDTHSW 9 { "width columns", 0 }, -#define SLEEPSW 12 +#define SLEEPSW 10 { "sleep seconds", 0 }, -#define BITSTUFFSW 13 +#define BITSTUFFSW 11 { "dashstuffing", -12 }, /* interface from forw */ -#define NBITSTUFFSW 14 +#define NBITSTUFFSW 12 { "nodashstuffing", -14 }, /* interface from forw */ -#define VERSIONSW 15 +#define VERSIONSW 13 { "version", 0 }, -#define HELPSW 16 +#define HELPSW 14 { "help", 0 }, -#define FORW1SW 17 +#define FORW1SW 15 { "forward", -7 }, /* interface from forw */ -#define FORW2SW 18 +#define FORW2SW 16 { "forwall", -7 }, /* interface from forw */ -#define DGSTSW 19 +#define DGSTSW 17 { "digest list", -6 }, -#define VOLUMSW 20 +#define VOLUMSW 18 { "volume number", -6 }, -#define ISSUESW 21 +#define ISSUESW 19 { "issue number", -5 }, -#define NBODYSW 22 +#define NBODYSW 20 { "nobody", -6 }, +#define FMTPROCSW 21 + { "fmtproc program", 0 }, +#define NFMTPROCSW 22 + { "nofmtproc", 0 }, { NULL, 0 } }; @@ -105,12 +108,64 @@ static struct swit mhlswitches[] = { #define DATEFMT 0x000800 /* contains dates */ #define FORMAT 0x001000 /* parse address/date/RFC-2047 field */ #define INIT 0x002000 /* initialize component */ -#define FACEFMT 0x004000 /* contains face */ -#define FACEDFLT 0x008000 /* default for face */ #define SPLIT 0x010000 /* split headers (don't concatenate) */ #define NONEWLINE 0x020000 /* don't write trailing newline */ -#define LBITS "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT\017FACEFMT\020FACEDFLT\021SPLIT\022NONEWLINE" -#define GFLAGS (NOCOMPONENT | UPPERCASE | CENTER | LEFTADJUST | COMPRESS | SPLIT) +#define NOWRAP 0x040000 /* Don't wrap lines ever */ +#define FMTFILTER 0x080000 /* Filter through format filter */ +#define LBITS "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT\021SPLIT\022NONEWLINE\023NOWRAP\024FMTFILTER" +#define GFLAGS (NOCOMPONENT | UPPERCASE | CENTER | LEFTADJUST | COMPRESS | SPLIT | NOWRAP) + +/* + * A format string to be used as a command-line argument to the body + * format filter. + */ + +struct arglist { + struct format *a_fmt; + char *a_nfs; + struct arglist *a_next; +}; + +/* + * Linked list of command line arguments for the body format filter. This + * USED to be in "struct mcomp", but the format API got cleaned up and even + * though it reduced the code we had to do, it make things more complicated + * for us. Specifically: + * + * - The interface to the hash table has been cleaned up, which means the + * rooting around in the hash table is no longer necessary (yay!). But + * this ALSO means that we have to make sure that we call our format + * compilation routines before we process the message, because the + * components need to be visible in the hash table so we can save them for + * later. So we moved them out of "mcomp" and now compile them right before + * header processing starts. + * - We also use format strings to handle other components in the mhl + * configuration (using "formatfield" and "decode"), but here life + * gets complicated: they aren't dealt with in the normal way. Instead + * of referring to a component like {from}, each component is processed + * using the special {text} component. But these format strings need to be + * compiled BEFORE we compile the format arguments; in the previous + * implementation they were compiled and scanned as the headers were + * read, and that would reset the hash table that we need to populate + * the components used by the body format filter. So we are compiling + * the formatfield component strings ahead of time and then scanning them + * later. + * + * Okay, fine ... this was broken before. But you know what? Fixing this + * the right way will make things easier down the road. + * + * One side-effect to this change: format strings are now compiled only once + * for components specified with "formatfield", but they are compiled for + * every message for format arguments. + */ + +static struct arglist *arglist_head; +static struct arglist *arglist_tail; +static int filter_nargs = 0; + +/* + * Flags/options for each component + */ struct mcomp { char *c_name; /* component name */ @@ -118,7 +173,8 @@ struct mcomp { char *c_ovtxt; /* text overflow indicator */ char *c_nfs; /* iff FORMAT */ struct format *c_fmt; /* .. */ - char *c_face; /* face designator */ + struct comp *c_c_text; /* Ref to {text} in FORMAT */ + struct comp *c_c_error; /* Ref to {error} */ int c_offset; /* left margin indentation */ int c_ovoff; /* overflow indentation */ int c_width; /* width of field */ @@ -134,11 +190,11 @@ static struct mcomp *fmthd = NULL; static struct mcomp *fmttl = NULL; static struct mcomp global = { - NULL, NULL, "", NULL, NULL, 0, -1, 80, -1, 40, BELL, 0 + NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, -1, 80, -1, 40, BELL, NULL }; static struct mcomp holder = { - NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, 0 + NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, NULL }; struct pair { @@ -148,7 +204,7 @@ struct pair { static struct pair pairs[] = { { "Date", DATEFMT }, - { "From", ADDRFMT|FACEDFLT }, + { "From", ADDRFMT }, { "Sender", ADDRFMT }, { "Reply-To", ADDRFMT }, { "To", ADDRFMT }, @@ -161,7 +217,6 @@ static struct pair pairs[] = { { "Resent-To", ADDRFMT }, { "Resent-cc", ADDRFMT }, { "Resent-Bcc", ADDRFMT }, - { "Face", FACEFMT }, { NULL, 0 } }; @@ -192,9 +247,29 @@ static struct triple triples[] = { { "datefield", DATEFMT, ADDRFMT }, { "newline", 0, NONEWLINE }, { "nonewline", NONEWLINE, 0 }, + { "wrap", 0, NOWRAP }, + { "nowrap", NOWRAP, 0 }, + { "format", FMTFILTER, 0 }, + { "noformat", 0, FMTFILTER }, { NULL, 0, 0 } }; +static char *addrcomps[] = { + "from", + "sender", + "reply-to", + "to", + "cc", + "bcc", + "resent-from", + "resent-sender", + "resent-reply-to", + "resent-to", + "resent-cc", + "resent-bcc", + NULL +}; + static int bellflg = 0; static int clearflg = 0; @@ -212,19 +287,21 @@ static int issue = 0; static int exitstat = 0; static int mhldebug = 0; +static int filesize = 0; + #define PITTY (-1) #define NOTTY 0 #define ISTTY 1 static int ontty = NOTTY; static int row; -static int column; +static unsigned int column; static int lm; static int llim; static int ovoff; static int term; -static int wid; +static unsigned int wid; static char *ovtxt; @@ -244,7 +321,6 @@ static char delim4[] = "\n------------------------------\n\n"; static FILE *(*mhl_action) () = (FILE *(*) ()) 0; - /* * Redefine a couple of functions. * These are undefined later in the code. @@ -269,33 +345,25 @@ static struct mcomp *add_queue (struct mcomp **, struct mcomp **, char *, char * static void free_queue (struct mcomp **, struct mcomp **); static void putcomp (struct mcomp *, struct mcomp *, int); static char *oneline (char *, long); -static void putstr (char *); -static void putch (char); -static RETSIGTYPE intrser (int); -static RETSIGTYPE pipeser (int); -static RETSIGTYPE quitser (int); -static void face_format (struct mcomp *); -static int doface (struct mcomp *); +static void putstr (char *, long); +static void putch (char, long); +static void intrser (int); +static void pipeser (int); +static void quitser (int); static void mhladios (char *, char *, ...); static void mhldone (int); static void m_popen (char *); - -int mhl (int, char **); -int mhlsbr (int, char **, FILE *(*)()); -void m_pclose (void); - -void clear_screen (void); /* from termsbr.c */ -int SOprintf (char *, ...); /* from termsbr.c */ -int sc_width (void); /* from termsbr.c */ -int sc_length (void); /* from termsbr.c */ -int sc_hardcopy (void); /* from termsbr.c */ +static void filterbody (struct mcomp *, char *, int, int, FILE *); +static void compile_formatfield(struct mcomp *); +static void compile_filterargs (void); int mhl (int argc, char **argv) { int length = 0, nomore = 0; - int i, width = 0, vecp = 0; + unsigned int i, vecp = 0; + int width = 0; char *cp, *folder = NULL, *form = NULL; char buf[BUFSIZ], *files[MAXARGS]; char **argp, **arguments; @@ -311,9 +379,6 @@ mhl (int argc, char **argv) if ((cp = getenv ("MHLDEBUG")) && *cp) mhldebug++; - if ((cp = getenv ("FACEPROC"))) - faceproc = cp; - while ((cp = *argp++)) { if (*cp == '-') { switch (smatch (++cp, mhlswitches)) { @@ -326,10 +391,10 @@ mhl (int argc, char **argv) case HELPSW: snprintf (buf, sizeof(buf), "%s [switches] [files ...]", invo_name); print_help (buf, mhlswitches, 1); - done (1); + done (0); case VERSIONSW: print_version(invo_name); - done (1); + done (0); case BELLSW: bellflg = 1; @@ -354,13 +419,6 @@ mhl (int argc, char **argv) adios (NULL, "missing argument to %s", argp[-2]); continue; - case FACESW: - if (!(faceproc = *argp++) || *faceproc == '-') - adios (NULL, "missing argument to %s", argp[-2]); - continue; - case NFACESW: - faceproc = NULL; - continue; case SLEEPSW: if (!(cp = *argp++) || *cp == '-') adios (NULL, "missing argument to %s", argp[-2]); @@ -375,6 +433,14 @@ mhl (int argc, char **argv) nomore++; continue; + case FMTPROCSW: + if (!(formatproc = *argp++) || *formatproc == '-') + adios (NULL, "missing argument to %s", argp[-2]); + continue; + case NFMTPROCSW: + formatproc = NULL; + continue; + case LENSW: if (!(cp = *argp++) || *cp == '-') adios (NULL, "missing argument to %s", argp[-2]); @@ -474,7 +540,7 @@ mhl (int argc, char **argv) printf ("%s", buf); } else - printf ("\n------- End of Forwarded Message%s\n\n", + printf ("\n------- End of Forwarded Message%s\n", vecp > 1 ? "s" : ""); } @@ -536,6 +602,7 @@ mhl_format (char *file, int length, int width) global.c_length = i - 1; global.c_flags = BELL; /* BELL is default */ *(ip = ignores) = NULL; + filter_nargs = 0; while (vfgets (fp, &ap) == OK) { bp = ap; @@ -595,13 +662,17 @@ mhl_format (char *file, int length, int width) } if (!c1->c_nfs && global.c_nfs) { if (c1->c_flags & DATEFMT) { - if (global.c_flags & DATEFMT) + if (global.c_flags & DATEFMT) { c1->c_nfs = getcpy (global.c_nfs); + compile_formatfield(c1); + } } else if (c1->c_flags & ADDRFMT) { - if (global.c_flags & ADDRFMT) + if (global.c_flags & ADDRFMT) { c1->c_nfs = getcpy (global.c_nfs); + compile_formatfield(c1); + } } } continue; @@ -676,21 +747,17 @@ evalvar (struct mcomp *c1) return ptos (name, &c1->c_ovtxt); if (!mh_strcasecmp (name, "formatfield")) { - char *nfs; - if (ptos (name, &cp)) return 1; - nfs = new_fs (NULL, NULL, cp); - c1->c_nfs = getcpy (nfs); + c1->c_nfs = getcpy (new_fs (NULL, NULL, cp)); + compile_formatfield(c1); c1->c_flags |= FORMAT; return 0; } if (!mh_strcasecmp (name, "decode")) { - char *nfs; - - nfs = new_fs (NULL, NULL, "%(decode{text})"); - c1->c_nfs = getcpy (nfs); + c1->c_nfs = getcpy (new_fs (NULL, NULL, "%(decode{text})")); + compile_formatfield(c1); c1->c_flags |= FORMAT; return 0; } @@ -715,6 +782,34 @@ evalvar (struct mcomp *c1) return 0; } + if (!mh_strcasecmp (name, "formatarg")) { + struct arglist *args; + + if (ptos (name, &cp)) + return 1; + + if (mh_strcasecmp (c1->c_name, "body")) { + advise (NULL, "format filters are currently only supported on " + "the \"body\" component"); + return 1; + } + + args = (struct arglist *) calloc((size_t) 1, sizeof(struct arglist)); + + if (arglist_tail) + arglist_tail->a_next = args; + + arglist_tail = args; + + if (! arglist_head) + arglist_head = args; + + args->a_nfs = getcpy (new_fs (NULL, NULL, cp)); + filter_nargs++; + + return 0; + } + return 1; } @@ -789,12 +884,18 @@ parse (void) } +/* + * Process one file/message + */ + static void process (char *folder, char *fname, int ofilen, int ofilec) { char *cp = NULL; FILE *fp = NULL; struct mcomp *c1; + struct stat st; + struct arglist *ap; switch (setjmp (env)) { case OK: @@ -809,11 +910,24 @@ process (char *folder, char *fname, int ofilen, int ofilec) fname = "(stdin)"; fp = stdin; } + if (fstat(fileno(fp), &st) == 0) { + filesize = st.st_size; + } else { + filesize = 0; + } cp = folder ? concat (folder, ":", fname, NULL) : getcpy (fname); if (ontty != PITTY) SIGNAL (SIGINT, intrser); mhlfile (fp, cp, ofilen, ofilec); /* FALL THROUGH! */ + for (ap = arglist_head; ap; ap = ap->a_next) { + fmt_free(ap->a_fmt, 0); + ap->a_fmt = NULL; + } + + if (arglist_head) + fmt_free(NULL, 1); + default: if (ontty != PITTY) SIGNAL (SIGINT, SIG_IGN); @@ -829,16 +943,19 @@ process (char *folder, char *fname, int ofilen, int ofilec) c1->c_flags &= ~HDROUTPUT; break; } + } static void mhlfile (FILE *fp, char *mname, int ofilen, int ofilec) { - int state; + int state, bucket; struct mcomp *c1, *c2, *c3; char **ip, name[NAMESZ], buf[BUFSIZ]; + compile_filterargs(); + if (forwall) { if (digest) printf ("%s", ofilen == 1 ? delim3 : delim4); @@ -901,10 +1018,13 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec) switch (state = m_getfld (state, name, buf, sizeof(buf), fp)) { case FLD: case FLDPLUS: + bucket = fmt_addcomptext(name, buf); for (ip = ignores; *ip; ip++) if (!mh_strcasecmp (name, *ip)) { - while (state == FLDPLUS) + while (state == FLDPLUS) { state = m_getfld (state, name, buf, sizeof(buf), fp); + fmt_appendcomp(bucket, name, buf); + } break; } if (*ip) @@ -926,6 +1046,7 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec) while (state == FLDPLUS) { state = m_getfld (state, name, buf, sizeof(buf), fp); c1->c_text = add (buf, c1->c_text); + fmt_appendcomp(bucket, name, buf); } if (c2 == NULL) c1->c_flags |= EXTRA; @@ -954,15 +1075,20 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec) continue; } if (dobody && !mh_strcasecmp (c1->c_name, "body")) { - holder.c_text = mh_xmalloc (sizeof(buf)); - strncpy (holder.c_text, buf, sizeof(buf)); - while (state == BODY) { - putcomp (c1, &holder, BODYCOMP); - state = m_getfld (state, name, holder.c_text, - sizeof(buf), fp); + if (c1->c_flags & FMTFILTER && state == BODY && + formatproc != NULL) { + filterbody(c1, buf, sizeof(buf), state, fp); + } else { + holder.c_text = mh_xmalloc (sizeof(buf)); + strncpy (holder.c_text, buf, sizeof(buf)); + while (state == BODY) { + putcomp (c1, &holder, BODYCOMP); + state = m_getfld (state, name, holder.c_text, + sizeof(buf), fp); + } + free (holder.c_text); + holder.c_text = NULL; } - free (holder.c_text); - holder.c_text = NULL; continue; } for (c2 = msghd; c2; c2 = c2->c_next) @@ -971,17 +1097,6 @@ mhlfile (FILE *fp, char *mname, int ofilen, int ofilec) if (!(c1->c_flags & SPLIT)) break; } - if (faceproc && c2 == NULL && (c1->c_flags & FACEFMT)) - for (c2 = msghd; c2; c2 = c2->c_next) - if (c2->c_flags & FACEDFLT) { - if (c2->c_face == NULL) - face_format (c2); - if ((holder.c_text = c2->c_face)) { - putcomp (c1, &holder, ONECOMP); - holder.c_text = NULL; - } - break; - } } return; @@ -1039,7 +1154,6 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2) int dat[5]; char *ap, *cp; char buffer[BUFSIZ], error[BUFSIZ]; - struct comp *cptr; struct pqpair *p, *q; struct pqpair pq; struct mailname *mp; @@ -1048,24 +1162,22 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2) c2->c_text = NULL; dat[0] = 0; dat[1] = 0; - dat[2] = 0; + dat[2] = filesize; dat[3] = sizeof(buffer) - 1; dat[4] = 0; - fmt_compile (c1->c_nfs, &c1->c_fmt); if (!(c1->c_flags & ADDRFMT)) { - FINDCOMP (cptr, "text"); - if (cptr) - cptr->c_text = ap; + if (c1->c_c_text) + c1->c_c_text->c_text = ap; if ((cp = strrchr(ap, '\n'))) /* drop ending newline */ if (!cp[1]) *cp = 0; - fmt_scan (c1->c_fmt, buffer, sizeof(buffer) - 1, dat); + fmt_scan (c1->c_fmt, buffer, sizeof buffer - 1, sizeof buffer - 1, dat); /* Don't need to append a newline, dctime() already did */ c2->c_text = getcpy (buffer); - free (ap); + /* ap is now owned by the component struct, so do NOT free it here */ return; } @@ -1078,15 +1190,6 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2) p->pq_text = getcpy (cp); p->pq_error = getcpy (error); } else { - if ((c1->c_flags & FACEDFLT) && c2->c_face == NULL) { - char *h, *o; - if ((h = mp->m_host) == NULL) - h = LocalName (); - if ((o = OfficialName (h))) - h = o; - c2->c_face = concat ("address ", h, " ", mp->m_mbox, - NULL); - } p->pq_text = getcpy (mp->m_text); mnfree (mp); } @@ -1094,14 +1197,16 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2) } for (p = pq.pq_next; p; p = q) { - FINDCOMP (cptr, "text"); - if (cptr) - cptr->c_text = p->pq_text; - FINDCOMP (cptr, "error"); - if (cptr) - cptr->c_text = p->pq_error; + if (c1->c_c_text) { + c1->c_c_text->c_text = p->pq_text; + p->pq_text = NULL; + } + if (c1->c_c_error) { + c1->c_c_error->c_text = p->pq_error; + p->pq_error = NULL; + } - fmt_scan (c1->c_fmt, buffer, sizeof(buffer) - 1, dat); + fmt_scan (c1->c_fmt, buffer, sizeof buffer - 1, sizeof buffer - 1, dat); if (*buffer) { if (c2->c_text) c2->c_text = add (",\n", c2->c_text); @@ -1110,7 +1215,8 @@ mcomp_format (struct mcomp *c1, struct mcomp *c2) c2->c_text = add (buffer, c2->c_text); } - free (p->pq_text); + if (p->pq_text) + free (p->pq_text); if (p->pq_error) free (p->pq_error); q = p->pq_next; @@ -1169,9 +1275,7 @@ free_queue (struct mcomp **head, struct mcomp **tail) if (c1->c_nfs) free (c1->c_nfs); if (c1->c_fmt) - free ((char *) c1->c_fmt); - if (c1->c_face) - free (c1->c_face); + fmt_free (c1->c_fmt, 0); free ((char *) c1); } @@ -1199,21 +1303,11 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag) onelp = NULL; if (c1->c_flags & CLEARTEXT) { - putstr (c1->c_text); - putstr ("\n"); + putstr (c1->c_text, c1->c_flags); + putstr ("\n", c1->c_flags); return; } - if (c1->c_flags & FACEFMT) - switch (doface (c2)) { - case NOTOK: /* error */ - case OK: /* async faceproc */ - return; - - default: /* sync faceproc */ - break; - } - if (c1->c_nfs && (c1->c_flags & (ADDRFMT | DATEFMT | FORMAT))) mcomp_format (c1, c2); @@ -1233,9 +1327,9 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag) for (cp = (c1->c_text ? c1->c_text : c1->c_name); *cp; cp++) if (islower (*cp)) *cp = toupper (*cp); - putstr (c1->c_text ? c1->c_text : c1->c_name); + putstr (c1->c_text ? c1->c_text : c1->c_name, c1->c_flags); if (flag != BODYCOMP) { - putstr (": "); + putstr (": ", c1->c_flags); if (!(c1->c_flags & SPLIT)) c1->c_flags |= HDROUTPUT; @@ -1243,7 +1337,7 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag) if ((count = c1->c_cwidth - strlen (c1->c_text ? c1->c_text : c1->c_name) - 2) > 0) while (count--) - putstr (" "); + putstr (" ", c1->c_flags); } else c1->c_flags |= HDROUTPUT; /* for BODYCOMP */ @@ -1256,15 +1350,15 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag) for (cp = c2->c_name; *cp; cp++) if (islower (*cp)) *cp = toupper (*cp); - putstr (c2->c_name); - putstr (": "); + putstr (c2->c_name, c1->c_flags); + putstr (": ", c1->c_flags); if (!(c1->c_flags & SPLIT)) c2->c_flags |= HDROUTPUT; cchdr++; if ((count = c1->c_cwidth - strlen (c2->c_name) - 2) > 0) while (count--) - putstr (" "); + putstr (" ", c1->c_flags); } if (c1->c_flags & UPPERCASE) for (cp = c2->c_text; *cp; cp++) @@ -1275,26 +1369,26 @@ putcomp (struct mcomp *c1, struct mcomp *c2, int flag) if (cchdr) { if (flag == TWOCOMP) count = (c1->c_cwidth >= 0) ? c1->c_cwidth - : strlen (c2->c_name) + 2; + : (int) strlen (c2->c_name) + 2; else - count = (c1->c_cwidth >= 0) ? c1->c_cwidth + count = (c1->c_cwidth >= 0) ? (size_t) c1->c_cwidth : strlen (c1->c_text ? c1->c_text : c1->c_name) + 2; } count += c1->c_offset; if ((cp = oneline (c2->c_text, c1->c_flags))) - putstr(cp); + putstr(cp, c1->c_flags); if (term == '\n') - putstr ("\n"); + putstr ("\n", c1->c_flags); while ((cp = oneline (c2->c_text, c1->c_flags))) { lm = count; if (flag == BODYCOMP && !(c1->c_flags & NOCOMPONENT)) - putstr (c1->c_text ? c1->c_text : c1->c_name); + putstr (c1->c_text ? c1->c_text : c1->c_name, c1->c_flags); if (*cp) - putstr (cp); + putstr (cp, c1->c_flags); if (term == '\n') - putstr ("\n"); + putstr ("\n", c1->c_flags); } if (flag == BODYCOMP && term == '\n') c1->c_flags &= ~HDROUTPUT; /* Buffer ended on a newline */ @@ -1354,27 +1448,27 @@ oneline (char *stuff, long flags) static void -putstr (char *string) +putstr (char *string, long flags) { if (!column && lm > 0) { while (lm > 0) if (lm >= 8) { - putch ('\t'); + putch ('\t', flags); lm -= 8; } else { - putch (' '); + putch (' ', flags); lm--; } } lm = 0; while (*string) - putch (*string++); + putch (*string++, flags); } static void -putch (char ch) +putch (char ch, long flags) { char buf[BUFSIZ]; @@ -1431,12 +1525,12 @@ putch (char ch) break; } - if (column >= wid) { - putch ('\n'); + if (column >= wid && (flags & NOWRAP) == 0) { + putch ('\n', flags); if (ovoff > 0) lm = ovoff; - putstr (ovtxt ? ovtxt : ""); - putch (ch); + putstr (ovtxt ? ovtxt : "", flags); + putch (ch, flags); return; } @@ -1444,12 +1538,10 @@ putch (char ch) } -static RETSIGTYPE +static void intrser (int i) { -#ifndef RELIABLE_SIGNALS - SIGNAL (SIGINT, intrser); -#endif + NMH_UNUSED (i); discard (stdout); putchar ('\n'); @@ -1457,23 +1549,19 @@ intrser (int i) } -static RETSIGTYPE +static void pipeser (int i) { -#ifndef RELIABLE_SIGNALS - SIGNAL (SIGPIPE, pipeser); -#endif + NMH_UNUSED (i); done (NOTOK); } -static RETSIGTYPE +static void quitser (int i) { -#ifndef RELIABLE_SIGNALS - SIGNAL (SIGQUIT, quitser); -#endif + NMH_UNUSED (i); putchar ('\n'); fflush (stdout); @@ -1481,215 +1569,13 @@ quitser (int i) } -static void -face_format (struct mcomp *c1) -{ - char *cp; - struct mailname *mp; - - if ((cp = c1->c_text) == NULL) - return; - - if ((cp = getname (cp))) { - if ((mp = getm (cp, NULL, 0, AD_NAME, NULL))) { - char *h, *o; - if ((h = mp->m_host) == NULL) - h = LocalName (); - if ((o = OfficialName (h))) - h = o; - c1->c_face = concat ("address ", h, " ", mp->m_mbox, NULL); - } - - while ((cp = getname (cp))) - continue; - } -} - - -/* - * faceproc is two elements defining the image agent's location: - * Internet host - * UDP port - */ - -#include -#include -#include - -#ifdef HAVE_ARPA_INET_H -# include -#endif - -static int -doface (struct mcomp *c1) -{ - int result, sd; - static int inited = OK; - static struct sockaddr_storage ss; - static socklen_t socklen; - static int socktype; - static int protocol; - - if (inited == OK) { - char *cp; - char **ap = brkstring (cp = getcpy (faceproc), " ", "\n"); - struct addrinfo hints, *res; - - if (ap[0] == NULL || ap[1] == NULL) { -bad_faceproc: ; - free (cp); - return (inited = NOTOK); - } - - memset(&hints, 0, sizeof(hints)); -#ifdef AI_ADDRCONFIG - hints.ai_flags = AI_ADDRCONFIG; -#endif - hints.ai_family = PF_UNSPEC; - hints.ai_socktype = SOCK_DGRAM; - - if (getaddrinfo(ap[0], ap[1], &hints, &res) != 0) - goto bad_faceproc; - - memcpy(&ss, res->ai_addr, res->ai_addrlen); - socklen = res->ai_addrlen; - socktype = res->ai_socktype; - protocol = res->ai_protocol; - freeaddrinfo(res); - - inited = DONE; - } - if (inited == NOTOK) - return NOTOK; - - if ((sd = socket (ss.ss_family, socktype, protocol)) == NOTOK) - return NOTOK; - - result = sendto (sd, c1->c_text, strlen (c1->c_text), 0, - (struct sockaddr *) &ss, socklen); - - close (sd); - - return (result != NOTOK ? OK : NOTOK); -} - -/* - * COMMENTED OUT - * This version doesn't use sockets - */ -#if 0 - -static int -doface (struct mcomp *c1) -{ - int i, len, vecp; - pid_t child_id; - int result, pdi[2], pdo[2]; - char *bp, *cp; - char buffer[BUFSIZ], *vec[10]; - - if (pipe (pdi) == NOTOK) - return NOTOK; - if (pipe (pdo) == NOTOK) { - close (pdi[0]); - close (pdi[1]); - return NOTOK; - } - - for (i = 0; (child_id = vfork()) == NOTOK && i < 5; i++) - sleep (5); - - switch (child_id) { - case NOTOK: - /* oops... fork error */ - return NOTOK; - - case OK: - /* child process */ - SIGNAL (SIGINT, SIG_IGN); - SIGNAL (SIGQUIT, SIG_IGN); - if (pdi[0] != fileno (stdin)) { - dup2 (pdi[0], fileno (stdin)); - close (pdi[0]); - } - close (pdi[1]); - close (pdo[0]); - if (pdo[1] != fileno (stdout)) { - dup2 (pdo[1], fileno (stdout)); - close (pdo[1]); - } - vecp = 0; - vec[vecp++] = r1bindex (faceproc, '/'); - vec[vecp++] = "-e"; - if (sleepsw != NOTOK) { - vec[vecp++] = "-s"; - snprintf (buffer, sizeof(buffer), "%d", sleepsw); - vec[vecp++] = buffer; - } - vec[vecp] = NULL; - execvp (faceproc, vec); - fprintf (stderr, "unable to exec "); - perror (faceproc); - _exit (-1); /* NOTREACHED */ - - default: - /* parent process */ - close (pdi[0]); - i = strlen (c1->c_text); - if (write (pdi[1], c1->c_text, i) != i) - adios ("pipe", "error writing to"); - free (c1->c_text), c1->c_text = NULL; - close (pdi[1]); - - close (pdo[1]); - cp = NULL, len = 0; - result = DONE; - while ((i = read (pdo[0], buffer, strlen (buffer))) > 0) { - if (cp) { - int j; - char *dp; - dp = mh_xrealloc (cp, (unsigned) (j = len + i)); - memcpy(dp + len, buffer, i); - cp = dp, len = j; - } - else { - cp = mh_xmalloc ((unsigned) i); - memcpy(cp, buffer, i); - len = i; - } - if (result == DONE) - for (bp = buffer + i - 1; bp >= buffer; bp--) - if (!isascii (*bp) || iscntrl (*bp)) { - result = OK; - break; - } - } - close (pdo[0]); - -/* no waiting for child... */ - - if (result == OK) { /* binary */ - if (write (1, cp, len) != len) - adios ("writing", "error"); - free (cp); - } - else /* empty */ - if ((c1->c_text = cp) == NULL) - result = OK; - break; - } - - return result; -} -#endif /* COMMENTED OUT */ - - int mhlsbr (int argc, char **argv, FILE *(*action)()) { SIGNAL_HANDLER istat = NULL, pstat = NULL, qstat = NULL; char *cp = NULL; struct mcomp *c1; + struct arglist *a, *a2; switch (setjmp (mhlenv)) { case OK: @@ -1726,6 +1612,15 @@ mhlsbr (int argc, char **argv, FILE *(*action)()) free_queue (&msghd, &msgtl); for (c1 = fmthd; c1; c1 = c1->c_next) c1->c_flags &= ~HDROUTPUT; + + a = arglist_head; + while (a) { + if (a->a_nfs) + free(a->a_nfs); + a2 = a->a_next; + free(a); + a = a2; + } return exitstat; } } @@ -1770,7 +1665,7 @@ m_popen (char *name) if (pipe (pd) == NOTOK) adios ("pipe", "unable to"); - switch (m_pid = vfork ()) { + switch (m_pid = vfork()) { case NOTOK: adios ("fork", "unable to"); @@ -1819,3 +1714,271 @@ m_pclose (void) pidwait (m_pid, OK); m_pid = NOTOK; } + + +/* + * Compile a format string used by the formatfield option and save it + * for later. + * + * We will want the {text} (and possibly {error}) components for later, + * so look for them and save them if we find them. + */ + +static void +compile_formatfield(struct mcomp *c1) +{ + fmt_compile(c1->c_nfs, &c1->c_fmt, 1); + + /* + * As a note to myself and any other poor bastard who is looking through + * this code in the future .... + * + * When the format hash table is reset later on (as it almost certainly + * will be), there will still be references to these components in the + * compiled format instructions. Thus these component references will + * be free'd when the format instructions are free'd (by fmt_free()). + * + * So, in other words ... don't go free'ing them yourself! + */ + + c1->c_c_text = fmt_findcomp("text"); + c1->c_c_error = fmt_findcomp("error"); +} + +/* + * Compile all of the arguments for our format list. + * + * Iterate through the linked list of format strings and compile them. + * Note that we reset the format hash table before we start, but we do NOT + * reset it between calls to fmt_compile(). + * + */ + +static void +compile_filterargs (void) +{ + struct arglist *arg = arglist_head; + struct comp *cptr; + char **ap; + + fmt_free(NULL, 1); + + while (arg) { + fmt_compile(arg->a_nfs, &arg->a_fmt, 0); + arg = arg->a_next; + } + + /* + * Search through and mark any components that are address components + */ + + for (ap = addrcomps; *ap; ap++) { + cptr = fmt_findcomp (*ap); + if (cptr) + cptr->c_type |= CT_ADDR; + } +} + +/* + * Filter the body of a message through a specified format program + */ + +static void +filterbody (struct mcomp *c1, char *buf, int bufsz, int state, FILE *fp) +{ + struct mcomp holder; + char name[NAMESZ]; + int fdinput[2], fdoutput[2], waitstat; + ssize_t cc; + pid_t writerpid, filterpid; + + /* + * Create pipes so we can communicate with our filter process. + */ + + if (pipe(fdinput) < 0) { + adios(NULL, "Unable to create input pipe"); + } + + if (pipe(fdoutput) < 0) { + adios(NULL, "Unable to create output pipe"); + } + + /* + * Here's what we're doing to do. + * + * - Fork ourselves and start writing data to the write side of the + * input pipe (fdinput[1]). + * + * - Fork and exec our filter program. We set the standard input of + * our filter program to be the read side of our input pipe (fdinput[0]). + * Standard output is set to the write side of our output pipe + * (fdoutput[1]). + * + * - We read from the read side of the output pipe (fdoutput[0]). + * + * We're forking because that's the simplest way to prevent any deadlocks. + * (without doing something like switching to non-blocking I/O and using + * select or poll, and I'm not interested in doing that). + */ + + switch (writerpid = fork()) { + case 0: + /* + * Our child process - just write to the filter input (fdinput[1]). + * Close all other descriptors that we don't need. + */ + + close(fdinput[0]); + close(fdoutput[0]); + close(fdoutput[1]); + + /* + * Call m_getfld() until we're no longer in the BODY state + */ + + while (state == BODY) { + write(fdinput[1], buf, strlen(buf)); + state = m_getfld(state, name, buf, bufsz, fp); + } + + /* + * We should be done; time to exit. + */ + + close(fdinput[1]); + /* + * Make sure we call _exit(), otherwise we may flush out the stdio + * buffers that we have duplicated from the parent. + */ + _exit(0); + break; + case -1: + adios(NULL, "Unable to fork for filter writer process"); + break; + } + + /* + * Fork and exec() our filter program, after redirecting standard in + * and standard out appropriately. + */ + + switch (filterpid = fork()) { + char **args; + struct arglist *a; + int i, dat[5], s; + + case 0: + /* + * Allocate an argument array for us + */ + + args = (char **) mh_xmalloc((filter_nargs + 2) * sizeof(char *)); + args[0] = formatproc; + args[filter_nargs + 1] = NULL; + dat[0] = 0; + dat[1] = 0; + dat[2] = 0; + dat[3] = BUFSIZ; + dat[4] = 0; + + /* + * Pull out each argument and scan them. + */ + + for (a = arglist_head, i = 1; a != NULL; a = a->a_next, i++) { + args[i] = mh_xmalloc(BUFSIZ); + fmt_scan(a->a_fmt, args[i], BUFSIZ - 1, BUFSIZ, dat); + /* + * fmt_scan likes to put a trailing newline at the end of the + * format string. If we have one, get rid of it. + */ + s = strlen(args[i]); + if (args[i][s - 1] == '\n') + args[i][s - 1] = '\0'; + + if (mhldebug) + fprintf(stderr, "filterarg: fmt=\"%s\", output=\"%s\"\n", + a->a_nfs, args[i]); + } + + if (dup2(fdinput[0], STDIN_FILENO) < 0) { + adios("formatproc", "Unable to dup2() standard input"); + } + if (dup2(fdoutput[1], STDOUT_FILENO) < 0) { + adios("formatproc", "Unable to dup2() standard output"); + } + + /* + * Close everything (especially the old input and output + * descriptors, since they've been dup'd to stdin and stdout), + * and exec the formatproc. + */ + + close(fdinput[0]); + close(fdinput[1]); + close(fdoutput[0]); + close(fdoutput[1]); + + execvp(formatproc, args); + + adios(formatproc, "Unable to execute filter"); + + break; + + case -1: + adios(NULL, "Unable to fork format program"); + } + + /* + * Close everything except our reader (fdoutput[0]); + */ + + close(fdinput[0]); + close(fdinput[1]); + close(fdoutput[1]); + + /* + * As we read in this data, send it to putcomp + */ + + holder.c_text = buf; + + while ((cc = read(fdoutput[0], buf, bufsz - 1)) > 0) { + buf[cc] = '\0'; + putcomp(c1, &holder, BODYCOMP); + } + + if (cc < 0) { + adios(NULL, "reading from formatproc"); + } + + /* + * See if we got any errors along the way. I'm a little leery of calling + * waitpid() without WNOHANG, but it seems to be the most correct solution. + */ + + if (waitpid(filterpid, &waitstat, 0) < 0) { + if (errno != ECHILD) { + adios("filterproc", "Unable to determine status"); + } + } else { + if (! (WIFEXITED(waitstat) && WEXITSTATUS(waitstat) == 0)) { + pidstatus(waitstat, stderr, "filterproc"); + } + } + + if (waitpid(writerpid, &waitstat, 0) < 0) { + if (errno != ECHILD) { + adios("writer process", "Unable to determine status"); + done(1); + } + } else { + if (! (WIFEXITED(waitstat) && WEXITSTATUS(waitstat) == 0)) { + pidstatus(waitstat, stderr, "writer process"); + done(1); + } + } + + close(fdoutput[0]); +}