Code

nicer display of thin pack completion
[git.git] / run-command.c
1 #include "cache.h"
2 #include "run-command.h"
3 #include "exec_cmd.h"
5 static inline void close_pair(int fd[2])
6 {
7         close(fd[0]);
8         close(fd[1]);
9 }
11 static inline void dup_devnull(int to)
12 {
13         int fd = open("/dev/null", O_RDWR);
14         dup2(fd, to);
15         close(fd);
16 }
18 int start_command(struct child_process *cmd)
19 {
20         int need_in, need_out, need_err;
21         int fdin[2], fdout[2], fderr[2];
23         need_in = !cmd->no_stdin && cmd->in < 0;
24         if (need_in) {
25                 if (pipe(fdin) < 0)
26                         return -ERR_RUN_COMMAND_PIPE;
27                 cmd->in = fdin[1];
28                 cmd->close_in = 1;
29         }
31         need_out = !cmd->no_stdout
32                 && !cmd->stdout_to_stderr
33                 && cmd->out < 0;
34         if (need_out) {
35                 if (pipe(fdout) < 0) {
36                         if (need_in)
37                                 close_pair(fdin);
38                         return -ERR_RUN_COMMAND_PIPE;
39                 }
40                 cmd->out = fdout[0];
41                 cmd->close_out = 1;
42         }
44         need_err = cmd->err < 0;
45         if (need_err) {
46                 if (pipe(fderr) < 0) {
47                         if (need_in)
48                                 close_pair(fdin);
49                         if (need_out)
50                                 close_pair(fdout);
51                         return -ERR_RUN_COMMAND_PIPE;
52                 }
53                 cmd->err = fderr[0];
54         }
56         cmd->pid = fork();
57         if (cmd->pid < 0) {
58                 if (need_in)
59                         close_pair(fdin);
60                 if (need_out)
61                         close_pair(fdout);
62                 if (need_err)
63                         close_pair(fderr);
64                 return -ERR_RUN_COMMAND_FORK;
65         }
67         if (!cmd->pid) {
68                 if (cmd->no_stdin)
69                         dup_devnull(0);
70                 else if (need_in) {
71                         dup2(fdin[0], 0);
72                         close_pair(fdin);
73                 } else if (cmd->in) {
74                         dup2(cmd->in, 0);
75                         close(cmd->in);
76                 }
78                 if (cmd->no_stdout)
79                         dup_devnull(1);
80                 else if (cmd->stdout_to_stderr)
81                         dup2(2, 1);
82                 else if (need_out) {
83                         dup2(fdout[1], 1);
84                         close_pair(fdout);
85                 } else if (cmd->out > 1) {
86                         dup2(cmd->out, 1);
87                         close(cmd->out);
88                 }
90                 if (need_err) {
91                         dup2(fderr[1], 2);
92                         close_pair(fderr);
93                 }
95                 if (cmd->dir && chdir(cmd->dir))
96                         die("exec %s: cd to %s failed (%s)", cmd->argv[0],
97                             cmd->dir, strerror(errno));
98                 if (cmd->env) {
99                         for (; *cmd->env; cmd->env++) {
100                                 if (strchr(*cmd->env, '='))
101                                         putenv((char*)*cmd->env);
102                                 else
103                                         unsetenv(*cmd->env);
104                         }
105                 }
106                 if (cmd->git_cmd) {
107                         execv_git_cmd(cmd->argv);
108                 } else {
109                         execvp(cmd->argv[0], (char *const*) cmd->argv);
110                 }
111                 die("exec %s failed.", cmd->argv[0]);
112         }
114         if (need_in)
115                 close(fdin[0]);
116         else if (cmd->in)
117                 close(cmd->in);
119         if (need_out)
120                 close(fdout[1]);
121         else if (cmd->out > 1)
122                 close(cmd->out);
124         if (need_err)
125                 close(fderr[1]);
127         return 0;
130 static int wait_or_whine(pid_t pid)
132         for (;;) {
133                 int status, code;
134                 pid_t waiting = waitpid(pid, &status, 0);
136                 if (waiting < 0) {
137                         if (errno == EINTR)
138                                 continue;
139                         error("waitpid failed (%s)", strerror(errno));
140                         return -ERR_RUN_COMMAND_WAITPID;
141                 }
142                 if (waiting != pid)
143                         return -ERR_RUN_COMMAND_WAITPID_WRONG_PID;
144                 if (WIFSIGNALED(status))
145                         return -ERR_RUN_COMMAND_WAITPID_SIGNAL;
147                 if (!WIFEXITED(status))
148                         return -ERR_RUN_COMMAND_WAITPID_NOEXIT;
149                 code = WEXITSTATUS(status);
150                 if (code)
151                         return -code;
152                 return 0;
153         }
156 int finish_command(struct child_process *cmd)
158         if (cmd->close_in)
159                 close(cmd->in);
160         if (cmd->close_out)
161                 close(cmd->out);
162         return wait_or_whine(cmd->pid);
165 int run_command(struct child_process *cmd)
167         int code = start_command(cmd);
168         if (code)
169                 return code;
170         return finish_command(cmd);
173 static void prepare_run_command_v_opt(struct child_process *cmd,
174                                       const char **argv,
175                                       int opt)
177         memset(cmd, 0, sizeof(*cmd));
178         cmd->argv = argv;
179         cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
180         cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
181         cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
184 int run_command_v_opt(const char **argv, int opt)
186         struct child_process cmd;
187         prepare_run_command_v_opt(&cmd, argv, opt);
188         return run_command(&cmd);
191 int run_command_v_opt_cd(const char **argv, int opt, const char *dir)
193         struct child_process cmd;
194         prepare_run_command_v_opt(&cmd, argv, opt);
195         cmd.dir = dir;
196         return run_command(&cmd);
199 int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
201         struct child_process cmd;
202         prepare_run_command_v_opt(&cmd, argv, opt);
203         cmd.dir = dir;
204         cmd.env = env;
205         return run_command(&cmd);
208 int start_async(struct async *async)
210         int pipe_out[2];
212         if (pipe(pipe_out) < 0)
213                 return error("cannot create pipe: %s", strerror(errno));
215         async->pid = fork();
216         if (async->pid < 0) {
217                 error("fork (async) failed: %s", strerror(errno));
218                 close_pair(pipe_out);
219                 return -1;
220         }
221         if (!async->pid) {
222                 close(pipe_out[0]);
223                 exit(!!async->proc(pipe_out[1], async->data));
224         }
225         async->out = pipe_out[0];
226         close(pipe_out[1]);
227         return 0;
230 int finish_async(struct async *async)
232         int ret = 0;
234         if (wait_or_whine(async->pid))
235                 ret = error("waitpid (async) failed");
236         return ret;