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

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

#ifndef SHELL_PATH
# define SHELL_PATH "/bin/sh"
#endif

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 **pp;

	for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
		struct child_to_clean *clean_me = *pp;

		if (clean_me->pid == pid) {
			*pp = clean_me->next;
			free(clean_me);
			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 char *locate_in_PATH(const char *file)
{
	const char *p = getenv("PATH");
	struct strbuf buf = STRBUF_INIT;

	if (!p || !*p)
		return NULL;

	while (1) {
		const char *end = strchrnul(p, ':');

		strbuf_reset(&buf);

		/* POSIX specifies an empty entry as the current directory. */
		if (end != p) {
			strbuf_add(&buf, p, end - p);
			strbuf_addch(&buf, '/');
		}
		strbuf_addstr(&buf, file);

		if (!access(buf.buf, F_OK))
			return strbuf_detach(&buf, NULL);

		if (!*end)
			break;
		p = end + 1;
	}

	strbuf_release(&buf);
	return NULL;
}

static int exists_in_PATH(const char *file)
{
	char *r = locate_in_PATH(file);
	free(r);
	return r != NULL;
}

int sane_execvp(const char *file, char * const argv[])
{
	if (!execvp(file, argv))
		return 0; /* cannot happen ;-) */

	/*
	 * When a command can't be found because one of the directories
	 * listed in $PATH is unsearchable, execvp reports EACCES, but
	 * careful usability testing (read: analysis of occasional bug
	 * reports) reveals that "No such file or directory" is more
	 * intuitive.
	 *
	 * We avoid commands with "/", because execvp will not do $PATH
	 * lookups in that case.
	 *
	 * The reassignment of EACCES to errno looks like a no-op below,
	 * but we need to protect against exists_in_PATH overwriting errno.
	 */
	if (errno == EACCES && !strchr(file, '/'))
		errno = exists_in_PATH(file) ? EACCES : ENOENT;
	else if (errno == ENOTDIR && !strchr(file, '/'))
		errno = ENOENT;
	return -1;
}

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