Rename the test trash directory to contain spaces.
[git/bdonlan.git] / run-command.c
blob44100a749b09439121073e32e7a3143b54185d31
1 #include "cache.h"
2 #include "run-command.h"
3 #include "exec_cmd.h"
5 static inline void close_pair(int fd[2])
7 close(fd[0]);
8 close(fd[1]);
11 static inline void dup_devnull(int to)
13 int fd = open("/dev/null", O_RDWR);
14 dup2(fd, to);
15 close(fd);
18 int start_command(struct child_process *cmd)
20 int need_in, need_out, need_err;
21 int fdin[2], fdout[2], fderr[2];
24 * In case of errors we must keep the promise to close FDs
25 * that have been passed in via ->in and ->out.
28 need_in = !cmd->no_stdin && cmd->in < 0;
29 if (need_in) {
30 if (pipe(fdin) < 0) {
31 if (cmd->out > 0)
32 close(cmd->out);
33 return -ERR_RUN_COMMAND_PIPE;
35 cmd->in = fdin[1];
38 need_out = !cmd->no_stdout
39 && !cmd->stdout_to_stderr
40 && cmd->out < 0;
41 if (need_out) {
42 if (pipe(fdout) < 0) {
43 if (need_in)
44 close_pair(fdin);
45 else if (cmd->in)
46 close(cmd->in);
47 return -ERR_RUN_COMMAND_PIPE;
49 cmd->out = fdout[0];
52 need_err = !cmd->no_stderr && cmd->err < 0;
53 if (need_err) {
54 if (pipe(fderr) < 0) {
55 if (need_in)
56 close_pair(fdin);
57 else if (cmd->in)
58 close(cmd->in);
59 if (need_out)
60 close_pair(fdout);
61 else if (cmd->out)
62 close(cmd->out);
63 return -ERR_RUN_COMMAND_PIPE;
65 cmd->err = fderr[0];
68 cmd->pid = fork();
69 if (cmd->pid < 0) {
70 if (need_in)
71 close_pair(fdin);
72 else if (cmd->in)
73 close(cmd->in);
74 if (need_out)
75 close_pair(fdout);
76 else if (cmd->out)
77 close(cmd->out);
78 if (need_err)
79 close_pair(fderr);
80 return -ERR_RUN_COMMAND_FORK;
83 if (!cmd->pid) {
84 if (cmd->no_stdin)
85 dup_devnull(0);
86 else if (need_in) {
87 dup2(fdin[0], 0);
88 close_pair(fdin);
89 } else if (cmd->in) {
90 dup2(cmd->in, 0);
91 close(cmd->in);
94 if (cmd->no_stderr)
95 dup_devnull(2);
96 else if (need_err) {
97 dup2(fderr[1], 2);
98 close_pair(fderr);
101 if (cmd->no_stdout)
102 dup_devnull(1);
103 else if (cmd->stdout_to_stderr)
104 dup2(2, 1);
105 else if (need_out) {
106 dup2(fdout[1], 1);
107 close_pair(fdout);
108 } else if (cmd->out > 1) {
109 dup2(cmd->out, 1);
110 close(cmd->out);
113 if (cmd->dir && chdir(cmd->dir))
114 die("exec %s: cd to %s failed (%s)", cmd->argv[0],
115 cmd->dir, strerror(errno));
116 if (cmd->env) {
117 for (; *cmd->env; cmd->env++) {
118 if (strchr(*cmd->env, '='))
119 putenv((char*)*cmd->env);
120 else
121 unsetenv(*cmd->env);
124 if (cmd->git_cmd) {
125 execv_git_cmd(cmd->argv);
126 } else {
127 execvp(cmd->argv[0], (char *const*) cmd->argv);
129 die("exec %s failed.", cmd->argv[0]);
132 if (need_in)
133 close(fdin[0]);
134 else if (cmd->in)
135 close(cmd->in);
137 if (need_out)
138 close(fdout[1]);
139 else if (cmd->out)
140 close(cmd->out);
142 if (need_err)
143 close(fderr[1]);
145 return 0;
148 static int wait_or_whine(pid_t pid)
150 for (;;) {
151 int status, code;
152 pid_t waiting = waitpid(pid, &status, 0);
154 if (waiting < 0) {
155 if (errno == EINTR)
156 continue;
157 error("waitpid failed (%s)", strerror(errno));
158 return -ERR_RUN_COMMAND_WAITPID;
160 if (waiting != pid)
161 return -ERR_RUN_COMMAND_WAITPID_WRONG_PID;
162 if (WIFSIGNALED(status))
163 return -ERR_RUN_COMMAND_WAITPID_SIGNAL;
165 if (!WIFEXITED(status))
166 return -ERR_RUN_COMMAND_WAITPID_NOEXIT;
167 code = WEXITSTATUS(status);
168 if (code)
169 return -code;
170 return 0;
174 int finish_command(struct child_process *cmd)
176 return wait_or_whine(cmd->pid);
179 int run_command(struct child_process *cmd)
181 int code = start_command(cmd);
182 if (code)
183 return code;
184 return finish_command(cmd);
187 static void prepare_run_command_v_opt(struct child_process *cmd,
188 const char **argv,
189 int opt)
191 memset(cmd, 0, sizeof(*cmd));
192 cmd->argv = argv;
193 cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
194 cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
195 cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
198 int run_command_v_opt(const char **argv, int opt)
200 struct child_process cmd;
201 prepare_run_command_v_opt(&cmd, argv, opt);
202 return run_command(&cmd);
205 int run_command_v_opt_cd(const char **argv, int opt, const char *dir)
207 struct child_process cmd;
208 prepare_run_command_v_opt(&cmd, argv, opt);
209 cmd.dir = dir;
210 return run_command(&cmd);
213 int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
215 struct child_process cmd;
216 prepare_run_command_v_opt(&cmd, argv, opt);
217 cmd.dir = dir;
218 cmd.env = env;
219 return run_command(&cmd);
222 int start_async(struct async *async)
224 int pipe_out[2];
226 if (pipe(pipe_out) < 0)
227 return error("cannot create pipe: %s", strerror(errno));
229 async->pid = fork();
230 if (async->pid < 0) {
231 error("fork (async) failed: %s", strerror(errno));
232 close_pair(pipe_out);
233 return -1;
235 if (!async->pid) {
236 close(pipe_out[0]);
237 exit(!!async->proc(pipe_out[1], async->data));
239 async->out = pipe_out[0];
240 close(pipe_out[1]);
241 return 0;
244 int finish_async(struct async *async)
246 int ret = 0;
248 if (wait_or_whine(async->pid))
249 ret = error("waitpid (async) failed");
250 return ret;