am: Use cat instead of echo to avoid DOS line-endings (fixes t4150)
[git/dscho.git] / run-command.c
blobe66536846963920a824908bb3d1f1d0301b3d1b2
1 #include "cache.h"
2 #include "run-command.h"
3 #include "exec_cmd.h"
4 #include "sigchain.h"
5 #include "argv-array.h"
7 #ifndef SHELL_PATH
8 # define SHELL_PATH "/bin/sh"
9 #endif
11 struct child_to_clean {
12 pid_t pid;
13 struct child_to_clean *next;
15 static struct child_to_clean *children_to_clean;
16 static int installed_child_cleanup_handler;
18 static void cleanup_children(int sig)
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);
28 static void cleanup_children_on_signal(int sig)
30 cleanup_children(sig);
31 sigchain_pop(sig);
32 raise(sig);
35 static void cleanup_children_on_exit(void)
37 cleanup_children(SIGTERM);
40 static void mark_child_for_cleanup(pid_t pid)
42 struct child_to_clean *p = xmalloc(sizeof(*p));
43 p->pid = pid;
44 p->next = children_to_clean;
45 children_to_clean = p;
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;
54 static void clear_child_for_cleanup(pid_t pid)
56 struct child_to_clean **last, *p;
58 last = &children_to_clean;
59 for (p = children_to_clean; p; p = p->next) {
60 if (p->pid == pid) {
61 *last = p->next;
62 free(p);
63 return;
68 static inline void close_pair(int fd[2])
70 close(fd[0]);
71 close(fd[1]);
74 #ifndef WIN32
75 static inline void dup_devnull(int to)
77 int fd = open("/dev/null", O_RDWR);
78 dup2(fd, to);
79 close(fd);
81 #endif
83 static char *locate_in_PATH(const char *file)
85 const char *p = getenv("PATH");
86 struct strbuf buf = STRBUF_INIT;
88 if (!p || !*p)
89 return NULL;
91 while (1) {
92 const char *end = strchrnul(p, ':');
94 strbuf_reset(&buf);
96 /* POSIX specifies an empty entry as the current directory. */
97 if (end != p) {
98 strbuf_add(&buf, p, end - p);
99 strbuf_addch(&buf, '/');
101 strbuf_addstr(&buf, file);
103 if (!access(buf.buf, F_OK))
104 return strbuf_detach(&buf, NULL);
106 if (!*end)
107 break;
108 p = end + 1;
111 strbuf_release(&buf);
112 return NULL;
115 static int exists_in_PATH(const char *file)
117 char *r = locate_in_PATH(file);
118 free(r);
119 return r != NULL;
122 int sane_execvp(const char *file, char * const argv[])
124 if (!execvp(file, argv))
125 return 0; /* cannot happen ;-) */
128 * When a command can't be found because one of the directories
129 * listed in $PATH is unsearchable, execvp reports EACCES, but
130 * careful usability testing (read: analysis of occasional bug
131 * reports) reveals that "No such file or directory" is more
132 * intuitive.
134 * We avoid commands with "/", because execvp will not do $PATH
135 * lookups in that case.
137 * The reassignment of EACCES to errno looks like a no-op below,
138 * but we need to protect against exists_in_PATH overwriting errno.
140 if (errno == EACCES && !strchr(file, '/'))
141 errno = exists_in_PATH(file) ? EACCES : ENOENT;
142 return -1;
145 static const char **prepare_shell_cmd(const char **argv)
147 int argc, nargc = 0;
148 const char **nargv;
150 for (argc = 0; argv[argc]; argc++)
151 ; /* just counting */
152 /* +1 for NULL, +3 for "sh -c" plus extra $0 */
153 nargv = xmalloc(sizeof(*nargv) * (argc + 1 + 3));
155 if (argc < 1)
156 die("BUG: shell command is empty");
158 if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
159 #ifndef WIN32
160 nargv[nargc++] = SHELL_PATH;
161 #else
162 nargv[nargc++] = "sh";
163 #endif
164 nargv[nargc++] = "-c";
166 if (argc < 2)
167 nargv[nargc++] = argv[0];
168 else {
169 struct strbuf arg0 = STRBUF_INIT;
170 strbuf_addf(&arg0, "%s \"$@\"", argv[0]);
171 nargv[nargc++] = strbuf_detach(&arg0, NULL);
175 for (argc = 0; argv[argc]; argc++)
176 nargv[nargc++] = argv[argc];
177 nargv[nargc] = NULL;
179 return nargv;
182 #ifndef WIN32
183 static int execv_shell_cmd(const char **argv)
185 const char **nargv = prepare_shell_cmd(argv);
186 trace_argv_printf(nargv, "trace: exec:");
187 sane_execvp(nargv[0], (char **)nargv);
188 free(nargv);
189 return -1;
191 #endif
193 #ifndef WIN32
194 static int child_err = 2;
195 static int child_notifier = -1;
197 static void notify_parent(void)
200 * execvp failed. If possible, we'd like to let start_command
201 * know, so failures like ENOENT can be handled right away; but
202 * otherwise, finish_command will still report the error.
204 xwrite(child_notifier, "", 1);
207 static NORETURN void die_child(const char *err, va_list params)
209 vwritef(child_err, "fatal: ", err, params);
210 exit(128);
213 static void error_child(const char *err, va_list params)
215 vwritef(child_err, "error: ", err, params);
217 #endif
219 static inline void set_cloexec(int fd)
221 int flags = fcntl(fd, F_GETFD);
222 if (flags >= 0)
223 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
226 static int wait_or_whine(pid_t pid, const char *argv0, int silent_exec_failure)
228 int status, code = -1;
229 pid_t waiting;
230 int failed_errno = 0;
232 while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
233 ; /* nothing */
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 error("%s died of signal %d", argv0, code);
244 * This return value is chosen so that code & 0xff
245 * mimics the exit code that a POSIX shell would report for
246 * a program that died from this signal.
248 code -= 128;
249 } else if (WIFEXITED(status)) {
250 code = WEXITSTATUS(status);
252 * Convert special exit code when execvp failed.
254 if (code == 127) {
255 code = -1;
256 failed_errno = ENOENT;
258 } else {
259 error("waitpid is confused (%s)", argv0);
262 clear_child_for_cleanup(pid);
264 errno = failed_errno;
265 return code;
268 int start_command(struct child_process *cmd)
270 int need_in, need_out, need_err;
271 int fdin[2], fdout[2], fderr[2];
272 int failed_errno = failed_errno;
275 * In case of errors we must keep the promise to close FDs
276 * that have been passed in via ->in and ->out.
279 need_in = !cmd->no_stdin && cmd->in < 0;
280 if (need_in) {
281 if (pipe(fdin) < 0) {
282 failed_errno = errno;
283 if (cmd->out > 0)
284 close(cmd->out);
285 goto fail_pipe;
287 cmd->in = fdin[1];
290 need_out = !cmd->no_stdout
291 && !cmd->stdout_to_stderr
292 && cmd->out < 0;
293 if (need_out) {
294 if (pipe(fdout) < 0) {
295 failed_errno = errno;
296 if (need_in)
297 close_pair(fdin);
298 else if (cmd->in)
299 close(cmd->in);
300 goto fail_pipe;
302 cmd->out = fdout[0];
305 need_err = !cmd->no_stderr && cmd->err < 0;
306 if (need_err) {
307 if (pipe(fderr) < 0) {
308 failed_errno = errno;
309 if (need_in)
310 close_pair(fdin);
311 else if (cmd->in)
312 close(cmd->in);
313 if (need_out)
314 close_pair(fdout);
315 else if (cmd->out)
316 close(cmd->out);
317 fail_pipe:
318 error("cannot create pipe for %s: %s",
319 cmd->argv[0], strerror(failed_errno));
320 errno = failed_errno;
321 return -1;
323 cmd->err = fderr[0];
326 trace_argv_printf(cmd->argv, "trace: run_command:");
327 fflush(NULL);
329 #ifndef WIN32
331 int notify_pipe[2];
332 if (pipe(notify_pipe))
333 notify_pipe[0] = notify_pipe[1] = -1;
335 cmd->pid = fork();
336 if (!cmd->pid) {
338 * Redirect the channel to write syscall error messages to
339 * before redirecting the process's stderr so that all die()
340 * in subsequent call paths use the parent's stderr.
342 if (cmd->no_stderr || need_err) {
343 child_err = dup(2);
344 set_cloexec(child_err);
346 set_die_routine(die_child);
347 set_error_routine(error_child);
349 close(notify_pipe[0]);
350 set_cloexec(notify_pipe[1]);
351 child_notifier = notify_pipe[1];
352 atexit(notify_parent);
354 if (cmd->no_stdin)
355 dup_devnull(0);
356 else if (need_in) {
357 dup2(fdin[0], 0);
358 close_pair(fdin);
359 } else if (cmd->in) {
360 dup2(cmd->in, 0);
361 close(cmd->in);
364 if (cmd->no_stderr)
365 dup_devnull(2);
366 else if (need_err) {
367 dup2(fderr[1], 2);
368 close_pair(fderr);
369 } else if (cmd->err > 1) {
370 dup2(cmd->err, 2);
371 close(cmd->err);
374 if (cmd->no_stdout)
375 dup_devnull(1);
376 else if (cmd->stdout_to_stderr)
377 dup2(2, 1);
378 else if (need_out) {
379 dup2(fdout[1], 1);
380 close_pair(fdout);
381 } else if (cmd->out > 1) {
382 dup2(cmd->out, 1);
383 close(cmd->out);
386 if (cmd->dir && chdir(cmd->dir))
387 die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
388 cmd->dir);
389 if (cmd->env) {
390 for (; *cmd->env; cmd->env++) {
391 if (strchr(*cmd->env, '='))
392 putenv((char *)*cmd->env);
393 else
394 unsetenv(*cmd->env);
397 if (cmd->preexec_cb) {
399 * We cannot predict what the pre-exec callback does.
400 * Forgo parent notification.
402 close(child_notifier);
403 child_notifier = -1;
405 cmd->preexec_cb();
407 if (cmd->git_cmd) {
408 execv_git_cmd(cmd->argv);
409 } else if (cmd->use_shell) {
410 execv_shell_cmd(cmd->argv);
411 } else {
412 sane_execvp(cmd->argv[0], (char *const*) cmd->argv);
414 if (errno == ENOENT) {
415 if (!cmd->silent_exec_failure)
416 error("cannot run %s: %s", cmd->argv[0],
417 strerror(ENOENT));
418 exit(127);
419 } else {
420 die_errno("cannot exec '%s'", cmd->argv[0]);
423 if (cmd->pid < 0)
424 error("cannot fork() for %s: %s", cmd->argv[0],
425 strerror(failed_errno = errno));
426 else if (cmd->clean_on_exit)
427 mark_child_for_cleanup(cmd->pid);
430 * Wait for child's execvp. If the execvp succeeds (or if fork()
431 * failed), EOF is seen immediately by the parent. Otherwise, the
432 * child process sends a single byte.
433 * Note that use of this infrastructure is completely advisory,
434 * therefore, we keep error checks minimal.
436 close(notify_pipe[1]);
437 if (read(notify_pipe[0], &notify_pipe[1], 1) == 1) {
439 * At this point we know that fork() succeeded, but execvp()
440 * failed. Errors have been reported to our stderr.
442 wait_or_whine(cmd->pid, cmd->argv[0],
443 cmd->silent_exec_failure);
444 failed_errno = errno;
445 cmd->pid = -1;
447 close(notify_pipe[0]);
450 #else
452 int fhin = 0, fhout = 1, fherr = 2;
453 const char **sargv = cmd->argv;
455 if (cmd->no_stdin)
456 fhin = open("/dev/null", O_RDWR);
457 else if (need_in)
458 fhin = dup(fdin[0]);
459 else if (cmd->in)
460 fhin = dup(cmd->in);
462 if (cmd->no_stderr)
463 fherr = open("/dev/null", O_RDWR);
464 else if (need_err)
465 fherr = dup(fderr[1]);
466 else if (cmd->err > 2)
467 fherr = dup(cmd->err);
469 if (cmd->no_stdout)
470 fhout = open("/dev/null", O_RDWR);
471 else if (cmd->stdout_to_stderr)
472 fhout = dup(fherr);
473 else if (need_out)
474 fhout = dup(fdout[1]);
475 else if (cmd->out > 1)
476 fhout = dup(cmd->out);
478 if (cmd->git_cmd) {
479 cmd->argv = prepare_git_cmd(cmd->argv);
480 } else if (cmd->use_shell) {
481 cmd->argv = prepare_shell_cmd(cmd->argv);
484 cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, (char**) cmd->env,
485 cmd->dir, fhin, fhout, fherr);
486 failed_errno = errno;
487 if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
488 error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));
489 if (cmd->clean_on_exit && cmd->pid >= 0)
490 mark_child_for_cleanup(cmd->pid);
492 if (cmd->git_cmd)
493 free(cmd->argv);
495 cmd->argv = sargv;
496 if (fhin != 0)
497 close(fhin);
498 if (fhout != 1)
499 close(fhout);
500 if (fherr != 2)
501 close(fherr);
503 #endif
505 if (cmd->pid < 0) {
506 if (need_in)
507 close_pair(fdin);
508 else if (cmd->in)
509 close(cmd->in);
510 if (need_out)
511 close_pair(fdout);
512 else if (cmd->out)
513 close(cmd->out);
514 if (need_err)
515 close_pair(fderr);
516 else if (cmd->err)
517 close(cmd->err);
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 return wait_or_whine(cmd->pid, cmd->argv[0], cmd->silent_exec_failure);
545 int run_command(struct child_process *cmd)
547 int code = start_command(cmd);
548 if (code)
549 return code;
550 return finish_command(cmd);
553 static void prepare_run_command_v_opt(struct child_process *cmd,
554 const char **argv,
555 int opt)
557 memset(cmd, 0, sizeof(*cmd));
558 cmd->argv = argv;
559 cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
560 cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
561 cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
562 cmd->silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
563 cmd->use_shell = opt & RUN_USING_SHELL ? 1 : 0;
564 cmd->clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
567 int run_command_v_opt(const char **argv, int opt)
569 struct child_process cmd;
570 prepare_run_command_v_opt(&cmd, argv, opt);
571 return run_command(&cmd);
574 int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
576 struct child_process cmd;
577 prepare_run_command_v_opt(&cmd, argv, opt);
578 cmd.dir = dir;
579 cmd.env = env;
580 return run_command(&cmd);
583 #ifndef NO_PTHREADS
584 static pthread_t main_thread;
585 static int main_thread_set;
586 static pthread_key_t async_key;
588 static void *run_thread(void *data)
590 struct async *async = data;
591 intptr_t ret;
593 pthread_setspecific(async_key, async);
594 ret = async->proc(async->proc_in, async->proc_out, async->data);
595 return (void *)ret;
598 static NORETURN void die_async(const char *err, va_list params)
600 vreportf("fatal: ", err, params);
602 if (!pthread_equal(main_thread, pthread_self())) {
603 struct async *async = pthread_getspecific(async_key);
604 if (async->proc_in >= 0)
605 close(async->proc_in);
606 if (async->proc_out >= 0)
607 close(async->proc_out);
608 pthread_exit((void *)128);
611 exit(128);
613 #endif
615 int start_async(struct async *async)
617 int need_in, need_out;
618 int fdin[2], fdout[2];
619 int proc_in, proc_out;
621 need_in = async->in < 0;
622 if (need_in) {
623 if (pipe(fdin) < 0) {
624 if (async->out > 0)
625 close(async->out);
626 return error("cannot create pipe: %s", strerror(errno));
628 async->in = fdin[1];
631 need_out = async->out < 0;
632 if (need_out) {
633 if (pipe(fdout) < 0) {
634 if (need_in)
635 close_pair(fdin);
636 else if (async->in)
637 close(async->in);
638 return error("cannot create pipe: %s", strerror(errno));
640 async->out = fdout[0];
643 if (need_in)
644 proc_in = fdin[0];
645 else if (async->in)
646 proc_in = async->in;
647 else
648 proc_in = -1;
650 if (need_out)
651 proc_out = fdout[1];
652 else if (async->out)
653 proc_out = async->out;
654 else
655 proc_out = -1;
657 #ifdef NO_PTHREADS
658 /* Flush stdio before fork() to avoid cloning buffers */
659 fflush(NULL);
661 async->pid = fork();
662 if (async->pid < 0) {
663 error("fork (async) failed: %s", strerror(errno));
664 goto error;
666 if (!async->pid) {
667 if (need_in)
668 close(fdin[1]);
669 if (need_out)
670 close(fdout[0]);
671 exit(!!async->proc(proc_in, proc_out, async->data));
674 mark_child_for_cleanup(async->pid);
676 if (need_in)
677 close(fdin[0]);
678 else if (async->in)
679 close(async->in);
681 if (need_out)
682 close(fdout[1]);
683 else if (async->out)
684 close(async->out);
685 #else
686 if (!main_thread_set) {
688 * We assume that the first time that start_async is called
689 * it is from the main thread.
691 main_thread_set = 1;
692 main_thread = pthread_self();
693 pthread_key_create(&async_key, NULL);
694 set_die_routine(die_async);
697 if (proc_in >= 0)
698 set_cloexec(proc_in);
699 if (proc_out >= 0)
700 set_cloexec(proc_out);
701 async->proc_in = proc_in;
702 async->proc_out = proc_out;
704 int err = pthread_create(&async->tid, NULL, run_thread, async);
705 if (err) {
706 error("cannot create thread: %s", strerror(err));
707 goto error;
710 #endif
711 return 0;
713 error:
714 if (need_in)
715 close_pair(fdin);
716 else if (async->in)
717 close(async->in);
719 if (need_out)
720 close_pair(fdout);
721 else if (async->out)
722 close(async->out);
723 return -1;
726 int finish_async(struct async *async)
728 #ifdef NO_PTHREADS
729 return wait_or_whine(async->pid, "child process", 0);
730 #else
731 void *ret = (void *)(intptr_t)(-1);
733 if (pthread_join(async->tid, &ret))
734 error("pthread_join failed");
735 return (int)(intptr_t)ret;
736 #endif
739 int run_hook(const char *index_file, const char *name, ...)
741 struct child_process hook;
742 struct argv_array argv = ARGV_ARRAY_INIT;
743 const char *p, *env[2];
744 char index[PATH_MAX];
745 va_list args;
746 int ret;
748 if (access(git_path("hooks/%s", name), X_OK) < 0)
749 return 0;
751 va_start(args, name);
752 argv_array_push(&argv, git_path("hooks/%s", name));
753 while ((p = va_arg(args, const char *)))
754 argv_array_push(&argv, p);
755 va_end(args);
757 memset(&hook, 0, sizeof(hook));
758 hook.argv = argv.argv;
759 hook.no_stdin = 1;
760 hook.stdout_to_stderr = 1;
761 if (index_file) {
762 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
763 env[0] = index;
764 env[1] = NULL;
765 hook.env = env;
768 ret = run_command(&hook);
769 argv_array_clear(&argv);
770 return ret;