git-multimail: update to release 1.2.0
[git.git] / run-command.c
blobe17e456cdaef63d3fa587b8e216bf1fe5c372317
1 #include "cache.h"
2 #include "run-command.h"
3 #include "exec_cmd.h"
4 #include "sigchain.h"
5 #include "argv-array.h"
7 void child_process_init(struct child_process *child)
9 memset(child, 0, sizeof(*child));
10 argv_array_init(&child->args);
11 argv_array_init(&child->env_array);
14 struct child_to_clean {
15 pid_t pid;
16 struct child_to_clean *next;
18 static struct child_to_clean *children_to_clean;
19 static int installed_child_cleanup_handler;
21 static void cleanup_children(int sig, int in_signal)
23 while (children_to_clean) {
24 struct child_to_clean *p = children_to_clean;
25 children_to_clean = p->next;
26 kill(p->pid, sig);
27 if (!in_signal)
28 free(p);
32 static void cleanup_children_on_signal(int sig)
34 cleanup_children(sig, 1);
35 sigchain_pop(sig);
36 raise(sig);
39 static void cleanup_children_on_exit(void)
41 cleanup_children(SIGTERM, 0);
44 static void mark_child_for_cleanup(pid_t pid)
46 struct child_to_clean *p = xmalloc(sizeof(*p));
47 p->pid = pid;
48 p->next = children_to_clean;
49 children_to_clean = p;
51 if (!installed_child_cleanup_handler) {
52 atexit(cleanup_children_on_exit);
53 sigchain_push_common(cleanup_children_on_signal);
54 installed_child_cleanup_handler = 1;
58 static void clear_child_for_cleanup(pid_t pid)
60 struct child_to_clean **pp;
62 for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
63 struct child_to_clean *clean_me = *pp;
65 if (clean_me->pid == pid) {
66 *pp = clean_me->next;
67 free(clean_me);
68 return;
73 static inline void close_pair(int fd[2])
75 close(fd[0]);
76 close(fd[1]);
79 #ifndef GIT_WINDOWS_NATIVE
80 static inline void dup_devnull(int to)
82 int fd = open("/dev/null", O_RDWR);
83 if (fd < 0)
84 die_errno(_("open /dev/null failed"));
85 if (dup2(fd, to) < 0)
86 die_errno(_("dup2(%d,%d) failed"), fd, to);
87 close(fd);
89 #endif
91 static char *locate_in_PATH(const char *file)
93 const char *p = getenv("PATH");
94 struct strbuf buf = STRBUF_INIT;
96 if (!p || !*p)
97 return NULL;
99 while (1) {
100 const char *end = strchrnul(p, ':');
102 strbuf_reset(&buf);
104 /* POSIX specifies an empty entry as the current directory. */
105 if (end != p) {
106 strbuf_add(&buf, p, end - p);
107 strbuf_addch(&buf, '/');
109 strbuf_addstr(&buf, file);
111 if (!access(buf.buf, F_OK))
112 return strbuf_detach(&buf, NULL);
114 if (!*end)
115 break;
116 p = end + 1;
119 strbuf_release(&buf);
120 return NULL;
123 static int exists_in_PATH(const char *file)
125 char *r = locate_in_PATH(file);
126 free(r);
127 return r != NULL;
130 int sane_execvp(const char *file, char * const argv[])
132 if (!execvp(file, argv))
133 return 0; /* cannot happen ;-) */
136 * When a command can't be found because one of the directories
137 * listed in $PATH is unsearchable, execvp reports EACCES, but
138 * careful usability testing (read: analysis of occasional bug
139 * reports) reveals that "No such file or directory" is more
140 * intuitive.
142 * We avoid commands with "/", because execvp will not do $PATH
143 * lookups in that case.
145 * The reassignment of EACCES to errno looks like a no-op below,
146 * but we need to protect against exists_in_PATH overwriting errno.
148 if (errno == EACCES && !strchr(file, '/'))
149 errno = exists_in_PATH(file) ? EACCES : ENOENT;
150 else if (errno == ENOTDIR && !strchr(file, '/'))
151 errno = ENOENT;
152 return -1;
155 static const char **prepare_shell_cmd(const char **argv)
157 int argc, nargc = 0;
158 const char **nargv;
160 for (argc = 0; argv[argc]; argc++)
161 ; /* just counting */
162 /* +1 for NULL, +3 for "sh -c" plus extra $0 */
163 nargv = xmalloc(sizeof(*nargv) * (argc + 1 + 3));
165 if (argc < 1)
166 die("BUG: shell command is empty");
168 if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
169 #ifndef GIT_WINDOWS_NATIVE
170 nargv[nargc++] = SHELL_PATH;
171 #else
172 nargv[nargc++] = "sh";
173 #endif
174 nargv[nargc++] = "-c";
176 if (argc < 2)
177 nargv[nargc++] = argv[0];
178 else {
179 struct strbuf arg0 = STRBUF_INIT;
180 strbuf_addf(&arg0, "%s \"$@\"", argv[0]);
181 nargv[nargc++] = strbuf_detach(&arg0, NULL);
185 for (argc = 0; argv[argc]; argc++)
186 nargv[nargc++] = argv[argc];
187 nargv[nargc] = NULL;
189 return nargv;
192 #ifndef GIT_WINDOWS_NATIVE
193 static int execv_shell_cmd(const char **argv)
195 const char **nargv = prepare_shell_cmd(argv);
196 trace_argv_printf(nargv, "trace: exec:");
197 sane_execvp(nargv[0], (char **)nargv);
198 free(nargv);
199 return -1;
201 #endif
203 #ifndef GIT_WINDOWS_NATIVE
204 static int child_notifier = -1;
206 static void notify_parent(void)
209 * execvp failed. If possible, we'd like to let start_command
210 * know, so failures like ENOENT can be handled right away; but
211 * otherwise, finish_command will still report the error.
213 xwrite(child_notifier, "", 1);
215 #endif
217 static inline void set_cloexec(int fd)
219 int flags = fcntl(fd, F_GETFD);
220 if (flags >= 0)
221 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
224 static int wait_or_whine(pid_t pid, const char *argv0, int in_signal)
226 int status, code = -1;
227 pid_t waiting;
228 int failed_errno = 0;
230 while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
231 ; /* nothing */
232 if (in_signal)
233 return 0;
235 if (waiting < 0) {
236 failed_errno = errno;
237 error("waitpid for %s failed: %s", argv0, strerror(errno));
238 } else if (waiting != pid) {
239 error("waitpid is confused (%s)", argv0);
240 } else if (WIFSIGNALED(status)) {
241 code = WTERMSIG(status);
242 if (code != SIGINT && code != SIGQUIT)
243 error("%s died of signal %d", argv0, code);
245 * This return value is chosen so that code & 0xff
246 * mimics the exit code that a POSIX shell would report for
247 * a program that died from this signal.
249 code += 128;
250 } else if (WIFEXITED(status)) {
251 code = WEXITSTATUS(status);
253 * Convert special exit code when execvp failed.
255 if (code == 127) {
256 code = -1;
257 failed_errno = ENOENT;
259 } else {
260 error("waitpid is confused (%s)", argv0);
263 clear_child_for_cleanup(pid);
265 errno = failed_errno;
266 return code;
269 int start_command(struct child_process *cmd)
271 int need_in, need_out, need_err;
272 int fdin[2], fdout[2], fderr[2];
273 int failed_errno;
274 char *str;
276 if (!cmd->argv)
277 cmd->argv = cmd->args.argv;
278 if (!cmd->env)
279 cmd->env = cmd->env_array.argv;
282 * In case of errors we must keep the promise to close FDs
283 * that have been passed in via ->in and ->out.
286 need_in = !cmd->no_stdin && cmd->in < 0;
287 if (need_in) {
288 if (pipe(fdin) < 0) {
289 failed_errno = errno;
290 if (cmd->out > 0)
291 close(cmd->out);
292 str = "standard input";
293 goto fail_pipe;
295 cmd->in = fdin[1];
298 need_out = !cmd->no_stdout
299 && !cmd->stdout_to_stderr
300 && cmd->out < 0;
301 if (need_out) {
302 if (pipe(fdout) < 0) {
303 failed_errno = errno;
304 if (need_in)
305 close_pair(fdin);
306 else if (cmd->in)
307 close(cmd->in);
308 str = "standard output";
309 goto fail_pipe;
311 cmd->out = fdout[0];
314 need_err = !cmd->no_stderr && cmd->err < 0;
315 if (need_err) {
316 if (pipe(fderr) < 0) {
317 failed_errno = errno;
318 if (need_in)
319 close_pair(fdin);
320 else if (cmd->in)
321 close(cmd->in);
322 if (need_out)
323 close_pair(fdout);
324 else if (cmd->out)
325 close(cmd->out);
326 str = "standard error";
327 fail_pipe:
328 error("cannot create %s pipe for %s: %s",
329 str, cmd->argv[0], strerror(failed_errno));
330 argv_array_clear(&cmd->args);
331 argv_array_clear(&cmd->env_array);
332 errno = failed_errno;
333 return -1;
335 cmd->err = fderr[0];
338 trace_argv_printf(cmd->argv, "trace: run_command:");
339 fflush(NULL);
341 #ifndef GIT_WINDOWS_NATIVE
343 int notify_pipe[2];
344 if (pipe(notify_pipe))
345 notify_pipe[0] = notify_pipe[1] = -1;
347 cmd->pid = fork();
348 failed_errno = errno;
349 if (!cmd->pid) {
351 * Redirect the channel to write syscall error messages to
352 * before redirecting the process's stderr so that all die()
353 * in subsequent call paths use the parent's stderr.
355 if (cmd->no_stderr || need_err) {
356 int child_err = dup(2);
357 set_cloexec(child_err);
358 set_error_handle(fdopen(child_err, "w"));
361 close(notify_pipe[0]);
362 set_cloexec(notify_pipe[1]);
363 child_notifier = notify_pipe[1];
364 atexit(notify_parent);
366 if (cmd->no_stdin)
367 dup_devnull(0);
368 else if (need_in) {
369 dup2(fdin[0], 0);
370 close_pair(fdin);
371 } else if (cmd->in) {
372 dup2(cmd->in, 0);
373 close(cmd->in);
376 if (cmd->no_stderr)
377 dup_devnull(2);
378 else if (need_err) {
379 dup2(fderr[1], 2);
380 close_pair(fderr);
381 } else if (cmd->err > 1) {
382 dup2(cmd->err, 2);
383 close(cmd->err);
386 if (cmd->no_stdout)
387 dup_devnull(1);
388 else if (cmd->stdout_to_stderr)
389 dup2(2, 1);
390 else if (need_out) {
391 dup2(fdout[1], 1);
392 close_pair(fdout);
393 } else if (cmd->out > 1) {
394 dup2(cmd->out, 1);
395 close(cmd->out);
398 if (cmd->dir && chdir(cmd->dir))
399 die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
400 cmd->dir);
401 if (cmd->env) {
402 for (; *cmd->env; cmd->env++) {
403 if (strchr(*cmd->env, '='))
404 putenv((char *)*cmd->env);
405 else
406 unsetenv(*cmd->env);
409 if (cmd->git_cmd)
410 execv_git_cmd(cmd->argv);
411 else if (cmd->use_shell)
412 execv_shell_cmd(cmd->argv);
413 else
414 sane_execvp(cmd->argv[0], (char *const*) cmd->argv);
415 if (errno == ENOENT) {
416 if (!cmd->silent_exec_failure)
417 error("cannot run %s: %s", cmd->argv[0],
418 strerror(ENOENT));
419 exit(127);
420 } else {
421 die_errno("cannot exec '%s'", cmd->argv[0]);
424 if (cmd->pid < 0)
425 error("cannot fork() for %s: %s", cmd->argv[0],
426 strerror(errno));
427 else if (cmd->clean_on_exit)
428 mark_child_for_cleanup(cmd->pid);
431 * Wait for child's execvp. If the execvp succeeds (or if fork()
432 * failed), EOF is seen immediately by the parent. Otherwise, the
433 * child process sends a single byte.
434 * Note that use of this infrastructure is completely advisory,
435 * therefore, we keep error checks minimal.
437 close(notify_pipe[1]);
438 if (read(notify_pipe[0], &notify_pipe[1], 1) == 1) {
440 * At this point we know that fork() succeeded, but execvp()
441 * failed. Errors have been reported to our stderr.
443 wait_or_whine(cmd->pid, cmd->argv[0], 0);
444 failed_errno = errno;
445 cmd->pid = -1;
447 close(notify_pipe[0]);
449 #else
451 int fhin = 0, fhout = 1, fherr = 2;
452 const char **sargv = cmd->argv;
454 if (cmd->no_stdin)
455 fhin = open("/dev/null", O_RDWR);
456 else if (need_in)
457 fhin = dup(fdin[0]);
458 else if (cmd->in)
459 fhin = dup(cmd->in);
461 if (cmd->no_stderr)
462 fherr = open("/dev/null", O_RDWR);
463 else if (need_err)
464 fherr = dup(fderr[1]);
465 else if (cmd->err > 2)
466 fherr = dup(cmd->err);
468 if (cmd->no_stdout)
469 fhout = open("/dev/null", O_RDWR);
470 else if (cmd->stdout_to_stderr)
471 fhout = dup(fherr);
472 else if (need_out)
473 fhout = dup(fdout[1]);
474 else if (cmd->out > 1)
475 fhout = dup(cmd->out);
477 if (cmd->git_cmd)
478 cmd->argv = prepare_git_cmd(cmd->argv);
479 else if (cmd->use_shell)
480 cmd->argv = prepare_shell_cmd(cmd->argv);
482 cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, (char**) cmd->env,
483 cmd->dir, fhin, fhout, fherr);
484 failed_errno = errno;
485 if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
486 error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));
487 if (cmd->clean_on_exit && cmd->pid >= 0)
488 mark_child_for_cleanup(cmd->pid);
490 if (cmd->git_cmd)
491 free(cmd->argv);
493 cmd->argv = sargv;
494 if (fhin != 0)
495 close(fhin);
496 if (fhout != 1)
497 close(fhout);
498 if (fherr != 2)
499 close(fherr);
501 #endif
503 if (cmd->pid < 0) {
504 if (need_in)
505 close_pair(fdin);
506 else if (cmd->in)
507 close(cmd->in);
508 if (need_out)
509 close_pair(fdout);
510 else if (cmd->out)
511 close(cmd->out);
512 if (need_err)
513 close_pair(fderr);
514 else if (cmd->err)
515 close(cmd->err);
516 argv_array_clear(&cmd->args);
517 argv_array_clear(&cmd->env_array);
518 errno = failed_errno;
519 return -1;
522 if (need_in)
523 close(fdin[0]);
524 else if (cmd->in)
525 close(cmd->in);
527 if (need_out)
528 close(fdout[1]);
529 else if (cmd->out)
530 close(cmd->out);
532 if (need_err)
533 close(fderr[1]);
534 else if (cmd->err)
535 close(cmd->err);
537 return 0;
540 int finish_command(struct child_process *cmd)
542 int ret = wait_or_whine(cmd->pid, cmd->argv[0], 0);
543 argv_array_clear(&cmd->args);
544 argv_array_clear(&cmd->env_array);
545 return ret;
548 int finish_command_in_signal(struct child_process *cmd)
550 return wait_or_whine(cmd->pid, cmd->argv[0], 1);
554 int run_command(struct child_process *cmd)
556 int code;
558 if (cmd->out < 0 || cmd->err < 0)
559 die("BUG: run_command with a pipe can cause deadlock");
561 code = start_command(cmd);
562 if (code)
563 return code;
564 return finish_command(cmd);
567 int run_command_v_opt(const char **argv, int opt)
569 return run_command_v_opt_cd_env(argv, opt, NULL, NULL);
572 int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
574 struct child_process cmd = CHILD_PROCESS_INIT;
575 cmd.argv = argv;
576 cmd.no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
577 cmd.git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
578 cmd.stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
579 cmd.silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
580 cmd.use_shell = opt & RUN_USING_SHELL ? 1 : 0;
581 cmd.clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
582 cmd.dir = dir;
583 cmd.env = env;
584 return run_command(&cmd);
587 #ifndef NO_PTHREADS
588 static pthread_t main_thread;
589 static int main_thread_set;
590 static pthread_key_t async_key;
591 static pthread_key_t async_die_counter;
593 static void *run_thread(void *data)
595 struct async *async = data;
596 intptr_t ret;
598 pthread_setspecific(async_key, async);
599 ret = async->proc(async->proc_in, async->proc_out, async->data);
600 return (void *)ret;
603 static NORETURN void die_async(const char *err, va_list params)
605 vreportf("fatal: ", err, params);
607 if (in_async()) {
608 struct async *async = pthread_getspecific(async_key);
609 if (async->proc_in >= 0)
610 close(async->proc_in);
611 if (async->proc_out >= 0)
612 close(async->proc_out);
613 pthread_exit((void *)128);
616 exit(128);
619 static int async_die_is_recursing(void)
621 void *ret = pthread_getspecific(async_die_counter);
622 pthread_setspecific(async_die_counter, (void *)1);
623 return ret != NULL;
626 int in_async(void)
628 if (!main_thread_set)
629 return 0; /* no asyncs started yet */
630 return !pthread_equal(main_thread, pthread_self());
633 #else
635 static struct {
636 void (**handlers)(void);
637 size_t nr;
638 size_t alloc;
639 } git_atexit_hdlrs;
641 static int git_atexit_installed;
643 static void git_atexit_dispatch(void)
645 size_t i;
647 for (i=git_atexit_hdlrs.nr ; i ; i--)
648 git_atexit_hdlrs.handlers[i-1]();
651 static void git_atexit_clear(void)
653 free(git_atexit_hdlrs.handlers);
654 memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
655 git_atexit_installed = 0;
658 #undef atexit
659 int git_atexit(void (*handler)(void))
661 ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);
662 git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;
663 if (!git_atexit_installed) {
664 if (atexit(&git_atexit_dispatch))
665 return -1;
666 git_atexit_installed = 1;
668 return 0;
670 #define atexit git_atexit
672 static int process_is_async;
673 int in_async(void)
675 return process_is_async;
678 #endif
680 int start_async(struct async *async)
682 int need_in, need_out;
683 int fdin[2], fdout[2];
684 int proc_in, proc_out;
686 need_in = async->in < 0;
687 if (need_in) {
688 if (pipe(fdin) < 0) {
689 if (async->out > 0)
690 close(async->out);
691 return error("cannot create pipe: %s", strerror(errno));
693 async->in = fdin[1];
696 need_out = async->out < 0;
697 if (need_out) {
698 if (pipe(fdout) < 0) {
699 if (need_in)
700 close_pair(fdin);
701 else if (async->in)
702 close(async->in);
703 return error("cannot create pipe: %s", strerror(errno));
705 async->out = fdout[0];
708 if (need_in)
709 proc_in = fdin[0];
710 else if (async->in)
711 proc_in = async->in;
712 else
713 proc_in = -1;
715 if (need_out)
716 proc_out = fdout[1];
717 else if (async->out)
718 proc_out = async->out;
719 else
720 proc_out = -1;
722 #ifdef NO_PTHREADS
723 /* Flush stdio before fork() to avoid cloning buffers */
724 fflush(NULL);
726 async->pid = fork();
727 if (async->pid < 0) {
728 error("fork (async) failed: %s", strerror(errno));
729 goto error;
731 if (!async->pid) {
732 if (need_in)
733 close(fdin[1]);
734 if (need_out)
735 close(fdout[0]);
736 git_atexit_clear();
737 process_is_async = 1;
738 exit(!!async->proc(proc_in, proc_out, async->data));
741 mark_child_for_cleanup(async->pid);
743 if (need_in)
744 close(fdin[0]);
745 else if (async->in)
746 close(async->in);
748 if (need_out)
749 close(fdout[1]);
750 else if (async->out)
751 close(async->out);
752 #else
753 if (!main_thread_set) {
755 * We assume that the first time that start_async is called
756 * it is from the main thread.
758 main_thread_set = 1;
759 main_thread = pthread_self();
760 pthread_key_create(&async_key, NULL);
761 pthread_key_create(&async_die_counter, NULL);
762 set_die_routine(die_async);
763 set_die_is_recursing_routine(async_die_is_recursing);
766 if (proc_in >= 0)
767 set_cloexec(proc_in);
768 if (proc_out >= 0)
769 set_cloexec(proc_out);
770 async->proc_in = proc_in;
771 async->proc_out = proc_out;
773 int err = pthread_create(&async->tid, NULL, run_thread, async);
774 if (err) {
775 error("cannot create thread: %s", strerror(err));
776 goto error;
779 #endif
780 return 0;
782 error:
783 if (need_in)
784 close_pair(fdin);
785 else if (async->in)
786 close(async->in);
788 if (need_out)
789 close_pair(fdout);
790 else if (async->out)
791 close(async->out);
792 return -1;
795 int finish_async(struct async *async)
797 #ifdef NO_PTHREADS
798 return wait_or_whine(async->pid, "child process", 0);
799 #else
800 void *ret = (void *)(intptr_t)(-1);
802 if (pthread_join(async->tid, &ret))
803 error("pthread_join failed");
804 return (int)(intptr_t)ret;
805 #endif
808 const char *find_hook(const char *name)
810 static struct strbuf path = STRBUF_INIT;
812 strbuf_reset(&path);
813 strbuf_git_path(&path, "hooks/%s", name);
814 if (access(path.buf, X_OK) < 0)
815 return NULL;
816 return path.buf;
819 int run_hook_ve(const char *const *env, const char *name, va_list args)
821 struct child_process hook = CHILD_PROCESS_INIT;
822 const char *p;
824 p = find_hook(name);
825 if (!p)
826 return 0;
828 argv_array_push(&hook.args, p);
829 while ((p = va_arg(args, const char *)))
830 argv_array_push(&hook.args, p);
831 hook.env = env;
832 hook.no_stdin = 1;
833 hook.stdout_to_stderr = 1;
835 return run_command(&hook);
838 int run_hook_le(const char *const *env, const char *name, ...)
840 va_list args;
841 int ret;
843 va_start(args, name);
844 ret = run_hook_ve(env, name, args);
845 va_end(args);
847 return ret;
850 int capture_command(struct child_process *cmd, struct strbuf *buf, size_t hint)
852 cmd->out = -1;
853 if (start_command(cmd) < 0)
854 return -1;
856 if (strbuf_read(buf, cmd->out, hint) < 0) {
857 close(cmd->out);
858 finish_command(cmd); /* throw away exit code */
859 return -1;
862 close(cmd->out);
863 return finish_command(cmd);