2 #include "run-command.h"
5 static inline void close_pair(int fd
[2])
12 static inline void dup_devnull(int to
)
14 int fd
= open("/dev/null", O_RDWR
);
20 int start_command(struct child_process
*cmd
)
22 int need_in
, need_out
, need_err
;
23 int fdin
[2], fdout
[2], fderr
[2];
24 int failed_errno
= failed_errno
;
27 * In case of errors we must keep the promise to close FDs
28 * that have been passed in via ->in and ->out.
31 need_in
= !cmd
->no_stdin
&& cmd
->in
< 0;
42 need_out
= !cmd
->no_stdout
43 && !cmd
->stdout_to_stderr
46 if (pipe(fdout
) < 0) {
57 need_err
= !cmd
->no_stderr
&& cmd
->err
< 0;
59 if (pipe(fderr
) < 0) {
70 error("cannot create pipe for %s: %s",
71 cmd
->argv
[0], strerror(failed_errno
));
78 trace_argv_printf(cmd
->argv
, "trace: run_command:");
103 else if (cmd
->stdout_to_stderr
)
108 } else if (cmd
->out
> 1) {
113 if (cmd
->dir
&& chdir(cmd
->dir
))
114 die_errno("exec '%s': cd to '%s' failed", cmd
->argv
[0],
117 for (; *cmd
->env
; cmd
->env
++) {
118 if (strchr(*cmd
->env
, '='))
119 putenv((char *)*cmd
->env
);
127 execv_git_cmd(cmd
->argv
);
129 execvp(cmd
->argv
[0], (char *const*) cmd
->argv
);
131 trace_printf("trace: exec '%s' failed: %s\n", cmd
->argv
[0],
136 error("cannot fork() for %s: %s", cmd
->argv
[0],
137 strerror(failed_errno
= errno
));
140 int fhin
= 0, fhout
= 1, fherr
= 2;
141 const char **sargv
= cmd
->argv
;
142 char **env
= environ
;
145 fhin
= open("/dev/null", O_RDWR
);
152 fherr
= open("/dev/null", O_RDWR
);
154 fherr
= dup(fderr
[1]);
157 fhout
= open("/dev/null", O_RDWR
);
158 else if (cmd
->stdout_to_stderr
)
161 fhout
= dup(fdout
[1]);
162 else if (cmd
->out
> 1)
163 fhout
= dup(cmd
->out
);
166 die("chdir in start_command() not implemented");
168 env
= make_augmented_environ(cmd
->env
);
171 cmd
->argv
= prepare_git_cmd(cmd
->argv
);
174 cmd
->pid
= mingw_spawnvpe(cmd
->argv
[0], cmd
->argv
, env
,
176 failed_errno
= errno
;
177 if (cmd
->pid
< 0 && (!cmd
->silent_exec_failure
|| errno
!= ENOENT
))
178 error("cannot spawn %s: %s", cmd
->argv
[0], strerror(errno
));
206 errno
= failed_errno
;
226 static int wait_or_whine(pid_t pid
, const char *argv0
, int silent_exec_failure
)
228 int status
, code
= -1;
230 int failed_errno
= 0;
232 while ((waiting
= waitpid(pid
, &status
, 0)) < 0 && errno
== EINTR
)
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.
249 } else if (WIFEXITED(status
)) {
250 code
= WEXITSTATUS(status
);
252 * Convert special exit code when execvp failed.
256 failed_errno
= ENOENT
;
257 if (!silent_exec_failure
)
258 error("cannot run %s: %s", argv0
,
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], cmd
->silent_exec_failure
);
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;
290 cmd
->silent_exec_failure
= opt
& RUN_SILENT_EXEC_FAILURE
? 1 : 0;
293 int run_command_v_opt(const char **argv
, int opt
)
295 struct child_process cmd
;
296 prepare_run_command_v_opt(&cmd
, argv
, opt
);
297 return run_command(&cmd
);
300 int run_command_v_opt_cd_env(const char **argv
, int opt
, const char *dir
, const char *const *env
)
302 struct child_process cmd
;
303 prepare_run_command_v_opt(&cmd
, argv
, opt
);
306 return run_command(&cmd
);
310 static unsigned __stdcall
run_thread(void *data
)
312 struct async
*async
= data
;
313 return async
->proc(async
->fd_for_proc
, async
->data
);
317 int start_async(struct async
*async
)
321 if (pipe(pipe_out
) < 0)
322 return error("cannot create pipe: %s", strerror(errno
));
323 async
->out
= pipe_out
[0];
326 /* Flush stdio before fork() to avoid cloning buffers */
330 if (async
->pid
< 0) {
331 error("fork (async) failed: %s", strerror(errno
));
332 close_pair(pipe_out
);
337 exit(!!async
->proc(pipe_out
[1], async
->data
));
341 async
->fd_for_proc
= pipe_out
[1];
342 async
->tid
= (HANDLE
) _beginthreadex(NULL
, 0, run_thread
, async
, 0, NULL
);
344 error("cannot create thread: %s", strerror(errno
));
345 close_pair(pipe_out
);
352 int finish_async(struct async
*async
)
355 int ret
= wait_or_whine(async
->pid
, "child process", 0);
358 if (WaitForSingleObject(async
->tid
, INFINITE
) != WAIT_OBJECT_0
)
359 ret
= error("waiting for thread failed: %lu", GetLastError());
360 else if (!GetExitCodeThread(async
->tid
, &ret
))
361 ret
= error("cannot get thread exit code: %lu", GetLastError());
362 CloseHandle(async
->tid
);
367 int run_hook(const char *index_file
, const char *name
, ...)
369 struct child_process hook
;
370 const char **argv
= NULL
, *env
[2];
371 char index
[PATH_MAX
];
374 size_t i
= 0, alloc
= 0;
376 if (access(git_path("hooks/%s", name
), X_OK
) < 0)
379 va_start(args
, name
);
380 ALLOC_GROW(argv
, i
+ 1, alloc
);
381 argv
[i
++] = git_path("hooks/%s", name
);
383 ALLOC_GROW(argv
, i
+ 1, alloc
);
384 argv
[i
++] = va_arg(args
, const char *);
388 memset(&hook
, 0, sizeof(hook
));
391 hook
.stdout_to_stderr
= 1;
393 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
399 ret
= run_command(&hook
);