/* Copyright (C) 1989, 1990, 1991, 1992, 2000, 2001, 2002, 2003

 * Free Software Foundation, Inc.

 * Copyright (C) 2003-2017 Colin Watson.

 *   Written for groff by James Clark (jjc@jclark.com)

 *   Heavily adapted and extended for man-db by Colin Watson.

 *

 * This file is part of libpipeline.

 *

 * libpipeline is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * libpipeline is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with libpipeline; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301

 * USA.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <stdio.h>

#include <stdlib.h>

#include <signal.h>

#include <errno.h>

#include <sys/select.h>

#include <sys/time.h>

#include <sys/types.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdarg.h>

#include <assert.h>

#include <string.h>

#include <sys/wait.h>

#include "dirname.h"

#include "full-write.h"

#include "safe-read.h"

#include "safe-write.h"

#include "xalloc.h"

#include "xstrndup.h"

#include "xvasprintf.h"

#include "pipeline-private.h"

#include "error.h"

#include "pipeline.h"

#ifdef USE_SOCKETPAIR_PIPE

#   include <netdb.h>

#   include <netinet/in.h>

#   include <sys/socket.h>

#   ifdef CORRECT_SOCKETPAIR_MODE

#	include <sys/stat.h>

#   endif

#   ifndef SHUT_RD

#	define SHUT_RD		0

#   endif

#   ifndef SHUT_WR

#	define SHUT_WR		1

#   endif

#   ifdef CORRECT_SOCKETPAIR_MODE

#	define pipe(p) (((socketpair(AF_UNIX,SOCK_STREAM,0,p) < 0) || \

                   (shutdown((p)[1],SHUT_RD) < 0) || (fchmod((p)[1],S_IWUSR) < 0) || \

                   (shutdown((p)[0],SHUT_WR) < 0) || (fchmod((p)[0],S_IRUSR) < 0)) ? -1 : 0)

#   else

#	define pipe(p) (((socketpair(AF_UNIX,SOCK_STREAM,0,p) < 0) || \

                   (shutdown((p)[1],SHUT_RD) < 0) || (shutdown((p)[0],SHUT_WR) < 0)) ? -1 : 0)

#   endif

#endif

#if defined(HAVE_SETENV) && !defined(HAVE_CLEARENV)

int clearenv (void)

{

	/* According to:

	 *   http://hg.dovecot.org/dovecot-2.0/file/74d9f61e224d/src/lib/env-util.c#l56

	 * simply setting "environ = NULL" crashes some systems.  Creating a

	 * new environment consisting of just a terminator is indeed

	 * probably the best we can do.

	 */

	environ = XCALLOC (1, char *);

	return 0;

}

#endif

/* ---------------------------------------------------------------------- */

/* Functions to build individual commands. */

pipecmd *pipecmd_new (const char *name)

{

	pipecmd *cmd = XMALLOC (pipecmd);

	struct pipecmd_process *cmdp;

	char *name_base;

	cmd->tag = PIPECMD_PROCESS;

	cmd->name = xstrdup (name);

	cmd->nice = 0;

	cmd->discard_err = 0;

	cmd->cwd_fd = -1;

	cmd->cwd = NULL;

	cmd->nenv = 0;

	cmd->env_max = 4;

	cmd->env = xnmalloc (cmd->env_max, sizeof *cmd->env);

	cmd->pre_exec_func = NULL;

	cmd->pre_exec_free_func = NULL;

	cmd->pre_exec_data = NULL;

	cmdp = &cmd->u.process;

	cmdp->argc = 0;

	cmdp->argv_max = 4;

	cmdp->argv = xnmalloc (cmdp->argv_max, sizeof *cmdp->argv);

	/* argv[0] is the basename of the command name. */

	name_base = base_name (name);

	pipecmd_arg (cmd, name_base);

	free (name_base);

	return cmd;

}

pipecmd *pipecmd_new_argv (const char *name, va_list argv)

{

	pipecmd *cmd = pipecmd_new (name);

	pipecmd_argv (cmd, argv);

	return cmd;

}

pipecmd *pipecmd_new_args (const char *name, ...)

{

	va_list argv;

	pipecmd *cmd;

	va_start (argv, name);

	cmd = pipecmd_new_argv (name, argv);

	va_end (argv);

	return cmd;

}

/* As suggested in the header file, this function (for pipecmd_new_argstr()

 * and pipecmd_argstr()) is really a wart. If we didn't have to worry about

 * old configuration files then it wouldn't be necessary. Worse, the

 * definition for tr in man_db.conf currently contains single-quoting, and

 * people probably took that as a licence to do similar things, so we're

 * obliged to worry about quoting as well!

 *

 * However, we can mitigate this; shell quoting alone is safe though

 * sometimes confusing, but it's other shell constructs that tend to cause

 * real security holes. Therefore, rather than punting to 'sh -c' or

 * whatever, we parse a safe subset manually. Environment variables are not

 * currently handled because of tricky word splitting issues, but in

 * principle they could be if there's demand for it.

 *

 * TODO: Support setting environment variables.

 */

static char *argstr_get_word (const char **argstr)

{

	char *out = NULL;

	const char *litstart = *argstr;

	enum { NONE, SINGLE, DOUBLE } quotemode = NONE;

	while (**argstr) {

		char backslashed[2];

		/* If it's just a literal character, go round again. */

		if ((quotemode == NONE && !strchr (" \t'\"\\", **argstr)) ||

		    /* nothing is special in '; terminated by ' */

		    (quotemode == SINGLE && **argstr != '\'') ||

		    /* \ is special in "; terminated by " */

		    (quotemode == DOUBLE && !strchr ("\"\\", **argstr))) {

			++*argstr;

			continue;

		}

		/* Within "", \ is only special when followed by $, `, ", or

		 * \ (or <newline> in a real shell, but we don't do that).

		 */

		if (quotemode == DOUBLE && **argstr == '\\' &&

		    !strchr ("$`\"\\", *(*argstr + 1))) {

			++*argstr;

			continue;

		}

		/* Copy any accumulated literal characters. */

		if (litstart < *argstr) {

			char *tmp = xstrndup (litstart, *argstr - litstart);

			out = appendstr (out, tmp, NULL);

			free (tmp);

		}

		switch (**argstr) {

			case ' ':

			case '\t':

				/* End of word; skip over extra whitespace. */

				while (*++*argstr)

					if (!strchr (" \t", **argstr))

						break;

				return out;

			case '\'':

				if (quotemode != NONE)

					quotemode = NONE;

				else

					quotemode = SINGLE;

				litstart = ++*argstr;

				break;

			case '"':

				if (quotemode != NONE)

					quotemode = NONE;

				else

					quotemode = DOUBLE;

				litstart = ++*argstr;

				break;

			case '\\':

				backslashed[0] = *++*argstr;

				if (!backslashed[0]) {

					/* Unterminated quoting; give up. */

					free (out);

					return NULL;

				}

				backslashed[1] = '\0';

				out = appendstr (out, backslashed, NULL);

				litstart = ++*argstr;

				break;

			default:

				assert (!"unexpected state parsing argstr");

		}

	}

	if (quotemode != NONE) {

		/* Unterminated quoting; give up. */

		free (out);

		return NULL;

	}

	/* Copy any accumulated literal characters. */

	if (litstart < *argstr) {

		char *tmp = xstrndup (litstart, *argstr - litstart);

		out = appendstr (out, tmp, NULL);

		free (tmp);

	}

	return out;

}

pipecmd *pipecmd_new_argstr (const char *argstr)

{

	pipecmd *cmd;

	char *arg;

	arg = argstr_get_word (&argstr);

	if (!arg)

		error (FATAL, 0,

		       "badly formed configuration directive: '%s'",

		       argstr);

	if (!strcmp (arg, "exec")) {

		/* Some old configuration files have "exec command" rather

		 * than "command"; this worked fine when being evaluated by

		 * a shell, but since exec is a shell builtin it doesn't

		 * work when being executed directly. To work around this,

		 * we just drop "exec" if it appears at the start of argstr.

		 */

		free (arg);

		arg = argstr_get_word (&argstr);

		if (!arg)

			error (FATAL, 0,

			       "badly formed configuration directive: '%s'",

			       argstr);

	}

	cmd = pipecmd_new (arg);

	free (arg);

	while ((arg = argstr_get_word (&argstr))) {

		pipecmd_arg (cmd, arg);

		free (arg);

	}

	return cmd;

}

pipecmd *pipecmd_new_function (const char *name,

			       pipecmd_function_type *func,

			       pipecmd_function_free_type *free_func,

			       void *data)

{

	pipecmd *cmd = XMALLOC (pipecmd);

	struct pipecmd_function *cmdf;

	cmd->tag = PIPECMD_FUNCTION;

	cmd->name = xstrdup (name);

	cmd->nice = 0;

	cmd->discard_err = 0;

	cmd->cwd_fd = -1;

	cmd->cwd = NULL;

	cmd->nenv = 0;

	cmd->env_max = 4;

	cmd->env = xnmalloc (cmd->env_max, sizeof *cmd->env);

	cmd->pre_exec_func = NULL;

	cmd->pre_exec_free_func = NULL;

	cmd->pre_exec_data = NULL;

	cmdf = &cmd->u.function;

	cmdf->func = func;

	cmdf->free_func = free_func;

	cmdf->data = data;

	return cmd;

}

pipecmd *pipecmd_new_sequencev (const char *name, va_list cmdv)

{

	pipecmd *cmd = XMALLOC (pipecmd);

	struct pipecmd_sequence *cmds;

	pipecmd *child;

	cmd->tag = PIPECMD_SEQUENCE;

	cmd->name = xstrdup (name);

	cmd->nice = 0;

	cmd->discard_err = 0;

	cmd->cwd_fd = -1;

	cmd->cwd = NULL;

	cmd->nenv = 0;

	cmd->env_max = 4;

	cmd->env = xnmalloc (cmd->env_max, sizeof *cmd->env);

	cmd->pre_exec_func = NULL;

	cmd->pre_exec_free_func = NULL;

	cmd->pre_exec_data = NULL;

	cmds = &cmd->u.sequence;

	cmds->ncommands = 0;

	cmds->commands_max = 4;

	cmds->commands = xnmalloc (cmds->commands_max, sizeof *cmds->commands);

	child = va_arg (cmdv, pipecmd *);

	while (child) {

		pipecmd_sequence_command (cmd, child);

		child = va_arg (cmdv, pipecmd *);

	}

	return cmd;

}

pipecmd *pipecmd_new_sequence (const char *name, ...)

{

	va_list cmdv;

	pipecmd *cmd;

	va_start (cmdv, name);

	cmd = pipecmd_new_sequencev (name, cmdv);

	va_end (cmdv);

	return cmd;

}

static void passthrough (void *data PIPELINE_ATTR_UNUSED)

{

	for (;;) {

		char buffer[4096];

		int r = safe_read (STDIN_FILENO, buffer, 4096);

		if (r <= 0)

			break;

		if (full_write (STDOUT_FILENO, buffer,

				(size_t) r) < (size_t) r)

			break;

	}

	return;

}

pipecmd *pipecmd_new_passthrough (void)

{

	return pipecmd_new_function ("cat", &passthrough, NULL, NULL);

}

pipecmd *pipecmd_dup (pipecmd *cmd)

{

	pipecmd *newcmd = XMALLOC (pipecmd);

	int i;

	newcmd->tag = cmd->tag;

	newcmd->name = xstrdup (cmd->name);

	newcmd->nice = cmd->nice;

	newcmd->discard_err = cmd->discard_err;

	newcmd->cwd_fd = cmd->cwd_fd;

	newcmd->cwd = cmd->cwd ? xstrdup (cmd->cwd) : NULL;

	newcmd->nenv = cmd->nenv;

	newcmd->env_max = cmd->env_max;

	assert (newcmd->nenv <= newcmd->env_max);

	newcmd->env = xmalloc (newcmd->env_max * sizeof *newcmd->env);

	newcmd->pre_exec_func = cmd->pre_exec_func;

	newcmd->pre_exec_free_func = cmd->pre_exec_free_func;

	newcmd->pre_exec_data = cmd->pre_exec_data;

	for (i = 0; i < cmd->nenv; ++i) {

		newcmd->env[i].name =

			cmd->env[i].name ? xstrdup (cmd->env[i].name) : NULL;

		newcmd->env[i].value =

			cmd->env[i].value ? xstrdup (cmd->env[i].value) : NULL;

	}

	switch (newcmd->tag) {

		case PIPECMD_PROCESS: {

			struct pipecmd_process *cmdp = &cmd->u.process;

			struct pipecmd_process *newcmdp = &newcmd->u.process;

			newcmdp->argc = cmdp->argc;

			newcmdp->argv_max = cmdp->argv_max;

			assert (newcmdp->argc < newcmdp->argv_max);

			newcmdp->argv = xmalloc

				(newcmdp->argv_max * sizeof *newcmdp->argv);

			for (i = 0; i < cmdp->argc; ++i)

				newcmdp->argv[i] = xstrdup (cmdp->argv[i]);

			newcmdp->argv[cmdp->argc] = NULL;

			break;

		}

		case PIPECMD_FUNCTION: {

			struct pipecmd_function *cmdf = &cmd->u.function;

			struct pipecmd_function *newcmdf = &newcmd->u.function;

			newcmdf->func = cmdf->func;

			newcmdf->free_func = cmdf->free_func;

			newcmdf->data = cmdf->data;

			break;

		}

		case PIPECMD_SEQUENCE: {

			struct pipecmd_sequence *cmds = &cmd->u.sequence;

			struct pipecmd_sequence *newcmds = &newcmd->u.sequence;

			newcmds->ncommands = cmds->ncommands;

			newcmds->commands_max = cmds->commands_max;

			assert (newcmds->ncommands <= newcmds->commands_max);

			newcmds->commands = xmalloc

				(newcmds->commands_max *

				 sizeof *newcmds->commands);

			for (i = 0; i < cmds->ncommands; ++i)

				newcmds->commands[i] =

					pipecmd_dup (cmds->commands[i]);

			break;

		}

	}

	return newcmd;

}

void pipecmd_arg (pipecmd *cmd, const char *arg)

{

	struct pipecmd_process *cmdp;

	assert (cmd->tag == PIPECMD_PROCESS);

	cmdp = &cmd->u.process;

	if (cmdp->argc + 1 >= cmdp->argv_max) {

		cmdp->argv_max *= 2;

		cmdp->argv = xrealloc (cmdp->argv,

				       cmdp->argv_max * sizeof *cmdp->argv);

	}

	cmdp->argv[cmdp->argc++] = xstrdup (arg);

	assert (cmdp->argc < cmdp->argv_max);

	cmdp->argv[cmdp->argc] = NULL;

}

void pipecmd_argf (pipecmd *cmd, const char *format, ...)

{

	va_list argv;

	char *arg;

	va_start (argv, format);

	arg = xvasprintf (format, argv);

	pipecmd_arg (cmd, arg);

	free (arg);

	va_end (argv);

}

void pipecmd_argv (pipecmd *cmd, va_list argv)

{

	const char *arg = va_arg (argv, const char *);

	assert (cmd->tag == PIPECMD_PROCESS);

	while (arg) {

		pipecmd_arg (cmd, arg);

		arg = va_arg (argv, const char *);

	}

}

void pipecmd_args (pipecmd *cmd, ...)

{

	va_list argv;

	assert (cmd->tag == PIPECMD_PROCESS);

	va_start (argv, cmd);

	pipecmd_argv (cmd, argv);

	va_end (argv);

}

void pipecmd_argstr (pipecmd *cmd, const char *argstr)

{

	char *arg;

	assert (cmd->tag == PIPECMD_PROCESS);

	while ((arg = argstr_get_word (&argstr))) {

		pipecmd_arg (cmd, arg);

		free (arg);

	}

}

int pipecmd_get_nargs (pipecmd *cmd)

{

	struct pipecmd_process *cmdp;

	assert (cmd->tag == PIPECMD_PROCESS);

	cmdp = &cmd->u.process;

	return cmdp->argc;

}

void pipecmd_nice (pipecmd *cmd, int value)

{

	cmd->nice = value;

}

void pipecmd_discard_err (pipecmd *cmd, int discard_err)

{

	cmd->discard_err = discard_err;

}

void pipecmd_chdir (pipecmd *cmd, const char *directory)

{

	free (cmd->cwd);

	cmd->cwd = xstrdup (directory);

}

void pipecmd_fchdir (pipecmd *cmd, int directory_fd)

{

	cmd->cwd_fd = directory_fd;

}

void pipecmd_setenv (pipecmd *cmd, const char *name, const char *value)

{

	if (cmd->nenv >= cmd->env_max) {

		cmd->env_max *= 2;

		cmd->env = xrealloc (cmd->env,

				     cmd->env_max * sizeof *cmd->env);

	}

	cmd->env[cmd->nenv].name = xstrdup (name);

	cmd->env[cmd->nenv].value = xstrdup (value);

	++cmd->nenv;

}

void pipecmd_unsetenv (pipecmd *cmd, const char *name)

{

	if (cmd->nenv >= cmd->env_max) {

		cmd->env_max *= 2;

		cmd->env = xrealloc (cmd->env,

				     cmd->env_max * sizeof *cmd->env);

	}

	cmd->env[cmd->nenv].name = xstrdup (name);

	cmd->env[cmd->nenv].value = NULL;

	++cmd->nenv;

}

void pipecmd_clearenv (pipecmd *cmd)

{

	if (cmd->nenv >= cmd->env_max) {

		cmd->env_max *= 2;

		cmd->env = xrealloc (cmd->env,

				     cmd->env_max * sizeof *cmd->env);

	}

	cmd->env[cmd->nenv].name = NULL;

	cmd->env[cmd->nenv].value = NULL;

	++cmd->nenv;

}

void pipecmd_pre_exec (pipecmd *cmd,

		       pipecmd_function_type *func,

		       pipecmd_function_free_type *free_func,

		       void *data)

{

	cmd->pre_exec_func = func;

	cmd->pre_exec_free_func = free_func;

	cmd->pre_exec_data = data;

}

void pipecmd_sequence_command (pipecmd *cmd, pipecmd *child)

{

	struct pipecmd_sequence *cmds;

	assert (cmd->tag == PIPECMD_SEQUENCE);

	cmds = &cmd->u.sequence;

	if (cmds->ncommands >= cmds->commands_max) {

		cmds->commands_max *= 2;

		cmds->commands = xrealloc

			(cmds->commands,

			 cmds->commands_max * sizeof *cmds->commands);

	}

	cmds->commands[cmds->ncommands++] = child;

}

void pipecmd_dump (pipecmd *cmd, FILE *stream)

{

	int i;

	if (cmd->cwd_fd >= 0)

		fprintf (stream, "(cd <fd %d> && ", cmd->cwd_fd);

	else if (cmd->cwd)

		fprintf (stream, "(cd %s && ", cmd->cwd);

	for (i = 0; i < cmd->nenv; ++i) {

		if (cmd->env[i].name)

			fprintf (stream, "%s=%s ",

				 cmd->env[i].name,

				 cmd->env[i].value ? cmd->env[i].value

						   : "<unset>");

		else

			fputs ("env -i ", stream);

	}

	switch (cmd->tag) {

		case PIPECMD_PROCESS: {

			struct pipecmd_process *cmdp = &cmd->u.process;

			fputs (cmd->name, stream);

			for (i = 1; i < cmdp->argc; ++i) {

				/* TODO: escape_shell()? */

				putc (' ', stream);

				fputs (cmdp->argv[i], stream);

			}

			break;

		}

		case PIPECMD_FUNCTION:

			fputs (cmd->name, stream);

			break;

		case PIPECMD_SEQUENCE: {

			struct pipecmd_sequence *cmds = &cmd->u.sequence;

			putc ('(', stream);

			for (i = 0; i < cmds->ncommands; ++i) {

				pipecmd_dump (cmds->commands[i], stream);

				if (i < cmds->ncommands - 1)

					fputs (" && ", stream);

			}

			putc (')', stream);

			break;

		}

	}

	if (cmd->cwd_fd >= 0 || cmd->cwd)

		putc (')', stream);

}

char *pipecmd_tostring (pipecmd *cmd)

{

	char *out = NULL;

	int i;

	if (cmd->cwd_fd >= 0) {

		char *cwd_fd_str = xasprintf ("%d", cmd->cwd_fd);

		out = appendstr (out, "(cd <fd ", cwd_fd_str, "> && ", NULL);

		free (cwd_fd_str);

	} else if (cmd->cwd)

		out = appendstr (out, "(cd ", cmd->cwd, " && ", NULL);

	for (i = 0; i < cmd->nenv; ++i) {

		if (cmd->env[i].name)

			out = appendstr (out, cmd->env[i].name, "=",

					 cmd->env[i].value ? cmd->env[i].value

							   : "<unset>",

					 " ", NULL);

		else

			out = appendstr (out, "env -i ", NULL);

	}

	switch (cmd->tag) {

		case PIPECMD_PROCESS: {

			struct pipecmd_process *cmdp = &cmd->u.process;

			out = appendstr (out, cmd->name, NULL);

			for (i = 1; i < cmdp->argc; ++i)

				/* TODO: escape_shell()? */

				out = appendstr (out, " ", cmdp->argv[i],

						 NULL);

			break;

		}

		case PIPECMD_FUNCTION:

			out = appendstr (out, cmd->name, NULL);

			break;

		case PIPECMD_SEQUENCE: {

			struct pipecmd_sequence *cmds = &cmd->u.sequence;

			out = appendstr (out, "(", NULL);

			for (i = 0; i < cmds->ncommands; ++i) {

				char *subout = pipecmd_tostring

					(cmds->commands[i]);

				out = appendstr (out, subout, NULL);

				free (subout);

				if (i < cmds->ncommands - 1)

					out = appendstr (out, " && ", NULL);

			}

			out = appendstr (out, ")", NULL);

			break;

		}

	}

	if (cmd->cwd_fd >= 0 || cmd->cwd)

		out = appendstr (out, ")", NULL);

	return out;

}

/* Children exit with this status if execvp fails. */

#define EXEC_FAILED_EXIT_STATUS 0xff

/* When called internally during pipeline execution, this is called in the

 * forked child process, with file descriptors already set up.

 */

void pipecmd_exec (pipecmd *cmd)

{

	int i;

	if (cmd->nice)

		if (nice (cmd->nice) < 0)

			/* Don't worry too much. */

			debug ("nice failed: %s\n", strerror (errno));

	if (cmd->discard_err) {

		int devnull = open ("/dev/null", O_WRONLY);

		if (devnull != -1) {

			dup2 (devnull, 2);

			close (devnull);

		}

	}

	if (cmd->cwd_fd >= 0) {

		if (fchdir (cmd->cwd_fd) < 0)

			error (EXEC_FAILED_EXIT_STATUS, errno,

			       "can't change directory to fd %d", cmd->cwd_fd);

	} else if (cmd->cwd) {

		if (chdir (cmd->cwd) < 0)

			error (EXEC_FAILED_EXIT_STATUS, errno,

			       "can't change directory to '%s'", cmd->cwd);

	}

	for (i = 0; i < cmd->nenv; ++i) {

		if (cmd->env[i].name) {

			if (cmd->env[i].value)

				setenv (cmd->env[i].name,

					cmd->env[i].value, 1);

			else

				unsetenv (cmd->env[i].name);

		} else

			clearenv ();

	}

	switch (cmd->tag) {

		case PIPECMD_PROCESS: {

			struct pipecmd_process *cmdp = &cmd->u.process;

			if (cmd->pre_exec_func)

				cmd->pre_exec_func (cmd->pre_exec_data);

			execvp (cmd->name, cmdp->argv);

			break;

		}

		/* TODO: ideally, could there be a facility

		 * to execute non-blocking functions without

		 * needing to fork?

		 */

		case PIPECMD_FUNCTION: {

			struct pipecmd_function *cmdf = &cmd->u.function;

			if (cmd->pre_exec_func)

				cmd->pre_exec_func (cmd->pre_exec_data);

			cmdf->func (cmdf->data);

			/* pacify valgrind et al */

			if (cmdf->free_func)

				cmdf->free_func (cmdf->data);

			if (cmd->pre_exec_free_func)

				cmd->pre_exec_free_func (cmd->pre_exec_data);

			exit (0);

		}

		case PIPECMD_SEQUENCE: {

			struct pipecmd_sequence *cmds = &cmd->u.sequence;

			struct sigaction sa;

			/* Flush all pending output so that subprocesses

			 * don't inherit it.

			 */

			fflush (NULL);

			/* pipeline_start will have blocked SIGCHLD. We like

			 * it that way. Lose the parent's signal handler,

			 * though.

			 */

			memset (&sa, 0, sizeof sa);

			sa.sa_handler = SIG_DFL;

			sigemptyset (&sa.sa_mask);

			sa.sa_flags = 0;

			if (sigaction (SIGCHLD, &sa, NULL) == -1)

				error (FATAL, errno,

				       "can't install SIGCHLD handler");

			for (i = 0; i < cmds->ncommands; ++i) {

				pipecmd *child = cmds->commands[i];

				pid_t pid = fork ();

				int status;

				if (pid < 0)

					error (FATAL, errno, "fork failed");

				if (pid == 0)

					pipecmd_exec (child);

				debug ("Started \"%s\", pid %d\n",

				       child->name, pid);

				while (waitpid (pid, &status, 0) < 0) {

					if (errno == EINTR)

						continue;

					error (FATAL, errno, "waitpid failed");

				}

				debug ("  \"%s\" (%d) -> %d\n",

				       child->name, pid, status);

				if (WIFSIGNALED (status)) {

					int sig = WTERMSIG (status);

#ifdef SIGPIPE

					if (sig == SIGPIPE)

						status = 0;

					else

#endif /* SIGPIPE */

					if (getenv ("PIPELINE_QUIET"))

						;

					else if (WCOREDUMP (status))

						error (0, 0,

						       "%s: %s (core dumped)",

						       child->name,

						       strsignal (sig));

					else