[thirdparty/git.git] / run-command.c

#include "cache.h"
#include "run-command.h"
#include "exec_cmd.h"
#include "sigchain.h"
#include "argv-array.h"

struct child_to_clean {
	pid_t pid;
	struct child_to_clean *next;
};
static struct child_to_clean *children_to_clean;
static int installed_child_cleanup_handler;

static void cleanup_children(int sig)
{
	while (children_to_clean) {
		struct child_to_clean *p = children_to_clean;
		children_to_clean = p->next;
		kill(p->pid, sig);
		free(p);
	}
}

static void cleanup_children_on_signal(int sig)
{
	cleanup_children(sig);
	sigchain_pop(sig);
	raise(sig);
}

static void cleanup_children_on_exit(void)
{
	cleanup_children(SIGTERM);
}

static void mark_child_for_cleanup(pid_t pid)
{
	struct child_to_clean *p = xmalloc(sizeof(*p));
	p->pid = pid;
	p->next = children_to_clean;
	children_to_clean = p;

	if (!installed_child_cleanup_handler) {
		atexit(cleanup_children_on_exit);
		sigchain_push_common(cleanup_children_on_signal);
		installed_child_cleanup_handler = 1;
	}
}

static void clear_child_for_cleanup(pid_t pid)
{
	struct child_to_clean **last, *p;

	last = &children_to_clean;
	for (p = children_to_clean; p; p = p->next) {
		if (p->pid == pid) {
			*last = p->next;
			free(p);
			return;
		}
	}
}

static inline void close_pair(int fd[2])
{
	close(fd[0]);
	close(fd[1]);
}

#ifndef WIN32
static inline void dup_devnull(int to)
{
	int fd = open("/dev/null", O_RDWR);
	dup2(fd, to);
	close(fd);
}
#endif

static const char **prepare_shell_cmd(const char **argv)
{
	int argc, nargc = 0;
	const char **nargv;

	for (argc = 0; argv[argc]; argc++)
		; /* just counting */
	/* +1 for NULL, +3 for "sh -c" plus extra $0 */
	nargv = xmalloc(sizeof(*nargv) * (argc + 1 + 3));

	if (argc < 1)
		die("BUG: shell command is empty");

	if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
		nargv[nargc++] = "sh";
		nargv[nargc++] = "-c";

		if (argc < 2)
			nargv[nargc++] = argv[0];
		else {
			struct strbuf arg0 = STRBUF_INIT;
			strbuf_addf(&arg0, "%s \"$@\"", argv[0]);
			nargv[nargc++] = strbuf_detach(&arg0, NULL);
		}
	}

	for (argc = 0; argv[argc]; argc++)
		nargv[nargc++] = argv[argc];
	nargv[nargc] = NULL;

	return nargv;
}

#ifndef WIN32
static int execv_shell_cmd(const char **argv)
{
	const char **nargv = prepare_shell_cmd(argv);
	trace_argv_printf(nargv, "trace: exec:");
	execvp(nargv[0], (char **)nargv);
	free(nargv);
	return -1;
}
#endif

#ifndef WIN32
static int child_err = 2;
static int child_notifier = -1;

static void notify_parent(void)
{
	/*
	 * execvp failed.  If possible, we'd like to let start_command
	 * know, so failures like ENOENT can be handled right away; but
	 * otherwise, finish_command will still report the error.
	 */
	xwrite(child_notifier, "", 1);
}

static NORETURN void die_child(const char *err, va_list params)
{
	vwritef(child_err, "fatal: ", err, params);
	exit(128);
}

static void error_child(const char *err, va_list params)
{
	vwritef(child_err, "error: ", err, params);
}
#endif

static inline void set_cloexec(int fd)
{
	int flags = fcntl(fd, F_GETFD);
	if (flags >= 0)
		fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
}

static int wait_or_whine(pid_t pid, const char *argv0, int silent_exec_failure)
{
	int status, code = -1;
	pid_t waiting;
	int failed_errno = 0;

	while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
		;	/* nothing */

	if (waiting < 0) {
		failed_errno = errno;
		error("waitpid for %s failed: %s", argv0, strerror(errno));
	} else if (waiting != pid) {
		error("waitpid is confused (%s)", argv0);
	} else if (WIFSIGNALED(status)) {
		code = WTERMSIG(status);
		error("%s died of signal %d", argv0, code);
		/*
		 * This return value is chosen so that code & 0xff
		 * mimics the exit code that a POSIX shell would report for
		 * a program that died from this signal.
		 */
		code -= 128;
	} else if (WIFEXITED(status)) {
		code = WEXITSTATUS(status);
		/*
		 * Convert special exit code when execvp failed.
		 */
		if (code == 127) {
			code = -1;
			failed_errno = ENOENT;
		}
	} else {
		error("waitpid is confused (%s)", argv0);
	}

	clear_child_for_cleanup(pid);

	errno = failed_errno;
	return code;
}

int start_command(struct child_process *cmd)
{
	int need_in, need_out, need_err;
	int fdin[2], fdout[2], fderr[2];
	int failed_errno = failed_errno;

	/*
	 * In case of errors we must keep the promise to close FDs
	 * that have been passed in via ->in and ->out.
	 */

	need_in = !cmd->no_stdin && cmd->in < 0;
	if (need_in) {
		if (pipe(fdin) < 0) {
			failed_errno = errno;
			if (cmd->out > 0)
				close(cmd->out);
			goto fail_pipe;
		}
		cmd->in = fdin[1];
	}

	need_out = !cmd->no_stdout
		&& !cmd->stdout_to_stderr
		&& cmd->out < 0;
	if (need_out) {
		if (pipe(fdout) < 0) {
			failed_errno = errno;
			if (need_in)
				close_pair(fdin);
			else if (cmd->in)
				close(cmd->in);
			goto fail_pipe;
		}
		cmd->out = fdout[0];
	}

	need_err = !cmd->no_stderr && cmd->err < 0;
	if (need_err) {
		if (pipe(fderr) < 0) {
			failed_errno = errno;
			if (need_in)
				close_pair(fdin);
			else if (cmd->in)
				close(cmd->in);
			if (need_out)
				close_pair(fdout);
			else if (cmd->out)
				close(cmd->out);
fail_pipe:
			error("cannot create pipe for %s: %s",
				cmd->argv[0], strerror(failed_errno));
			errno = failed_errno;
			return -1;
		}
		cmd->err = fderr[0];
	}

	trace_argv_printf(cmd->argv, "trace: run_command:");
	fflush(NULL);

#ifndef WIN32
{
	int notify_pipe[2];
	if (pipe(notify_pipe))
		notify_pipe[0] = notify_pipe[1] = -1;

	cmd->pid = fork();
	if (!cmd->pid) {
		/*
		 * Redirect the channel to write syscall error messages to
		 * before redirecting the process's stderr so that all die()
		 * in subsequent call paths use the parent's stderr.
		 */
		if (cmd->no_stderr || need_err) {
			child_err = dup(2);
			set_cloexec(child_err);
		}
		set_die_routine(die_child);
		set_error_routine(error_child);

		close(notify_pipe[0]);
		set_cloexec(notify_pipe[1]);
		child_notifier = notify_pipe[1];
		atexit(notify_parent);

		if (cmd->no_stdin)
			dup_devnull(0);
		else if (need_in) {
			dup2(fdin[0], 0);
			close_pair(fdin);
		} else if (cmd->in) {
			dup2(cmd->in, 0);
			close(cmd->in);
		}

		if (cmd->no_stderr)
			dup_devnull(2);
		else if (need_err) {
			dup2(fderr[1], 2);
			close_pair(fderr);
		} else if (cmd->err > 1) {
			dup2(cmd->err, 2);
			close(cmd->err);
		}

		if (cmd->no_stdout)
			dup_devnull(1);
		else if (cmd->stdout_to_stderr)
			dup2(2, 1);
		else if (need_out) {
			dup2(fdout[1], 1);
			close_pair(fdout);
		} else if (cmd->out > 1) {
			dup2(cmd->out, 1);
			close(cmd->out);
		}

		if (cmd->dir && chdir(cmd->dir))
			die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
			    cmd->dir);
		if (cmd->env) {
			for (; *cmd->env; cmd->env++) {
				if (strchr(*cmd->env, '='))
					putenv((char *)*cmd->env);
				else
					unsetenv(*cmd->env);
			}
		}
		if (cmd->preexec_cb) {
			/*
			 * We cannot predict what the pre-exec callback does.
			 * Forgo parent notification.
			 */
			close(child_notifier);
			child_notifier = -1;

			cmd->preexec_cb();
		}
		if (cmd->git_cmd) {
			execv_git_cmd(cmd->argv);
		} else if (cmd->use_shell) {
			execv_shell_cmd(cmd->argv);
		} else {
			execvp(cmd->argv[0], (char *const*) cmd->argv);
		}
		if (errno == ENOENT) {
			if (!cmd->silent_exec_failure)
				error("cannot run %s: %s", cmd->argv[0],
					strerror(ENOENT));
			exit(127);
		} else {
			die_errno("cannot exec '%s'", cmd->argv[0]);
		}
	}
	if (cmd->pid < 0)
		error("cannot fork() for %s: %s", cmd->argv[0],
			strerror(failed_errno = errno));
	else if (cmd->clean_on_exit)
		mark_child_for_cleanup(cmd->pid);

	/*
	 * Wait for child's execvp. If the execvp succeeds (or if fork()
	 * failed), EOF is seen immediately by the parent. Otherwise, the
	 * child process sends a single byte.
	 * Note that use of this infrastructure is completely advisory,
	 * therefore, we keep error checks minimal.
	 */
	close(notify_pipe[1]);
	if (read(notify_pipe[0], &notify_pipe[1], 1) == 1) {
		/*
		 * At this point we know that fork() succeeded, but execvp()
		 * failed. Errors have been reported to our stderr.
		 */
		wait_or_whine(cmd->pid, cmd->argv[0],
			      cmd->silent_exec_failure);
		failed_errno = errno;
		cmd->pid = -1;
	}
	close(notify_pipe[0]);

}
#else
{
	int fhin = 0, fhout = 1, fherr = 2;
	const char **sargv = cmd->argv;
	char **env = environ;

	if (cmd->no_stdin)
		fhin = open("/dev/null", O_RDWR);
	else if (need_in)
		fhin = dup(fdin[0]);
	else if (cmd->in)
		fhin = dup(cmd->in);

	if (cmd->no_stderr)
		fherr = open("/dev/null", O_RDWR);
	else if (need_err)
		fherr = dup(fderr[1]);
	else if (cmd->err > 2)
		fherr = dup(cmd->err);

	if (cmd->no_stdout)
		fhout = open("/dev/null", O_RDWR);
	else if (cmd->stdout_to_stderr)
		fhout = dup(fherr);
	else if (need_out)
		fhout = dup(fdout[1]);
	else if (cmd->out > 1)
		fhout = dup(cmd->out);

	if (cmd->env)
		env = make_augmented_environ(cmd->env);

	if (cmd->git_cmd) {
		cmd->argv = prepare_git_cmd(cmd->argv);
	} else if (cmd->use_shell) {
		cmd->argv = prepare_shell_cmd(cmd->argv);
	}

	cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, env, cmd->dir,
				  fhin, fhout, fherr);
	failed_errno = errno;
	if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
		error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));
	if (cmd->clean_on_exit && cmd->pid >= 0)
		mark_child_for_cleanup(cmd->pid);

	if (cmd->env)
		free_environ(env);
	if (cmd->git_cmd)
		free(cmd->argv);

	cmd->argv = sargv;
	if (fhin != 0)
		close(fhin);
	if (fhout != 1)
		close(fhout);
	if (fherr != 2)
		close(fherr);
}
#endif

	if (cmd->pid < 0) {
		if (need_in)
			close_pair(fdin);
		else if (cmd->in)
			close(cmd->in);
		if (need_out)
			close_pair(fdout);
		else if (cmd->out)
			close(cmd->out);
		if (need_err)
			close_pair(fderr);
		else if (cmd->err)
			close(cmd->err);
		errno = failed_errno;
		return -1;
	}

	if (need_in)
		close(fdin[0]);
	else if (cmd->in)
		close(cmd->in);

	if (need_out)
		close(fdout[1]);
	else if (cmd->out)
		close(cmd->out);

	if (need_err)
		close(fderr[1]);
	else if (cmd->err)
		close(cmd->err);

	return 0;
}

int finish_command(struct child_process *cmd)
{
	return wait_or_whine(cmd->pid, cmd->argv[0], cmd->silent_exec_failure);
}

int run_command(struct child_process *cmd)
{
	int code = start_command(cmd);
	if (code)
		return code;
	return finish_command(cmd);
}

static void prepare_run_command_v_opt(struct child_process *cmd,
				      const char **argv,
				      int opt)
{
	memset(cmd, 0, sizeof(*cmd));
	cmd->argv = argv;
	cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
	cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
	cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
	cmd->silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
	cmd->use_shell = opt & RUN_USING_SHELL ? 1 : 0;
}

int run_command_v_opt(const char **argv, int opt)
{
	struct child_process cmd;
	prepare_run_command_v_opt(&cmd, argv, opt);
	return run_command(&cmd);
}

int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
{
	struct child_process cmd;
	prepare_run_command_v_opt(&cmd, argv, opt);
	cmd.dir = dir;
	cmd.env = env;
	return run_command(&cmd);
}

#ifndef NO_PTHREADS
static pthread_t main_thread;
static int main_thread_set;
static pthread_key_t async_key;

static void *run_thread(void *data)
{
	struct async *async = data;
	intptr_t ret;

	pthread_setspecific(async_key, async);
	ret = async->proc(async->proc_in, async->proc_out, async->data);
	return (void *)ret;
}

static NORETURN void die_async(const char *err, va_list params)
{
	vreportf("fatal: ", err, params);

	if (!pthread_equal(main_thread, pthread_self())) {
		struct async *async = pthread_getspecific(async_key);
		if (async->proc_in >= 0)
			close(async->proc_in);
		if (async->proc_out >= 0)
			close(async->proc_out);
		pthread_exit((void *)128);
	}

	exit(128);
}
#endif

int start_async(struct async *async)
{
	int need_in, need_out;
	int fdin[2], fdout[2];
	int proc_in, proc_out;

	need_in = async->in < 0;
	if (need_in) {
		if (pipe(fdin) < 0) {
			if (async->out > 0)
				close(async->out);
			return error("cannot create pipe: %s", strerror(errno));
		}
		async->in = fdin[1];
	}

	need_out = async->out < 0;
	if (need_out) {
		if (pipe(fdout) < 0) {
			if (need_in)
				close_pair(fdin);
			else if (async->in)
				close(async->in);
			return error("cannot create pipe: %s", strerror(errno));
		}
		async->out = fdout[0];
	}

	if (need_in)
		proc_in = fdin[0];
	else if (async->in)
		proc_in = async->in;
	else
		proc_in = -1;

	if (need_out)
		proc_out = fdout[1];
	else if (async->out)
		proc_out = async->out;
	else
		proc_out = -1;

#ifdef NO_PTHREADS
	/* Flush stdio before fork() to avoid cloning buffers */
	fflush(NULL);

	async->pid = fork();
	if (async->pid < 0) {
		error("fork (async) failed: %s", strerror(errno));
		goto error;
	}
	if (!async->pid) {
		if (need_in)
			close(fdin[1]);
		if (need_out)
			close(fdout[0]);
		exit(!!async->proc(proc_in, proc_out, async->data));
	}

	mark_child_for_cleanup(async->pid);

	if (need_in)
		close(fdin[0]);
	else if (async->in)
		close(async->in);

	if (need_out)
		close(fdout[1]);
	else if (async->out)
		close(async->out);
#else
	if (!main_thread_set) {
		/*
		 * We assume that the first time that start_async is called
		 * it is from the main thread.
		 */
		main_thread_set = 1;
		main_thread = pthread_self();
		pthread_key_create(&async_key, NULL);
		set_die_routine(die_async);
	}

	if (proc_in >= 0)
		set_cloexec(proc_in);
	if (proc_out >= 0)
		set_cloexec(proc_out);
	async->proc_in = proc_in;
	async->proc_out = proc_out;
	{
		int err = pthread_create(&async->tid, NULL, run_thread, async);
		if (err) {
			error("cannot create thread: %s", strerror(err));
			goto error;
		}
	}
#endif
	return 0;

error:
	if (need_in)
		close_pair(fdin);
	else if (async->in)
		close(async->in);

	if (need_out)
		close_pair(fdout);
	else if (async->out)
		close(async->out);
	return -1;
}

int finish_async(struct async *async)
{
#ifdef NO_PTHREADS
	return wait_or_whine(async->pid, "child process", 0);
#else
	void *ret = (void *)(intptr_t)(-1);

	if (pthread_join(async->tid, &ret))
		error("pthread_join failed");
	return (int)(intptr_t)ret;
#endif
}

int run_hook(const char *index_file, const char *name, ...)
{
	struct child_process hook;
	struct argv_array argv = ARGV_ARRAY_INIT;
	const char *p, *env[2];
	char index[PATH_MAX];
	va_list args;
	int ret;

	if (access(git_path("hooks/%s", name), X_OK) < 0)
		return 0;

	va_start(args, name);
	argv_array_push(&argv, git_path("hooks/%s", name));
	while ((p = va_arg(args, const char *)))
		argv_array_push(&argv, p);
	va_end(args);

	memset(&hook, 0, sizeof(hook));
	hook.argv = argv.argv;
	hook.no_stdin = 1;
	hook.stdout_to_stderr = 1;
	if (index_file) {
		snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
		env[0] = index;
		env[1] = NULL;
		hook.env = env;
	}

	ret = run_command(&hook);
	argv_array_clear(&argv);
	return ret;
}
Commit	Line	Data
b1bf95bb JW	1	#include "cache.h"
b1bf95bb JW	2	#include "run-command.h"
77cb17e9	3	#include "exec_cmd.h"
afe19ff7	4	#include "sigchain.h"
5d40a179	5	#include "argv-array.h"
b1bf95bb	6
afe19ff7 JK	7	struct child_to_clean {
	8	pid_t pid;
	9	struct child_to_clean *next;
	10	};
	11	static struct child_to_clean *children_to_clean;
	12	static int installed_child_cleanup_handler;
	13
	14	static void cleanup_children(int sig)
	15	{
	16	while (children_to_clean) {
	17	struct child_to_clean *p = children_to_clean;
	18	children_to_clean = p->next;
	19	kill(p->pid, sig);
	20	free(p);
	21	}
	22	}
	23
	24	static void cleanup_children_on_signal(int sig)
	25	{
	26	cleanup_children(sig);
	27	sigchain_pop(sig);
	28	raise(sig);
	29	}
	30
	31	static void cleanup_children_on_exit(void)
	32	{
	33	cleanup_children(SIGTERM);
	34	}
	35
	36	static void mark_child_for_cleanup(pid_t pid)
	37	{
	38	struct child_to_clean p = xmalloc(sizeof(p));
	39	p->pid = pid;
	40	p->next = children_to_clean;
	41	children_to_clean = p;
	42
	43	if (!installed_child_cleanup_handler) {
	44	atexit(cleanup_children_on_exit);
	45	sigchain_push_common(cleanup_children_on_signal);
	46	installed_child_cleanup_handler = 1;
	47	}
	48	}
	49
	50	static void clear_child_for_cleanup(pid_t pid)
	51	{
	52	struct child_to_clean *last, p;
	53
	54	last = &children_to_clean;
	55	for (p = children_to_clean; p; p = p->next) {
	56	if (p->pid == pid) {
	57	*last = p->next;
	58	free(p);
	59	return;
	60	}
	61	}
	62	}
	63
9dc09c76 SP	64	static inline void close_pair(int fd[2])
	65	{
	66	close(fd[0]);
	67	close(fd[1]);
	68	}
	69
75301f90	70	#ifndef WIN32
e4507ae8 SP	71	static inline void dup_devnull(int to)
	72	{
	73	int fd = open("/dev/null", O_RDWR);
	74	dup2(fd, to);
	75	close(fd);
	76	}
75301f90	77	#endif
e4507ae8	78
8dba1e63 JK	79	static const char prepare_shell_cmd(const char argv)
	80	{
	81	int argc, nargc = 0;
	82	const char **nargv;
	83
	84	for (argc = 0; argv[argc]; argc++)
	85	; /* just counting */
	86	/* +1 for NULL, +3 for "sh -c" plus extra $0 */
	87	nargv = xmalloc(sizeof(nargv) (argc + 1 + 3));
	88
	89	if (argc < 1)
	90	die("BUG: shell command is empty");
	91
f445644f JK	92	if (strcspn(argv[0], "\|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
	93	nargv[nargc++] = "sh";
	94	nargv[nargc++] = "-c";
8dba1e63	95
f445644f JK	96	if (argc < 2)
	97	nargv[nargc++] = argv[0];
	98	else {
	99	struct strbuf arg0 = STRBUF_INIT;
	100	strbuf_addf(&arg0, "%s \"$@\"", argv[0]);
	101	nargv[nargc++] = strbuf_detach(&arg0, NULL);
	102	}
8dba1e63 JK	103	}
	104
	105	for (argc = 0; argv[argc]; argc++)
	106	nargv[nargc++] = argv[argc];
	107	nargv[nargc] = NULL;
	108
	109	return nargv;
	110	}
	111
	112	#ifndef WIN32
	113	static int execv_shell_cmd(const char **argv)
	114	{
	115	const char **nargv = prepare_shell_cmd(argv);
	116	trace_argv_printf(nargv, "trace: exec:");
	117	execvp(nargv[0], (char **)nargv);
	118	free(nargv);
	119	return -1;
	120	}
	121	#endif
	122
a5487ddf JS	123	#ifndef WIN32
a5487ddf JS	124	static int child_err = 2;
2b541bf8 JS	125	static int child_notifier = -1;
	126
	127	static void notify_parent(void)
	128	{
a111eb78 JN	129	/*
	130	* execvp failed. If possible, we'd like to let start_command
	131	* know, so failures like ENOENT can be handled right away; but
	132	* otherwise, finish_command will still report the error.
	133	*/
	134	xwrite(child_notifier, "", 1);
2b541bf8	135	}
a5487ddf JS	136
	137	static NORETURN void die_child(const char *err, va_list params)
	138	{
3bc4181f	139	vwritef(child_err, "fatal: ", err, params);
a5487ddf JS	140	exit(128);
a5487ddf JS	141	}
3bc4181f CB	142
	143	static void error_child(const char *err, va_list params)
	144	{
	145	vwritef(child_err, "error: ", err, params);
	146	}
200a76b7	147	#endif
a5487ddf JS	148
	149	static inline void set_cloexec(int fd)
	150	{
	151	int flags = fcntl(fd, F_GETFD);
	152	if (flags >= 0)
	153	fcntl(fd, F_SETFD, flags \| FD_CLOEXEC);
	154	}
a5487ddf	155
ab0b41da JS	156	static int wait_or_whine(pid_t pid, const char *argv0, int silent_exec_failure)
	157	{
	158	int status, code = -1;
	159	pid_t waiting;
	160	int failed_errno = 0;
	161
	162	while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
	163	; /* nothing */
	164
	165	if (waiting < 0) {
	166	failed_errno = errno;
	167	error("waitpid for %s failed: %s", argv0, strerror(errno));
	168	} else if (waiting != pid) {
	169	error("waitpid is confused (%s)", argv0);
	170	} else if (WIFSIGNALED(status)) {
	171	code = WTERMSIG(status);
	172	error("%s died of signal %d", argv0, code);
	173	/*
	174	* This return value is chosen so that code & 0xff
	175	* mimics the exit code that a POSIX shell would report for
	176	* a program that died from this signal.
	177	*/
	178	code -= 128;
	179	} else if (WIFEXITED(status)) {
	180	code = WEXITSTATUS(status);
	181	/*
	182	* Convert special exit code when execvp failed.
	183	*/
	184	if (code == 127) {
	185	code = -1;
	186	failed_errno = ENOENT;
ab0b41da JS	187	}
	188	} else {
	189	error("waitpid is confused (%s)", argv0);
	190	}
afe19ff7 JK	191
	192	clear_child_for_cleanup(pid);
	193
ab0b41da JS	194	errno = failed_errno;
	195	return code;
	196	}
	197
ebcb5d16	198	int start_command(struct child_process *cmd)
b1bf95bb	199	{
f3b33f1d JS	200	int need_in, need_out, need_err;
f3b33f1d JS	201	int fdin[2], fdout[2], fderr[2];
5a7a3671	202	int failed_errno = failed_errno;
4919bf03	203
c20181e3 JS	204	/*
	205	* In case of errors we must keep the promise to close FDs
	206	* that have been passed in via ->in and ->out.
	207	*/
	208
e4507ae8	209	need_in = !cmd->no_stdin && cmd->in < 0;
4919bf03	210	if (need_in) {
c20181e3	211	if (pipe(fdin) < 0) {
0ac77ec3	212	failed_errno = errno;
c20181e3 JS	213	if (cmd->out > 0)
c20181e3 JS	214	close(cmd->out);
0ac77ec3	215	goto fail_pipe;
c20181e3	216	}
4919bf03	217	cmd->in = fdin[1];
4919bf03 SP	218	}
4919bf03 SP	219
e4507ae8 SP	220	need_out = !cmd->no_stdout
	221	&& !cmd->stdout_to_stderr
	222	&& cmd->out < 0;
f4bba25b SP	223	if (need_out) {
f4bba25b SP	224	if (pipe(fdout) < 0) {
0ac77ec3	225	failed_errno = errno;
f4bba25b SP	226	if (need_in)
f4bba25b SP	227	close_pair(fdin);
c20181e3 JS	228	else if (cmd->in)
c20181e3 JS	229	close(cmd->in);
0ac77ec3	230	goto fail_pipe;
f4bba25b SP	231	}
f4bba25b SP	232	cmd->out = fdout[0];
f4bba25b SP	233	}
f4bba25b SP	234
b73a4397	235	need_err = !cmd->no_stderr && cmd->err < 0;
f3b33f1d JS	236	if (need_err) {
f3b33f1d JS	237	if (pipe(fderr) < 0) {
0ac77ec3	238	failed_errno = errno;
f3b33f1d JS	239	if (need_in)
f3b33f1d JS	240	close_pair(fdin);
c20181e3 JS	241	else if (cmd->in)
c20181e3 JS	242	close(cmd->in);
f3b33f1d JS	243	if (need_out)
f3b33f1d JS	244	close_pair(fdout);
c20181e3 JS	245	else if (cmd->out)
c20181e3 JS	246	close(cmd->out);
0ac77ec3 JS	247	fail_pipe:
	248	error("cannot create pipe for %s: %s",
	249	cmd->argv[0], strerror(failed_errno));
	250	errno = failed_errno;
	251	return -1;
f3b33f1d JS	252	}
	253	cmd->err = fderr[0];
	254	}
	255
8852f5d7	256	trace_argv_printf(cmd->argv, "trace: run_command:");
13af8cbd	257	fflush(NULL);
8852f5d7	258
71064e3f	259	#ifndef WIN32
2b541bf8 JS	260	{
	261	int notify_pipe[2];
	262	if (pipe(notify_pipe))
	263	notify_pipe[0] = notify_pipe[1] = -1;
	264
ebcb5d16	265	cmd->pid = fork();
ebcb5d16	266	if (!cmd->pid) {
a5487ddf JS	267	/*
	268	* Redirect the channel to write syscall error messages to
	269	* before redirecting the process's stderr so that all die()
	270	* in subsequent call paths use the parent's stderr.
	271	*/
	272	if (cmd->no_stderr \|\| need_err) {
	273	child_err = dup(2);
	274	set_cloexec(child_err);
	275	}
	276	set_die_routine(die_child);
3bc4181f	277	set_error_routine(error_child);
a5487ddf	278
2b541bf8 JS	279	close(notify_pipe[0]);
	280	set_cloexec(notify_pipe[1]);
	281	child_notifier = notify_pipe[1];
	282	atexit(notify_parent);
	283
e4507ae8 SP	284	if (cmd->no_stdin)
	285	dup_devnull(0);
	286	else if (need_in) {
4919bf03	287	dup2(fdin[0], 0);
9dc09c76	288	close_pair(fdin);
4919bf03 SP	289	} else if (cmd->in) {
	290	dup2(cmd->in, 0);
	291	close(cmd->in);
95d3c4f5	292	}
4919bf03	293
ce2cf27a CC	294	if (cmd->no_stderr)
	295	dup_devnull(2);
	296	else if (need_err) {
	297	dup2(fderr[1], 2);
	298	close_pair(fderr);
4f41b611 SP	299	} else if (cmd->err > 1) {
	300	dup2(cmd->err, 2);
	301	close(cmd->err);
ce2cf27a CC	302	}
ce2cf27a CC	303
e4507ae8 SP	304	if (cmd->no_stdout)
	305	dup_devnull(1);
	306	else if (cmd->stdout_to_stderr)
cd83c74c	307	dup2(2, 1);
f4bba25b SP	308	else if (need_out) {
	309	dup2(fdout[1], 1);
	310	close_pair(fdout);
	311	} else if (cmd->out > 1) {
	312	dup2(cmd->out, 1);
	313	close(cmd->out);
	314	}
	315
1568fea0	316	if (cmd->dir && chdir(cmd->dir))
d824cbba TR	317	die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
d824cbba TR	318	cmd->dir);
ee493148	319	if (cmd->env) {
3427b375 AR	320	for (; *cmd->env; cmd->env++) {
3427b375 AR	321	if (strchr(*cmd->env, '='))
4b25d091	322	putenv((char )cmd->env);
3427b375 AR	323	else
	324	unsetenv(*cmd->env);
	325	}
ee493148	326	}
2b541bf8 JS	327	if (cmd->preexec_cb) {
	328	/*
	329	* We cannot predict what the pre-exec callback does.
	330	* Forgo parent notification.
	331	*/
	332	close(child_notifier);
	333	child_notifier = -1;
	334
ccf08bc3	335	cmd->preexec_cb();
2b541bf8	336	}
f1000898 SP	337	if (cmd->git_cmd) {
f1000898 SP	338	execv_git_cmd(cmd->argv);
8dba1e63 JK	339	} else if (cmd->use_shell) {
8dba1e63 JK	340	execv_shell_cmd(cmd->argv);
77cb17e9	341	} else {
f1000898	342	execvp(cmd->argv[0], (char const) cmd->argv);
128aed68	343	}
fc1b56f0 CB	344	if (errno == ENOENT) {
	345	if (!cmd->silent_exec_failure)
	346	error("cannot run %s: %s", cmd->argv[0],
	347	strerror(ENOENT));
a5487ddf	348	exit(127);
fc1b56f0	349	} else {
a5487ddf	350	die_errno("cannot exec '%s'", cmd->argv[0]);
fc1b56f0	351	}
b1bf95bb	352	}
0ac77ec3 JS	353	if (cmd->pid < 0)
	354	error("cannot fork() for %s: %s", cmd->argv[0],
	355	strerror(failed_errno = errno));
afe19ff7 JK	356	else if (cmd->clean_on_exit)
afe19ff7 JK	357	mark_child_for_cleanup(cmd->pid);
2b541bf8 JS	358
	359	/*
	360	* Wait for child's execvp. If the execvp succeeds (or if fork()
	361	* failed), EOF is seen immediately by the parent. Otherwise, the
	362	* child process sends a single byte.
	363	* Note that use of this infrastructure is completely advisory,
	364	* therefore, we keep error checks minimal.
	365	*/
	366	close(notify_pipe[1]);
	367	if (read(notify_pipe[0], &notify_pipe[1], 1) == 1) {
	368	/*
	369	* At this point we know that fork() succeeded, but execvp()
	370	* failed. Errors have been reported to our stderr.
	371	*/
	372	wait_or_whine(cmd->pid, cmd->argv[0],
	373	cmd->silent_exec_failure);
	374	failed_errno = errno;
	375	cmd->pid = -1;
	376	}
	377	close(notify_pipe[0]);
afe19ff7	378
2b541bf8	379	}
ba26f296	380	#else
0d30ad71	381	{
75301f90	382	int fhin = 0, fhout = 1, fherr = 2;
108ac313	383	const char **sargv = cmd->argv;
ba26f296	384	char **env = environ;
ba26f296	385
75301f90 JS	386	if (cmd->no_stdin)
	387	fhin = open("/dev/null", O_RDWR);
	388	else if (need_in)
	389	fhin = dup(fdin[0]);
	390	else if (cmd->in)
	391	fhin = dup(cmd->in);
	392
	393	if (cmd->no_stderr)
	394	fherr = open("/dev/null", O_RDWR);
	395	else if (need_err)
	396	fherr = dup(fderr[1]);
76d44c8c JH	397	else if (cmd->err > 2)
76d44c8c JH	398	fherr = dup(cmd->err);
75301f90 JS	399
	400	if (cmd->no_stdout)
	401	fhout = open("/dev/null", O_RDWR);
	402	else if (cmd->stdout_to_stderr)
	403	fhout = dup(fherr);
	404	else if (need_out)
	405	fhout = dup(fdout[1]);
	406	else if (cmd->out > 1)
	407	fhout = dup(cmd->out);
ba26f296	408
2affea41 JS	409	if (cmd->env)
2affea41 JS	410	env = make_augmented_environ(cmd->env);
ba26f296 JS	411
ba26f296 JS	412	if (cmd->git_cmd) {
108ac313	413	cmd->argv = prepare_git_cmd(cmd->argv);
8dba1e63 JK	414	} else if (cmd->use_shell) {
8dba1e63 JK	415	cmd->argv = prepare_shell_cmd(cmd->argv);
ba26f296 JS	416	}
ba26f296 JS	417
f9a2743c	418	cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, env, cmd->dir,
75301f90	419	fhin, fhout, fherr);
0ac77ec3	420	failed_errno = errno;
c024beb5	421	if (cmd->pid < 0 && (!cmd->silent_exec_failure \|\| errno != ENOENT))
0ac77ec3	422	error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));
afe19ff7 JK	423	if (cmd->clean_on_exit && cmd->pid >= 0)
afe19ff7 JK	424	mark_child_for_cleanup(cmd->pid);
ba26f296 JS	425
	426	if (cmd->env)
	427	free_environ(env);
	428	if (cmd->git_cmd)
108ac313	429	free(cmd->argv);
ba26f296	430
108ac313	431	cmd->argv = sargv;
75301f90 JS	432	if (fhin != 0)
	433	close(fhin);
	434	if (fhout != 1)
	435	close(fhout);
	436	if (fherr != 2)
	437	close(fherr);
0d30ad71	438	}
ba26f296 JS	439	#endif
	440
	441	if (cmd->pid < 0) {
	442	if (need_in)
	443	close_pair(fdin);
	444	else if (cmd->in)
	445	close(cmd->in);
	446	if (need_out)
	447	close_pair(fdout);
	448	else if (cmd->out)
	449	close(cmd->out);
	450	if (need_err)
	451	close_pair(fderr);
fc012c28 D	452	else if (cmd->err)
fc012c28 D	453	close(cmd->err);
0ac77ec3 JS	454	errno = failed_errno;
0ac77ec3 JS	455	return -1;
ba26f296	456	}
4919bf03 SP	457
	458	if (need_in)
	459	close(fdin[0]);
	460	else if (cmd->in)
	461	close(cmd->in);
	462
f4bba25b SP	463	if (need_out)
f4bba25b SP	464	close(fdout[1]);
c20181e3	465	else if (cmd->out)
f4bba25b SP	466	close(cmd->out);
f4bba25b SP	467
f3b33f1d JS	468	if (need_err)
f3b33f1d JS	469	close(fderr[1]);
4f41b611 SP	470	else if (cmd->err)
4f41b611 SP	471	close(cmd->err);
f3b33f1d	472
ebcb5d16 SP	473	return 0;
	474	}
	475
2d22c208 JS	476	int finish_command(struct child_process *cmd)
2d22c208 JS	477	{
c024beb5	478	return wait_or_whine(cmd->pid, cmd->argv[0], cmd->silent_exec_failure);
2d22c208 JS	479	}
2d22c208 JS	480
ebcb5d16 SP	481	int run_command(struct child_process *cmd)
	482	{
	483	int code = start_command(cmd);
	484	if (code)
	485	return code;
	486	return finish_command(cmd);
	487	}
	488
1568fea0	489	static void prepare_run_command_v_opt(struct child_process *cmd,
ee493148 AR	490	const char **argv,
ee493148 AR	491	int opt)
1568fea0 AR	492	{
	493	memset(cmd, 0, sizeof(*cmd));
	494	cmd->argv = argv;
	495	cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
	496	cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
	497	cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
c024beb5	498	cmd->silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
8dba1e63	499	cmd->use_shell = opt & RUN_USING_SHELL ? 1 : 0;
1568fea0 AR	500	}
1568fea0 AR	501
f1000898 SP	502	int run_command_v_opt(const char **argv, int opt)
	503	{
	504	struct child_process cmd;
1568fea0 AR	505	prepare_run_command_v_opt(&cmd, argv, opt);
	506	return run_command(&cmd);
	507	}
	508
ee493148 AR	509	int run_command_v_opt_cd_env(const char *argv, int opt, const char dir, const char const env)
	510	{
	511	struct child_process cmd;
	512	prepare_run_command_v_opt(&cmd, argv, opt);
	513	cmd.dir = dir;
	514	cmd.env = env;
	515	return run_command(&cmd);
	516	}
2d22c208	517
f6b60983	518	#ifndef NO_PTHREADS
0ea1c89b JS	519	static pthread_t main_thread;
	520	static int main_thread_set;
	521	static pthread_key_t async_key;
	522
200a76b7	523	static void run_thread(void data)
618ebe9f JS	524	{
618ebe9f JS	525	struct async *async = data;
f6b60983	526	intptr_t ret;
0ea1c89b JS	527
0ea1c89b JS	528	pthread_setspecific(async_key, async);
f6b60983	529	ret = async->proc(async->proc_in, async->proc_out, async->data);
200a76b7	530	return (void *)ret;
618ebe9f	531	}
0ea1c89b JS	532
	533	static NORETURN void die_async(const char *err, va_list params)
	534	{
	535	vreportf("fatal: ", err, params);
	536
	537	if (!pthread_equal(main_thread, pthread_self())) {
	538	struct async *async = pthread_getspecific(async_key);
	539	if (async->proc_in >= 0)
	540	close(async->proc_in);
	541	if (async->proc_out >= 0)
	542	close(async->proc_out);
	543	pthread_exit((void *)128);
	544	}
	545
	546	exit(128);
618ebe9f JS	547	}
	548	#endif
	549
2d22c208 JS	550	int start_async(struct async *async)
2d22c208 JS	551	{
ae6a5609 EFL	552	int need_in, need_out;
	553	int fdin[2], fdout[2];
	554	int proc_in, proc_out;
2d22c208	555
ae6a5609 EFL	556	need_in = async->in < 0;
	557	if (need_in) {
	558	if (pipe(fdin) < 0) {
	559	if (async->out > 0)
	560	close(async->out);
	561	return error("cannot create pipe: %s", strerror(errno));
	562	}
	563	async->in = fdin[1];
	564	}
	565
	566	need_out = async->out < 0;
	567	if (need_out) {
	568	if (pipe(fdout) < 0) {
	569	if (need_in)
	570	close_pair(fdin);
	571	else if (async->in)
	572	close(async->in);
	573	return error("cannot create pipe: %s", strerror(errno));
	574	}
	575	async->out = fdout[0];
	576	}
	577
	578	if (need_in)
	579	proc_in = fdin[0];
	580	else if (async->in)
	581	proc_in = async->in;
	582	else
	583	proc_in = -1;
	584
	585	if (need_out)
	586	proc_out = fdout[1];
	587	else if (async->out)
	588	proc_out = async->out;
	589	else
	590	proc_out = -1;
2d22c208	591
f6b60983	592	#ifdef NO_PTHREADS
2c3766f0 AM	593	/* Flush stdio before fork() to avoid cloning buffers */
	594	fflush(NULL);
	595
2d22c208 JS	596	async->pid = fork();
	597	if (async->pid < 0) {
	598	error("fork (async) failed: %s", strerror(errno));
ae6a5609	599	goto error;
2d22c208 JS	600	}
2d22c208 JS	601	if (!async->pid) {
ae6a5609 EFL	602	if (need_in)
	603	close(fdin[1]);
	604	if (need_out)
	605	close(fdout[0]);
	606	exit(!!async->proc(proc_in, proc_out, async->data));
2d22c208	607	}
ae6a5609	608
afe19ff7 JK	609	mark_child_for_cleanup(async->pid);
afe19ff7 JK	610
ae6a5609 EFL	611	if (need_in)
	612	close(fdin[0]);
	613	else if (async->in)
	614	close(async->in);
	615
	616	if (need_out)
	617	close(fdout[1]);
	618	else if (async->out)
	619	close(async->out);
618ebe9f	620	#else
0ea1c89b JS	621	if (!main_thread_set) {
	622	/*
	623	* We assume that the first time that start_async is called
	624	* it is from the main thread.
	625	*/
	626	main_thread_set = 1;
	627	main_thread = pthread_self();
	628	pthread_key_create(&async_key, NULL);
	629	set_die_routine(die_async);
	630	}
	631
200a76b7 JS	632	if (proc_in >= 0)
	633	set_cloexec(proc_in);
	634	if (proc_out >= 0)
	635	set_cloexec(proc_out);
ae6a5609 EFL	636	async->proc_in = proc_in;
ae6a5609 EFL	637	async->proc_out = proc_out;
200a76b7 JS	638	{
	639	int err = pthread_create(&async->tid, NULL, run_thread, async);
	640	if (err) {
	641	error("cannot create thread: %s", strerror(err));
	642	goto error;
	643	}
618ebe9f JS	644	}
618ebe9f JS	645	#endif
2d22c208	646	return 0;
ae6a5609 EFL	647
	648	error:
	649	if (need_in)
	650	close_pair(fdin);
	651	else if (async->in)
	652	close(async->in);
	653
	654	if (need_out)
	655	close_pair(fdout);
	656	else if (async->out)
	657	close(async->out);
	658	return -1;
2d22c208 JS	659	}
	660
	661	int finish_async(struct async *async)
	662	{
f6b60983	663	#ifdef NO_PTHREADS
200a76b7	664	return wait_or_whine(async->pid, "child process", 0);
618ebe9f	665	#else
200a76b7 JS	666	void ret = (void )(intptr_t)(-1);
	667
	668	if (pthread_join(async->tid, &ret))
	669	error("pthread_join failed");
	670	return (int)(intptr_t)ret;
618ebe9f	671	#endif
2d22c208	672	}
ae98a008 SB	673
	674	int run_hook(const char index_file, const char name, ...)
	675	{
	676	struct child_process hook;
5d40a179 JK	677	struct argv_array argv = ARGV_ARRAY_INIT;
5d40a179 JK	678	const char p, env[2];
ae98a008 SB	679	char index[PATH_MAX];
	680	va_list args;
	681	int ret;
ae98a008	682
cf94ca8e SB	683	if (access(git_path("hooks/%s", name), X_OK) < 0)
	684	return 0;
	685
ae98a008	686	va_start(args, name);
5d40a179 JK	687	argv_array_push(&argv, git_path("hooks/%s", name));
	688	while ((p = va_arg(args, const char *)))
	689	argv_array_push(&argv, p);
ae98a008 SB	690	va_end(args);
ae98a008 SB	691
ae98a008	692	memset(&hook, 0, sizeof(hook));
5d40a179	693	hook.argv = argv.argv;
ae98a008 SB	694	hook.no_stdin = 1;
	695	hook.stdout_to_stderr = 1;
	696	if (index_file) {
	697	snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
	698	env[0] = index;
	699	env[1] = NULL;
	700	hook.env = env;
	701	}
	702
0ac77ec3	703	ret = run_command(&hook);
5d40a179	704	argv_array_clear(&argv);
ae98a008 SB	705	return ret;
ae98a008 SB	706	}