+
+
+/*
+ * Compile a format string and add it to the list of arguments used by
+ * the formatproc.
+ *
+ * This deserves some explanation. Here's the deal:
+ *
+ * We want to keep track of components used as arguments by formatproc,
+ * but the hash table is reset every time fmt_compile is called. So we
+ * iterate through the function list looking for things that use components
+ * and save the name. And because we might get the same components used
+ * by different arguments we need to keep track to every reference of
+ * every component so we can add them when the message is processed. So
+ * we compile the argument string now (to get the components we use) and
+ * save them for later.
+ */
+
+static int
+compileargs (struct mcomp *c1, char *nfs)
+{
+ struct format *fmt;
+ struct arglist *args;
+ char **ap;
+ struct comp *cptr;
+ unsigned int i;
+
+ i = fmt_compile(nfs, &fmt);
+
+ /*
+ * Search through and mark any components that are address components
+ */
+
+ for (ap = addrcomps; *ap; ap++) {
+ FINDCOMP (cptr, *ap);
+ if (cptr)
+ cptr->c_type |= CT_ADDR;
+ }
+
+ args = (struct arglist *) mh_xmalloc(sizeof(struct arglist));
+
+ if (! args)
+ adios (NULL, "Unable to allocate formatproc args storage");
+
+ args->a_fmt = fmt;
+ args->a_nfs = format_string;
+ args->a_next = NULL;
+ c1->c_nargs++;
+ format_string = NULL;
+
+ if (c1->c_f_tail)
+ c1->c_f_tail->a_next = args;
+
+ c1->c_f_tail = args;
+
+ if (! c1->c_f_args)
+ c1->c_f_args = args;
+
+ if (i == 0)
+ return 0;
+
+ /*
+ * If wantcomp ever changes size, we need to change the size
+ * of mhlcomp as well
+ */
+
+ for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++) {
+ if (wantcomp[i]) {
+ if (mhlcomp[i]) {
+ struct comp *c;
+ for (c = mhlcomp[i]; c->c_next != NULL; c = c->c_next)
+ ;
+ c->c_next = wantcomp[i];
+ } else
+ mhlcomp[i] = wantcomp[i];
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * Check to see if we are interested in a component. If we are, save
+ * the text.
+ */
+
+static int
+checkcomp(char *name, char *buf)
+{
+ int found = 0, i;
+ struct comp *c;
+ int bucket = CHASH(name);
+ char *cp;
+
+ if ((c = mhlcomp[bucket])) {
+ do {
+ if (mh_strcasecmp(name, c->c_name) == 0) {
+ found++;
+ if (! c->c_text) {
+ c->c_text = strdup(buf);
+ } else {
+ i = strlen(cp = c->c_text) - 1;
+ if (cp[i] == '\n') {
+ if (c->c_type & CT_ADDR) {
+ cp[i] = '\0';
+ cp = add (",\n\t", cp);
+ } else {
+ cp = add ("\t", cp);
+ }
+ }
+ c->c_text = add (buf, cp);
+ }
+ }
+ } while ((c = c->c_next));
+ }
+
+ return found ? bucket : -1;
+}
+
+/*
+ * Add text to an existing component
+ */
+
+static void
+addcomp(int bucket, char *name, char *buf)
+{
+ struct comp *c;
+
+ if (bucket != -1) {
+ c = mhlcomp[bucket];
+ do {
+ if (mh_strcasecmp(name, c->c_name) == 0)
+ c->c_text = add (buf, c->c_text);
+ } while ((c = c->c_next));
+ }
+}
+
+/*
+ * Free up saved component structures
+ */
+
+static void
+freecomps(void)
+{
+ struct comp *c1, *c2;
+ unsigned int i;
+
+ for (i = 0; i < sizeof(mhlcomp)/sizeof(mhlcomp[0]); i++) {
+ if ((c1 = mhlcomp[i]))
+ for (; c1; c1 = c2) {
+ c2 = c1->c_next;
+ if (c1->c_text)
+ free(c1->c_text);
+ free(c1);
+ }
+ }
+}
+
+/*
+ * Just free up the component text.
+ */
+
+static void
+freecomptext(void)
+{
+ struct comp *c1;
+ unsigned int i;
+
+ for (i = 0; i < sizeof(mhlcomp)/sizeof(mhlcomp[0]); i++) {
+ if ((c1 = mhlcomp[i]))
+ for (; c1; c1 = c1->c_next) {
+ if (c1->c_text) {
+ free(c1->c_text);
+ c1->c_text = NULL;
+ }
+ }
+ }
+}
+
+/*
+ * 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((c1->c_nargs + 2) * sizeof(char *));
+ args[0] = formatproc;
+ args[c1->c_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 = c1->c_f_args, 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 (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]);
+}