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, int in_signal)
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 if (!in_signal)
28 free(p);
29 }
30}
31static void cleanup_children_on_signal(int sig)
33{
34 cleanup_children(sig, 1);
35 sigchain_pop(sig);
36 raise(sig);
37}
38static void cleanup_children_on_exit(void)
40{
41 cleanup_children(SIGTERM, 0);
42}
43static void mark_child_for_cleanup(pid_t pid)
45{
46 struct child_to_clean *p = xmalloc(sizeof(*p));
47 p->pid = pid;
48 p->next = children_to_clean;
49 children_to_clean = p;
50 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;
55 }
56}
57static void clear_child_for_cleanup(pid_t pid)
59{
60 struct child_to_clean **pp;
61 for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
63 struct child_to_clean *clean_me = *pp;
64 if (clean_me->pid == pid) {
66 *pp = clean_me->next;
67 free(clean_me);
68 return;
69 }
70 }
71}
72static inline void close_pair(int fd[2])
74{
75 close(fd[0]);
76 close(fd[1]);
77}
78#ifndef GIT_WINDOWS_NATIVE
80static inline void dup_devnull(int to)
81{
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);
88}
89#endif
90static char *locate_in_PATH(const char *file)
92{
93 const char *p = getenv("PATH");
94 struct strbuf buf = STRBUF_INIT;
95 if (!p || !*p)
97 return NULL;
98 while (1) {
100 const char *end = strchrnul(p, ':');
101 strbuf_reset(&buf);
103 /* POSIX specifies an empty entry as the current directory. */
105 if (end != p) {
106 strbuf_add(&buf, p, end - p);
107 strbuf_addch(&buf, '/');
108 }
109 strbuf_addstr(&buf, file);
110 if (!access(buf.buf, F_OK))
112 return strbuf_detach(&buf, NULL);
113 if (!*end)
115 break;
116 p = end + 1;
117 }
118 strbuf_release(&buf);
120 return NULL;
121}
122static int exists_in_PATH(const char *file)
124{
125 char *r = locate_in_PATH(file);
126 free(r);
127 return r != NULL;
128}
129int sane_execvp(const char *file, char * const argv[])
131{
132 if (!execvp(file, argv))
133 return 0; /* cannot happen ;-) */
134 /*
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.
141 *
142 * We avoid commands with "/", because execvp will not do $PATH
143 * lookups in that case.
144 *
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.
147 */
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;
153}
154static const char **prepare_shell_cmd(const char **argv)
156{
157 int argc, nargc = 0;
158 const char **nargv;
159 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));
164 if (argc < 1)
166 die("BUG: shell command is empty");
167 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";
175 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);
182 }
183 }
184 for (argc = 0; argv[argc]; argc++)
186 nargv[nargc++] = argv[argc];
187 nargv[nargc] = NULL;
188 return nargv;
190}
191#ifndef GIT_WINDOWS_NATIVE
193static int execv_shell_cmd(const char **argv)
194{
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;
200}
201#endif
202#ifndef GIT_WINDOWS_NATIVE
204static int child_notifier = -1;
205static void notify_parent(void)
207{
208 /*
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.
212 */
213 xwrite(child_notifier, "", 1);
214}
215#endif
216static inline void set_cloexec(int fd)
218{
219 int flags = fcntl(fd, F_GETFD);
220 if (flags >= 0)
221 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
222}
223static int wait_or_whine(pid_t pid, const char *argv0, int in_signal)
225{
226 int status, code = -1;
227 pid_t waiting;
228 int failed_errno = 0;
229 while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
231 ; /* nothing */
232 if (in_signal)
233 return 0;
234 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);
244 /*
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.
248 */
249 code += 128;
250 } else if (WIFEXITED(status)) {
251 code = WEXITSTATUS(status);
252 /*
253 * Convert special exit code when execvp failed.
254 */
255 if (code == 127) {
256 code = -1;
257 failed_errno = ENOENT;
258 }
259 } else {
260 error("waitpid is confused (%s)", argv0);
261 }
262 clear_child_for_cleanup(pid);
264 errno = failed_errno;
266 return code;
267}
268int start_command(struct child_process *cmd)
270{
271 int need_in, need_out, need_err;
272 int fdin[2], fdout[2], fderr[2];
273 int failed_errno;
274 char *str;
275 if (!cmd->argv)
277 cmd->argv = cmd->args.argv;
278 if (!cmd->env)
279 cmd->env = cmd->env_array.argv;
280 /*
282 * In case of errors we must keep the promise to close FDs
283 * that have been passed in via ->in and ->out.
284 */
285 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;
294 }
295 cmd->in = fdin[1];
296 }
297 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;
310 }
311 cmd->out = fdout[0];
312 }
313 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";
327fail_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;
334 }
335 cmd->err = fderr[0];
336 }
337 trace_argv_printf(cmd->argv, "trace: run_command:");
339 fflush(NULL);
340#ifndef GIT_WINDOWS_NATIVE
342{
343 int notify_pipe[2];
344 if (pipe(notify_pipe))
345 notify_pipe[0] = notify_pipe[1] = -1;
346 cmd->pid = fork();
348 failed_errno = errno;
349 if (!cmd->pid) {
350 /*
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.
354 */
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"));
359 }
360 close(notify_pipe[0]);
362 set_cloexec(notify_pipe[1]);
363 child_notifier = notify_pipe[1];
364 atexit(notify_parent);
365 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);
374 }
375 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);
384 }
385 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);
396 }
397 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);
407 }
408 }
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]);
422 }
423 }
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);
429 /*
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.
436 */
437 close(notify_pipe[1]);
438 if (read(notify_pipe[0], ¬ify_pipe[1], 1) == 1) {
439 /*
440 * At this point we know that fork() succeeded, but execvp()
441 * failed. Errors have been reported to our stderr.
442 */
443 wait_or_whine(cmd->pid, cmd->argv[0], 0);
444 failed_errno = errno;
445 cmd->pid = -1;
446 }
447 close(notify_pipe[0]);
448}
449#else
450{
451 int fhin = 0, fhout = 1, fherr = 2;
452 const char **sargv = cmd->argv;
453 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);
460 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);
467 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);
476 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);
481 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);
489 if (cmd->git_cmd)
491 free(cmd->argv);
492 cmd->argv = sargv;
494 if (fhin != 0)
495 close(fhin);
496 if (fhout != 1)
497 close(fhout);
498 if (fherr != 2)
499 close(fherr);
500}
501#endif
502 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;
520 }
521 if (need_in)
523 close(fdin[0]);
524 else if (cmd->in)
525 close(cmd->in);
526 if (need_out)
528 close(fdout[1]);
529 else if (cmd->out)
530 close(cmd->out);
531 if (need_err)
533 close(fderr[1]);
534 else if (cmd->err)
535 close(cmd->err);
536 return 0;
538}
539int finish_command(struct child_process *cmd)
541{
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;
546}
547int finish_command_in_signal(struct child_process *cmd)
549{
550 return wait_or_whine(cmd->pid, cmd->argv[0], 1);
551}
552int run_command(struct child_process *cmd)
555{
556 int code;
557 if (cmd->out < 0 || cmd->err < 0)
559 die("BUG: run_command with a pipe can cause deadlock");
560 code = start_command(cmd);
562 if (code)
563 return code;
564 return finish_command(cmd);
565}
566int run_command_v_opt(const char **argv, int opt)
568{
569 return run_command_v_opt_cd_env(argv, opt, NULL, NULL);
570}
571int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
573{
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);
585}
586#ifndef NO_PTHREADS
588static pthread_t main_thread;
589static int main_thread_set;
590static pthread_key_t async_key;
591static pthread_key_t async_die_counter;
592static void *run_thread(void *data)
594{
595 struct async *async = data;
596 intptr_t ret;
597 pthread_setspecific(async_key, async);
599 ret = async->proc(async->proc_in, async->proc_out, async->data);
600 return (void *)ret;
601}
602static NORETURN void die_async(const char *err, va_list params)
604{
605 vreportf("fatal: ", err, params);
606 if (!pthread_equal(main_thread, pthread_self())) {
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);
614 }
615 exit(128);
617}
618static int async_die_is_recursing(void)
620{
621 void *ret = pthread_getspecific(async_die_counter);
622 pthread_setspecific(async_die_counter, (void *)1);
623 return ret != NULL;
624}
625#else
627static struct {
629 void (**handlers)(void);
630 size_t nr;
631 size_t alloc;
632} git_atexit_hdlrs;
633static int git_atexit_installed;
635static void git_atexit_dispatch(void)
637{
638 size_t i;
639 for (i=git_atexit_hdlrs.nr ; i ; i--)
641 git_atexit_hdlrs.handlers[i-1]();
642}
643static void git_atexit_clear(void)
645{
646 free(git_atexit_hdlrs.handlers);
647 memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
648 git_atexit_installed = 0;
649}
650#undef atexit
652int git_atexit(void (*handler)(void))
653{
654 ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);
655 git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;
656 if (!git_atexit_installed) {
657 if (atexit(&git_atexit_dispatch))
658 return -1;
659 git_atexit_installed = 1;
660 }
661 return 0;
662}
663#define atexit git_atexit
664#endif
666int start_async(struct async *async)
668{
669 int need_in, need_out;
670 int fdin[2], fdout[2];
671 int proc_in, proc_out;
672 need_in = async->in < 0;
674 if (need_in) {
675 if (pipe(fdin) < 0) {
676 if (async->out > 0)
677 close(async->out);
678 return error("cannot create pipe: %s", strerror(errno));
679 }
680 async->in = fdin[1];
681 }
682 need_out = async->out < 0;
684 if (need_out) {
685 if (pipe(fdout) < 0) {
686 if (need_in)
687 close_pair(fdin);
688 else if (async->in)
689 close(async->in);
690 return error("cannot create pipe: %s", strerror(errno));
691 }
692 async->out = fdout[0];
693 }
694 if (need_in)
696 proc_in = fdin[0];
697 else if (async->in)
698 proc_in = async->in;
699 else
700 proc_in = -1;
701 if (need_out)
703 proc_out = fdout[1];
704 else if (async->out)
705 proc_out = async->out;
706 else
707 proc_out = -1;
708#ifdef NO_PTHREADS
710 /* Flush stdio before fork() to avoid cloning buffers */
711 fflush(NULL);
712 async->pid = fork();
714 if (async->pid < 0) {
715 error("fork (async) failed: %s", strerror(errno));
716 goto error;
717 }
718 if (!async->pid) {
719 if (need_in)
720 close(fdin[1]);
721 if (need_out)
722 close(fdout[0]);
723 git_atexit_clear();
724 exit(!!async->proc(proc_in, proc_out, async->data));
725 }
726 mark_child_for_cleanup(async->pid);
728 if (need_in)
730 close(fdin[0]);
731 else if (async->in)
732 close(async->in);
733 if (need_out)
735 close(fdout[1]);
736 else if (async->out)
737 close(async->out);
738#else
739 if (!main_thread_set) {
740 /*
741 * We assume that the first time that start_async is called
742 * it is from the main thread.
743 */
744 main_thread_set = 1;
745 main_thread = pthread_self();
746 pthread_key_create(&async_key, NULL);
747 pthread_key_create(&async_die_counter, NULL);
748 set_die_routine(die_async);
749 set_die_is_recursing_routine(async_die_is_recursing);
750 }
751 if (proc_in >= 0)
753 set_cloexec(proc_in);
754 if (proc_out >= 0)
755 set_cloexec(proc_out);
756 async->proc_in = proc_in;
757 async->proc_out = proc_out;
758 {
759 int err = pthread_create(&async->tid, NULL, run_thread, async);
760 if (err) {
761 error("cannot create thread: %s", strerror(err));
762 goto error;
763 }
764 }
765#endif
766 return 0;
767error:
769 if (need_in)
770 close_pair(fdin);
771 else if (async->in)
772 close(async->in);
773 if (need_out)
775 close_pair(fdout);
776 else if (async->out)
777 close(async->out);
778 return -1;
779}
780int finish_async(struct async *async)
782{
783#ifdef NO_PTHREADS
784 return wait_or_whine(async->pid, "child process", 0);
785#else
786 void *ret = (void *)(intptr_t)(-1);
787 if (pthread_join(async->tid, &ret))
789 error("pthread_join failed");
790 return (int)(intptr_t)ret;
791#endif
792}
793const char *find_hook(const char *name)
795{
796 static struct strbuf path = STRBUF_INIT;
797 strbuf_reset(&path);
799 strbuf_git_path(&path, "hooks/%s", name);
800 if (access(path.buf, X_OK) < 0)
801 return NULL;
802 return path.buf;
803}
804int run_hook_ve(const char *const *env, const char *name, va_list args)
806{
807 struct child_process hook = CHILD_PROCESS_INIT;
808 const char *p;
809 p = find_hook(name);
811 if (!p)
812 return 0;
813 argv_array_push(&hook.args, p);
815 while ((p = va_arg(args, const char *)))
816 argv_array_push(&hook.args, p);
817 hook.env = env;
818 hook.no_stdin = 1;
819 hook.stdout_to_stderr = 1;
820 return run_command(&hook);
822}
823int run_hook_le(const char *const *env, const char *name, ...)
825{
826 va_list args;
827 int ret;
828 va_start(args, name);
830 ret = run_hook_ve(env, name, args);
831 va_end(args);
832 return ret;
834}
835int capture_command(struct child_process *cmd, struct strbuf *buf, size_t hint)
837{
838 cmd->out = -1;
839 if (start_command(cmd) < 0)
840 return -1;
841 if (strbuf_read(buf, cmd->out, hint) < 0) {
843 close(cmd->out);
844 finish_command(cmd); /* throw away exit code */
845 return -1;
846 }
847 close(cmd->out);
849 return finish_command(cmd);
850}