1#include <unistd.h>
  2#include <sys/types.h>
  3#include <sys/stat.h>
  4#include <fcntl.h>
  5#include <string.h>
  6#include <linux/string.h>
  7#include <errno.h>
  8#include <sys/wait.h>
  9#include "subcmd-util.h"
 10#include "run-command.h"
 11#include "exec-cmd.h"
 12
 13#define STRERR_BUFSIZE 128
 14
 15static inline void close_pair(int fd[2])
 16{
 17	close(fd[0]);
 18	close(fd[1]);
 19}
 20
 21static inline void dup_devnull(int to)
 22{
 23	int fd = open("/dev/null", O_RDWR);
 24	dup2(fd, to);
 25	close(fd);
 26}
 27
 28int start_command(struct child_process *cmd)
 29{
 30	int need_in, need_out, need_err;
 31	int fdin[2], fdout[2], fderr[2];
 32	char sbuf[STRERR_BUFSIZE];
 33
 34	/*
 35	 * In case of errors we must keep the promise to close FDs
 36	 * that have been passed in via ->in and ->out.
 37	 */
 38
 39	need_in = !cmd->no_stdin && cmd->in < 0;
 40	if (need_in) {
 41		if (pipe(fdin) < 0) {
 42			if (cmd->out > 0)
 43				close(cmd->out);
 44			return -ERR_RUN_COMMAND_PIPE;
 45		}
 46		cmd->in = fdin[1];
 47	}
 48
 49	need_out = !cmd->no_stdout
 50		&& !cmd->stdout_to_stderr
 51		&& cmd->out < 0;
 52	if (need_out) {
 53		if (pipe(fdout) < 0) {
 54			if (need_in)
 55				close_pair(fdin);
 56			else if (cmd->in)
 57				close(cmd->in);
 58			return -ERR_RUN_COMMAND_PIPE;
 59		}
 60		cmd->out = fdout[0];
 61	}
 62
 63	need_err = !cmd->no_stderr && cmd->err < 0;
 64	if (need_err) {
 65		if (pipe(fderr) < 0) {
 66			if (need_in)
 67				close_pair(fdin);
 68			else if (cmd->in)
 69				close(cmd->in);
 70			if (need_out)
 71				close_pair(fdout);
 72			else if (cmd->out)
 73				close(cmd->out);
 74			return -ERR_RUN_COMMAND_PIPE;
 75		}
 76		cmd->err = fderr[0];
 77	}
 78
 79	fflush(NULL);
 80	cmd->pid = fork();
 81	if (!cmd->pid) {
 82		if (cmd->no_stdin)
 83			dup_devnull(0);
 84		else if (need_in) {
 85			dup2(fdin[0], 0);
 86			close_pair(fdin);
 87		} else if (cmd->in) {
 88			dup2(cmd->in, 0);
 89			close(cmd->in);
 90		}
 91
 92		if (cmd->no_stderr)
 93			dup_devnull(2);
 94		else if (need_err) {
 95			dup2(fderr[1], 2);
 96			close_pair(fderr);
 97		}
 98
 99		if (cmd->no_stdout)
100			dup_devnull(1);
101		else if (cmd->stdout_to_stderr)
102			dup2(2, 1);
103		else if (need_out) {
104			dup2(fdout[1], 1);
105			close_pair(fdout);
106		} else if (cmd->out > 1) {
107			dup2(cmd->out, 1);
108			close(cmd->out);
109		}
110
111		if (cmd->dir && chdir(cmd->dir))
112			die("exec %s: cd to %s failed (%s)", cmd->argv[0],
113			    cmd->dir, str_error_r(errno, sbuf, sizeof(sbuf)));
114		if (cmd->env) {
115			for (; *cmd->env; cmd->env++) {
116				if (strchr(*cmd->env, '='))
117					putenv((char*)*cmd->env);
118				else
119					unsetenv(*cmd->env);
120			}
121		}
122		if (cmd->preexec_cb)
123			cmd->preexec_cb();
124		if (cmd->exec_cmd) {
125			execv_cmd(cmd->argv);
126		} else {
127			execvp(cmd->argv[0], (char *const*) cmd->argv);
128		}
129		exit(127);
130	}
131
132	if (cmd->pid < 0) {
133		int err = errno;
134		if (need_in)
135			close_pair(fdin);
136		else if (cmd->in)
137			close(cmd->in);
138		if (need_out)
139			close_pair(fdout);
140		else if (cmd->out)
141			close(cmd->out);
142		if (need_err)
143			close_pair(fderr);
144		return err == ENOENT ?
145			-ERR_RUN_COMMAND_EXEC :
146			-ERR_RUN_COMMAND_FORK;
147	}
148
149	if (need_in)
150		close(fdin[0]);
151	else if (cmd->in)
152		close(cmd->in);
153
154	if (need_out)
155		close(fdout[1]);
156	else if (cmd->out)
157		close(cmd->out);
158
159	if (need_err)
160		close(fderr[1]);
161
162	return 0;
163}
164
165static int wait_or_whine(pid_t pid)
166{
167	char sbuf[STRERR_BUFSIZE];
168
169	for (;;) {
170		int status, code;
171		pid_t waiting = waitpid(pid, &status, 0);
172
173		if (waiting < 0) {
174			if (errno == EINTR)
175				continue;
176			fprintf(stderr, " Error: waitpid failed (%s)",
177				str_error_r(errno, sbuf, sizeof(sbuf)));
178			return -ERR_RUN_COMMAND_WAITPID;
179		}
180		if (waiting != pid)
181			return -ERR_RUN_COMMAND_WAITPID_WRONG_PID;
182		if (WIFSIGNALED(status))
183			return -ERR_RUN_COMMAND_WAITPID_SIGNAL;
184
185		if (!WIFEXITED(status))
186			return -ERR_RUN_COMMAND_WAITPID_NOEXIT;
187		code = WEXITSTATUS(status);
188		switch (code) {
189		case 127:
190			return -ERR_RUN_COMMAND_EXEC;
191		case 0:
192			return 0;
193		default:
194			return -code;
195		}
196	}
197}
198
199int finish_command(struct child_process *cmd)
200{
201	return wait_or_whine(cmd->pid);
202}
203
204int run_command(struct child_process *cmd)
205{
206	int code = start_command(cmd);
207	if (code)
208		return code;
209	return finish_command(cmd);
210}
211
212static void prepare_run_command_v_opt(struct child_process *cmd,
213				      const char **argv,
214				      int opt)
215{
216	memset(cmd, 0, sizeof(*cmd));
217	cmd->argv = argv;
218	cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
219	cmd->exec_cmd = opt & RUN_EXEC_CMD ? 1 : 0;
220	cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
221}
222
223int run_command_v_opt(const char **argv, int opt)
224{
225	struct child_process cmd;
226	prepare_run_command_v_opt(&cmd, argv, opt);
227	return run_command(&cmd);
228}