1#include "cache.h"
2#include "run-command.h"
3#include "exec_cmd.h"
4#include "sigchain.h"
5#include "argv-array.h"
6void child_process_init(struct child_process *child)
8{
9 memset(child, 0, sizeof(*child));
10 argv_array_init(&child->args);
11 argv_array_init(&child->env_array);
12}
13struct child_to_clean {
15 pid_t pid;
16 struct child_to_clean *next;
17};
18static struct child_to_clean *children_to_clean;
19static int installed_child_cleanup_handler;
20static void cleanup_children(int sig)
22{
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 free(p);
28 }
29}
30static void cleanup_children_on_signal(int sig)
32{
33 cleanup_children(sig);
34 sigchain_pop(sig);
35 raise(sig);
36}
37static void cleanup_children_on_exit(void)
39{
40 cleanup_children(SIGTERM);
41}
42static void mark_child_for_cleanup(pid_t pid)
44{
45 struct child_to_clean *p = xmalloc(sizeof(*p));
46 p->pid = pid;
47 p->next = children_to_clean;
48 children_to_clean = p;
49 if (!installed_child_cleanup_handler) {
51 atexit(cleanup_children_on_exit);
52 sigchain_push_common(cleanup_children_on_signal);
53 installed_child_cleanup_handler = 1;
54 }
55}
56static void clear_child_for_cleanup(pid_t pid)
58{
59 struct child_to_clean **pp;
60 for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
62 struct child_to_clean *clean_me = *pp;
63 if (clean_me->pid == pid) {
65 *pp = clean_me->next;
66 free(clean_me);
67 return;
68 }
69 }
70}
71static inline void close_pair(int fd[2])
73{
74 close(fd[0]);
75 close(fd[1]);
76}
77#ifndef GIT_WINDOWS_NATIVE
79static inline void dup_devnull(int to)
80{
81 int fd = open("/dev/null", O_RDWR);
82 if (fd < 0)
83 die_errno(_("open /dev/null failed"));
84 if (dup2(fd, to) < 0)
85 die_errno(_("dup2(%d,%d) failed"), fd, to);
86 close(fd);
87}
88#endif
89static char *locate_in_PATH(const char *file)
91{
92 const char *p = getenv("PATH");
93 struct strbuf buf = STRBUF_INIT;
94 if (!p || !*p)
96 return NULL;
97 while (1) {
99 const char *end = strchrnul(p, ':');
100 strbuf_reset(&buf);
102 /* POSIX specifies an empty entry as the current directory. */
104 if (end != p) {
105 strbuf_add(&buf, p, end - p);
106 strbuf_addch(&buf, '/');
107 }
108 strbuf_addstr(&buf, file);
109 if (!access(buf.buf, F_OK))
111 return strbuf_detach(&buf, NULL);
112 if (!*end)
114 break;
115 p = end + 1;
116 }
117 strbuf_release(&buf);
119 return NULL;
120}
121static int exists_in_PATH(const char *file)
123{
124 char *r = locate_in_PATH(file);
125 free(r);
126 return r != NULL;
127}
128int sane_execvp(const char *file, char * const argv[])
130{
131 if (!execvp(file, argv))
132 return 0; /* cannot happen ;-) */
133 /*
135 * When a command can't be found because one of the directories
136 * listed in $PATH is unsearchable, execvp reports EACCES, but
137 * careful usability testing (read: analysis of occasional bug
138 * reports) reveals that "No such file or directory" is more
139 * intuitive.
140 *
141 * We avoid commands with "/", because execvp will not do $PATH
142 * lookups in that case.
143 *
144 * The reassignment of EACCES to errno looks like a no-op below,
145 * but we need to protect against exists_in_PATH overwriting errno.
146 */
147 if (errno == EACCES && !strchr(file, '/'))
148 errno = exists_in_PATH(file) ? EACCES : ENOENT;
149 else if (errno == ENOTDIR && !strchr(file, '/'))
150 errno = ENOENT;
151 return -1;
152}
153static const char **prepare_shell_cmd(const char **argv)
155{
156 int argc, nargc = 0;
157 const char **nargv;
158 for (argc = 0; argv[argc]; argc++)
160 ; /* just counting */
161 /* +1 for NULL, +3 for "sh -c" plus extra $0 */
162 nargv = xmalloc(sizeof(*nargv) * (argc + 1 + 3));
163 if (argc < 1)
165 die("BUG: shell command is empty");
166 if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
168#ifndef GIT_WINDOWS_NATIVE
169 nargv[nargc++] = SHELL_PATH;
170#else
171 nargv[nargc++] = "sh";
172#endif
173 nargv[nargc++] = "-c";
174 if (argc < 2)
176 nargv[nargc++] = argv[0];
177 else {
178 struct strbuf arg0 = STRBUF_INIT;
179 strbuf_addf(&arg0, "%s \"$@\"", argv[0]);
180 nargv[nargc++] = strbuf_detach(&arg0, NULL);
181 }
182 }
183 for (argc = 0; argv[argc]; argc++)
185 nargv[nargc++] = argv[argc];
186 nargv[nargc] = NULL;
187 return nargv;
189}
190#ifndef GIT_WINDOWS_NATIVE
192static int execv_shell_cmd(const char **argv)
193{
194 const char **nargv = prepare_shell_cmd(argv);
195 trace_argv_printf(nargv, "trace: exec:");
196 sane_execvp(nargv[0], (char **)nargv);
197 free(nargv);
198 return -1;
199}
200#endif
201#ifndef GIT_WINDOWS_NATIVE
203static int child_notifier = -1;
204static void notify_parent(void)
206{
207 /*
208 * execvp failed. If possible, we'd like to let start_command
209 * know, so failures like ENOENT can be handled right away; but
210 * otherwise, finish_command will still report the error.
211 */
212 xwrite(child_notifier, "", 1);
213}
214#endif
215static inline void set_cloexec(int fd)
217{
218 int flags = fcntl(fd, F_GETFD);
219 if (flags >= 0)
220 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
221}
222static int wait_or_whine(pid_t pid, const char *argv0)
224{
225 int status, code = -1;
226 pid_t waiting;
227 int failed_errno = 0;
228 while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
230 ; /* nothing */
231 if (waiting < 0) {
233 failed_errno = errno;
234 error("waitpid for %s failed: %s", argv0, strerror(errno));
235 } else if (waiting != pid) {
236 error("waitpid is confused (%s)", argv0);
237 } else if (WIFSIGNALED(status)) {
238 code = WTERMSIG(status);
239 if (code != SIGINT && code != SIGQUIT)
240 error("%s died of signal %d", argv0, code);
241 /*
242 * This return value is chosen so that code & 0xff
243 * mimics the exit code that a POSIX shell would report for
244 * a program that died from this signal.
245 */
246 code += 128;
247 } else if (WIFEXITED(status)) {
248 code = WEXITSTATUS(status);
249 /*
250 * Convert special exit code when execvp failed.
251 */
252 if (code == 127) {
253 code = -1;
254 failed_errno = ENOENT;
255 }
256 } else {
257 error("waitpid is confused (%s)", argv0);
258 }
259 clear_child_for_cleanup(pid);
261 errno = failed_errno;
263 return code;
264}
265int start_command(struct child_process *cmd)
267{
268 int need_in, need_out, need_err;
269 int fdin[2], fdout[2], fderr[2];
270 int failed_errno;
271 char *str;
272 if (!cmd->argv)
274 cmd->argv = cmd->args.argv;
275 if (!cmd->env)
276 cmd->env = cmd->env_array.argv;
277 /*
279 * In case of errors we must keep the promise to close FDs
280 * that have been passed in via ->in and ->out.
281 */
282 need_in = !cmd->no_stdin && cmd->in < 0;
284 if (need_in) {
285 if (pipe(fdin) < 0) {
286 failed_errno = errno;
287 if (cmd->out > 0)
288 close(cmd->out);
289 str = "standard input";
290 goto fail_pipe;
291 }
292 cmd->in = fdin[1];
293 }
294 need_out = !cmd->no_stdout
296 && !cmd->stdout_to_stderr
297 && cmd->out < 0;
298 if (need_out) {
299 if (pipe(fdout) < 0) {
300 failed_errno = errno;
301 if (need_in)
302 close_pair(fdin);
303 else if (cmd->in)
304 close(cmd->in);
305 str = "standard output";
306 goto fail_pipe;
307 }
308 cmd->out = fdout[0];
309 }
310 need_err = !cmd->no_stderr && cmd->err < 0;
312 if (need_err) {
313 if (pipe(fderr) < 0) {
314 failed_errno = errno;
315 if (need_in)
316 close_pair(fdin);
317 else if (cmd->in)
318 close(cmd->in);
319 if (need_out)
320 close_pair(fdout);
321 else if (cmd->out)
322 close(cmd->out);
323 str = "standard error";
324fail_pipe:
325 error("cannot create %s pipe for %s: %s",
326 str, cmd->argv[0], strerror(failed_errno));
327 argv_array_clear(&cmd->args);
328 argv_array_clear(&cmd->env_array);
329 errno = failed_errno;
330 return -1;
331 }
332 cmd->err = fderr[0];
333 }
334 trace_argv_printf(cmd->argv, "trace: run_command:");
336 fflush(NULL);
337#ifndef GIT_WINDOWS_NATIVE
339{
340 int notify_pipe[2];
341 if (pipe(notify_pipe))
342 notify_pipe[0] = notify_pipe[1] = -1;
343 cmd->pid = fork();
345 failed_errno = errno;
346 if (!cmd->pid) {
347 /*
348 * Redirect the channel to write syscall error messages to
349 * before redirecting the process's stderr so that all die()
350 * in subsequent call paths use the parent's stderr.
351 */
352 if (cmd->no_stderr || need_err) {
353 int child_err = dup(2);
354 set_cloexec(child_err);
355 set_error_handle(fdopen(child_err, "w"));
356 }
357 close(notify_pipe[0]);
359 set_cloexec(notify_pipe[1]);
360 child_notifier = notify_pipe[1];
361 atexit(notify_parent);
362 if (cmd->no_stdin)
364 dup_devnull(0);
365 else if (need_in) {
366 dup2(fdin[0], 0);
367 close_pair(fdin);
368 } else if (cmd->in) {
369 dup2(cmd->in, 0);
370 close(cmd->in);
371 }
372 if (cmd->no_stderr)
374 dup_devnull(2);
375 else if (need_err) {
376 dup2(fderr[1], 2);
377 close_pair(fderr);
378 } else if (cmd->err > 1) {
379 dup2(cmd->err, 2);
380 close(cmd->err);
381 }
382 if (cmd->no_stdout)
384 dup_devnull(1);
385 else if (cmd->stdout_to_stderr)
386 dup2(2, 1);
387 else if (need_out) {
388 dup2(fdout[1], 1);
389 close_pair(fdout);
390 } else if (cmd->out > 1) {
391 dup2(cmd->out, 1);
392 close(cmd->out);
393 }
394 if (cmd->dir && chdir(cmd->dir))
396 die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
397 cmd->dir);
398 if (cmd->env) {
399 for (; *cmd->env; cmd->env++) {
400 if (strchr(*cmd->env, '='))
401 putenv((char *)*cmd->env);
402 else
403 unsetenv(*cmd->env);
404 }
405 }
406 if (cmd->git_cmd)
407 execv_git_cmd(cmd->argv);
408 else if (cmd->use_shell)
409 execv_shell_cmd(cmd->argv);
410 else
411 sane_execvp(cmd->argv[0], (char *const*) cmd->argv);
412 if (errno == ENOENT) {
413 if (!cmd->silent_exec_failure)
414 error("cannot run %s: %s", cmd->argv[0],
415 strerror(ENOENT));
416 exit(127);
417 } else {
418 die_errno("cannot exec '%s'", cmd->argv[0]);
419 }
420 }
421 if (cmd->pid < 0)
422 error("cannot fork() for %s: %s", cmd->argv[0],
423 strerror(errno));
424 else if (cmd->clean_on_exit)
425 mark_child_for_cleanup(cmd->pid);
426 /*
428 * Wait for child's execvp. If the execvp succeeds (or if fork()
429 * failed), EOF is seen immediately by the parent. Otherwise, the
430 * child process sends a single byte.
431 * Note that use of this infrastructure is completely advisory,
432 * therefore, we keep error checks minimal.
433 */
434 close(notify_pipe[1]);
435 if (read(notify_pipe[0], ¬ify_pipe[1], 1) == 1) {
436 /*
437 * At this point we know that fork() succeeded, but execvp()
438 * failed. Errors have been reported to our stderr.
439 */
440 wait_or_whine(cmd->pid, cmd->argv[0]);
441 failed_errno = errno;
442 cmd->pid = -1;
443 }
444 close(notify_pipe[0]);
445}
446#else
447{
448 int fhin = 0, fhout = 1, fherr = 2;
449 const char **sargv = cmd->argv;
450 if (cmd->no_stdin)
452 fhin = open("/dev/null", O_RDWR);
453 else if (need_in)
454 fhin = dup(fdin[0]);
455 else if (cmd->in)
456 fhin = dup(cmd->in);
457 if (cmd->no_stderr)
459 fherr = open("/dev/null", O_RDWR);
460 else if (need_err)
461 fherr = dup(fderr[1]);
462 else if (cmd->err > 2)
463 fherr = dup(cmd->err);
464 if (cmd->no_stdout)
466 fhout = open("/dev/null", O_RDWR);
467 else if (cmd->stdout_to_stderr)
468 fhout = dup(fherr);
469 else if (need_out)
470 fhout = dup(fdout[1]);
471 else if (cmd->out > 1)
472 fhout = dup(cmd->out);
473 if (cmd->git_cmd)
475 cmd->argv = prepare_git_cmd(cmd->argv);
476 else if (cmd->use_shell)
477 cmd->argv = prepare_shell_cmd(cmd->argv);
478 cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, (char**) cmd->env,
480 cmd->dir, fhin, fhout, fherr);
481 failed_errno = errno;
482 if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
483 error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));
484 if (cmd->clean_on_exit && cmd->pid >= 0)
485 mark_child_for_cleanup(cmd->pid);
486 if (cmd->git_cmd)
488 free(cmd->argv);
489 cmd->argv = sargv;
491 if (fhin != 0)
492 close(fhin);
493 if (fhout != 1)
494 close(fhout);
495 if (fherr != 2)
496 close(fherr);
497}
498#endif
499 if (cmd->pid < 0) {
501 if (need_in)
502 close_pair(fdin);
503 else if (cmd->in)
504 close(cmd->in);
505 if (need_out)
506 close_pair(fdout);
507 else if (cmd->out)
508 close(cmd->out);
509 if (need_err)
510 close_pair(fderr);
511 else if (cmd->err)
512 close(cmd->err);
513 argv_array_clear(&cmd->args);
514 argv_array_clear(&cmd->env_array);
515 errno = failed_errno;
516 return -1;
517 }
518 if (need_in)
520 close(fdin[0]);
521 else if (cmd->in)
522 close(cmd->in);
523 if (need_out)
525 close(fdout[1]);
526 else if (cmd->out)
527 close(cmd->out);
528 if (need_err)
530 close(fderr[1]);
531 else if (cmd->err)
532 close(cmd->err);
533 return 0;
535}
536int finish_command(struct child_process *cmd)
538{
539 int ret = wait_or_whine(cmd->pid, cmd->argv[0]);
540 argv_array_clear(&cmd->args);
541 argv_array_clear(&cmd->env_array);
542 return ret;
543}
544int run_command(struct child_process *cmd)
546{
547 int code;
548 if (cmd->out < 0 || cmd->err < 0)
550 die("BUG: run_command with a pipe can cause deadlock");
551 code = start_command(cmd);
553 if (code)
554 return code;
555 return finish_command(cmd);
556}
557int run_command_v_opt(const char **argv, int opt)
559{
560 return run_command_v_opt_cd_env(argv, opt, NULL, NULL);
561}
562int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
564{
565 struct child_process cmd = CHILD_PROCESS_INIT;
566 cmd.argv = argv;
567 cmd.no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
568 cmd.git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
569 cmd.stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
570 cmd.silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
571 cmd.use_shell = opt & RUN_USING_SHELL ? 1 : 0;
572 cmd.clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
573 cmd.dir = dir;
574 cmd.env = env;
575 return run_command(&cmd);
576}
577#ifndef NO_PTHREADS
579static pthread_t main_thread;
580static int main_thread_set;
581static pthread_key_t async_key;
582static pthread_key_t async_die_counter;
583static void *run_thread(void *data)
585{
586 struct async *async = data;
587 intptr_t ret;
588 pthread_setspecific(async_key, async);
590 ret = async->proc(async->proc_in, async->proc_out, async->data);
591 return (void *)ret;
592}
593static NORETURN void die_async(const char *err, va_list params)
595{
596 vreportf("fatal: ", err, params);
597 if (!pthread_equal(main_thread, pthread_self())) {
599 struct async *async = pthread_getspecific(async_key);
600 if (async->proc_in >= 0)
601 close(async->proc_in);
602 if (async->proc_out >= 0)
603 close(async->proc_out);
604 pthread_exit((void *)128);
605 }
606 exit(128);
608}
609static int async_die_is_recursing(void)
611{
612 void *ret = pthread_getspecific(async_die_counter);
613 pthread_setspecific(async_die_counter, (void *)1);
614 return ret != NULL;
615}
616#else
618static struct {
620 void (**handlers)(void);
621 size_t nr;
622 size_t alloc;
623} git_atexit_hdlrs;
624static int git_atexit_installed;
626static void git_atexit_dispatch(void)
628{
629 size_t i;
630 for (i=git_atexit_hdlrs.nr ; i ; i--)
632 git_atexit_hdlrs.handlers[i-1]();
633}
634static void git_atexit_clear(void)
636{
637 free(git_atexit_hdlrs.handlers);
638 memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
639 git_atexit_installed = 0;
640}
641#undef atexit
643int git_atexit(void (*handler)(void))
644{
645 ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);
646 git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;
647 if (!git_atexit_installed) {
648 if (atexit(&git_atexit_dispatch))
649 return -1;
650 git_atexit_installed = 1;
651 }
652 return 0;
653}
654#define atexit git_atexit
655#endif
657int start_async(struct async *async)
659{
660 int need_in, need_out;
661 int fdin[2], fdout[2];
662 int proc_in, proc_out;
663 need_in = async->in < 0;
665 if (need_in) {
666 if (pipe(fdin) < 0) {
667 if (async->out > 0)
668 close(async->out);
669 return error("cannot create pipe: %s", strerror(errno));
670 }
671 async->in = fdin[1];
672 }
673 need_out = async->out < 0;
675 if (need_out) {
676 if (pipe(fdout) < 0) {
677 if (need_in)
678 close_pair(fdin);
679 else if (async->in)
680 close(async->in);
681 return error("cannot create pipe: %s", strerror(errno));
682 }
683 async->out = fdout[0];
684 }
685 if (need_in)
687 proc_in = fdin[0];
688 else if (async->in)
689 proc_in = async->in;
690 else
691 proc_in = -1;
692 if (need_out)
694 proc_out = fdout[1];
695 else if (async->out)
696 proc_out = async->out;
697 else
698 proc_out = -1;
699#ifdef NO_PTHREADS
701 /* Flush stdio before fork() to avoid cloning buffers */
702 fflush(NULL);
703 async->pid = fork();
705 if (async->pid < 0) {
706 error("fork (async) failed: %s", strerror(errno));
707 goto error;
708 }
709 if (!async->pid) {
710 if (need_in)
711 close(fdin[1]);
712 if (need_out)
713 close(fdout[0]);
714 git_atexit_clear();
715 exit(!!async->proc(proc_in, proc_out, async->data));
716 }
717 mark_child_for_cleanup(async->pid);
719 if (need_in)
721 close(fdin[0]);
722 else if (async->in)
723 close(async->in);
724 if (need_out)
726 close(fdout[1]);
727 else if (async->out)
728 close(async->out);
729#else
730 if (!main_thread_set) {
731 /*
732 * We assume that the first time that start_async is called
733 * it is from the main thread.
734 */
735 main_thread_set = 1;
736 main_thread = pthread_self();
737 pthread_key_create(&async_key, NULL);
738 pthread_key_create(&async_die_counter, NULL);
739 set_die_routine(die_async);
740 set_die_is_recursing_routine(async_die_is_recursing);
741 }
742 if (proc_in >= 0)
744 set_cloexec(proc_in);
745 if (proc_out >= 0)
746 set_cloexec(proc_out);
747 async->proc_in = proc_in;
748 async->proc_out = proc_out;
749 {
750 int err = pthread_create(&async->tid, NULL, run_thread, async);
751 if (err) {
752 error("cannot create thread: %s", strerror(err));
753 goto error;
754 }
755 }
756#endif
757 return 0;
758error:
760 if (need_in)
761 close_pair(fdin);
762 else if (async->in)
763 close(async->in);
764 if (need_out)
766 close_pair(fdout);
767 else if (async->out)
768 close(async->out);
769 return -1;
770}
771int finish_async(struct async *async)
773{
774#ifdef NO_PTHREADS
775 return wait_or_whine(async->pid, "child process");
776#else
777 void *ret = (void *)(intptr_t)(-1);
778 if (pthread_join(async->tid, &ret))
780 error("pthread_join failed");
781 return (int)(intptr_t)ret;
782#endif
783}
784const char *find_hook(const char *name)
786{
787 static struct strbuf path = STRBUF_INIT;
788 strbuf_reset(&path);
790 strbuf_git_path(&path, "hooks/%s", name);
791 if (access(path.buf, X_OK) < 0)
792 return NULL;
793 return path.buf;
794}
795int run_hook_ve(const char *const *env, const char *name, va_list args)
797{
798 struct child_process hook = CHILD_PROCESS_INIT;
799 const char *p;
800 p = find_hook(name);
802 if (!p)
803 return 0;
804 argv_array_push(&hook.args, p);
806 while ((p = va_arg(args, const char *)))
807 argv_array_push(&hook.args, p);
808 hook.env = env;
809 hook.no_stdin = 1;
810 hook.stdout_to_stderr = 1;
811 return run_command(&hook);
813}
814int run_hook_le(const char *const *env, const char *name, ...)
816{
817 va_list args;
818 int ret;
819 va_start(args, name);
821 ret = run_hook_ve(env, name, args);
822 va_end(args);
823 return ret;
825}
826int capture_command(struct child_process *cmd, struct strbuf *buf, size_t hint)
828{
829 cmd->out = -1;
830 if (start_command(cmd) < 0)
831 return -1;
832 if (strbuf_read(buf, cmd->out, hint) < 0) {
834 close(cmd->out);
835 finish_command(cmd); /* throw away exit code */
836 return -1;
837 }
838 close(cmd->out);
840 return finish_command(cmd);
841}