2 #include "run-command.h"
5 static inline void close_pair(int fd
[2])
11 static inline void dup_devnull(int to
)
13 int fd
= open("/dev/null", O_RDWR
);
18 int start_command(struct child_process
*cmd
)
20 int need_in
, need_out
, need_err
;
21 int fdin
[2], fdout
[2], fderr
[2];
25 * In case of errors we must keep the promise to close FDs
26 * that have been passed in via ->in and ->out.
29 need_in
= !cmd
->no_stdin
&& cmd
->in
< 0;
40 need_out
= !cmd
->no_stdout
41 && !cmd
->stdout_to_stderr
44 if (pipe(fdout
) < 0) {
55 need_err
= !cmd
->no_stderr
&& cmd
->err
< 0;
57 if (pipe(fderr
) < 0) {
68 error("cannot create pipe for %s: %s",
69 cmd
->argv
[0], strerror(failed_errno
));
76 trace_argv_printf(cmd
->argv
, "trace: run_command:");
101 else if (cmd
->stdout_to_stderr
)
106 } else if (cmd
->out
> 1) {
111 if (cmd
->dir
&& chdir(cmd
->dir
))
112 die("exec %s: cd to %s failed (%s)", cmd
->argv
[0],
113 cmd
->dir
, strerror(errno
));
115 for (; *cmd
->env
; cmd
->env
++) {
116 if (strchr(*cmd
->env
, '='))
117 putenv((char *)*cmd
->env
);
125 execv_git_cmd(cmd
->argv
);
127 execvp(cmd
->argv
[0], (char *const*) cmd
->argv
);
129 trace_printf("trace: exec '%s' failed: %s\n", cmd
->argv
[0],
134 error("cannot fork() for %s: %s", cmd
->argv
[0],
135 strerror(failed_errno
= errno
));
137 int s0
= -1, s1
= -1, s2
= -1; /* backups of stdin, stdout, stderr */
138 const char **sargv
= cmd
->argv
;
139 char **env
= environ
;
144 } else if (need_in
) {
147 } else if (cmd
->in
) {
152 if (cmd
->no_stderr
) {
155 } else if (need_err
) {
160 if (cmd
->no_stdout
) {
163 } else if (cmd
->stdout_to_stderr
) {
166 } else if (need_out
) {
169 } else if (cmd
->out
> 1) {
175 die("chdir in start_command() not implemented");
177 env
= copy_environ();
178 for (; *cmd
->env
; cmd
->env
++)
179 env
= env_setenv(env
, *cmd
->env
);
183 cmd
->argv
= prepare_git_cmd(cmd
->argv
);
186 cmd
->pid
= mingw_spawnvpe(cmd
->argv
[0], cmd
->argv
, env
);
187 failed_errno
= errno
;
188 if (cmd
->pid
< 0 && errno
!= ENOENT
)
189 error("cannot spawn %s: %s", cmd
->argv
[0], strerror(errno
));
198 dup2(s0
, 0), close(s0
);
200 dup2(s1
, 1), close(s1
);
202 dup2(s2
, 2), close(s2
);
216 errno
= failed_errno
;
236 static int wait_or_whine(pid_t pid
, const char *argv0
)
238 int status
, code
= -1;
240 int failed_errno
= 0;
242 while ((waiting
= waitpid(pid
, &status
, 0)) < 0 && errno
== EINTR
)
246 failed_errno
= errno
;
247 error("waitpid for %s failed: %s", argv0
, strerror(errno
));
248 } else if (waiting
!= pid
) {
249 error("waitpid is confused (%s)", argv0
);
250 } else if (WIFSIGNALED(status
)) {
251 error("%s died of signal", argv0
);
252 } else if (WIFEXITED(status
)) {
253 code
= WEXITSTATUS(status
);
255 * Convert special exit code when execvp failed.
259 failed_errno
= ENOENT
;
262 error("waitpid is confused (%s)", argv0
);
264 errno
= failed_errno
;
268 int finish_command(struct child_process
*cmd
)
270 return wait_or_whine(cmd
->pid
, cmd
->argv
[0]);
273 int run_command(struct child_process
*cmd
)
275 int code
= start_command(cmd
);
278 return finish_command(cmd
);
281 static void prepare_run_command_v_opt(struct child_process
*cmd
,
285 memset(cmd
, 0, sizeof(*cmd
));
287 cmd
->no_stdin
= opt
& RUN_COMMAND_NO_STDIN
? 1 : 0;
288 cmd
->git_cmd
= opt
& RUN_GIT_CMD
? 1 : 0;
289 cmd
->stdout_to_stderr
= opt
& RUN_COMMAND_STDOUT_TO_STDERR
? 1 : 0;
292 int run_command_v_opt(const char **argv
, int opt
)
294 struct child_process cmd
;
295 prepare_run_command_v_opt(&cmd
, argv
, opt
);
296 return run_command(&cmd
);
299 int run_command_v_opt_cd_env(const char **argv
, int opt
, const char *dir
, const char *const *env
)
301 struct child_process cmd
;
302 prepare_run_command_v_opt(&cmd
, argv
, opt
);
305 return run_command(&cmd
);
309 static __stdcall
unsigned run_thread(void *data
)
311 struct async
*async
= data
;
312 return async
->proc(async
->fd_for_proc
, async
->data
);
316 int start_async(struct async
*async
)
320 if (pipe(pipe_out
) < 0)
321 return error("cannot create pipe: %s", strerror(errno
));
322 async
->out
= pipe_out
[0];
325 /* Flush stdio before fork() to avoid cloning buffers */
329 if (async
->pid
< 0) {
330 error("fork (async) failed: %s", strerror(errno
));
331 close_pair(pipe_out
);
336 exit(!!async
->proc(pipe_out
[1], async
->data
));
340 async
->fd_for_proc
= pipe_out
[1];
341 async
->tid
= (HANDLE
) _beginthreadex(NULL
, 0, run_thread
, async
, 0, NULL
);
343 error("cannot create thread: %s", strerror(errno
));
344 close_pair(pipe_out
);
351 int finish_async(struct async
*async
)
354 int ret
= wait_or_whine(async
->pid
, "child process");
357 if (WaitForSingleObject(async
->tid
, INFINITE
) != WAIT_OBJECT_0
)
358 ret
= error("waiting for thread failed: %lu", GetLastError());
359 else if (!GetExitCodeThread(async
->tid
, &ret
))
360 ret
= error("cannot get thread exit code: %lu", GetLastError());
361 CloseHandle(async
->tid
);
366 int run_hook(const char *index_file
, const char *name
, ...)
368 struct child_process hook
;
369 const char **argv
= NULL
, *env
[2];
370 char index
[PATH_MAX
];
373 size_t i
= 0, alloc
= 0;
375 if (access(git_path("hooks/%s", name
), X_OK
) < 0)
378 va_start(args
, name
);
379 ALLOC_GROW(argv
, i
+ 1, alloc
);
380 argv
[i
++] = git_path("hooks/%s", name
);
382 ALLOC_GROW(argv
, i
+ 1, alloc
);
383 argv
[i
++] = va_arg(args
, const char *);
387 memset(&hook
, 0, sizeof(hook
));
390 hook
.stdout_to_stderr
= 1;
392 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
398 ret
= run_command(&hook
);