Docs gitk: Explicitly mention the files that gitk uses (~/.gitk)
[git] / run-command.c
1 #include "cache.h"
2 #include "run-command.h"
3 #include "exec_cmd.h"
4
5 static inline void close_pair(int fd[2])
6 {
7         close(fd[0]);
8         close(fd[1]);
9 }
10
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 }
17
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];
22
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         }
30
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         }
43
44         need_err = !cmd->no_stderr && 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         }
55
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         }
66
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                 }
77
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                 }
89
90                 if (cmd->no_stderr)
91                         dup_devnull(2);
92                 else if (need_err) {
93                         dup2(fderr[1], 2);
94                         close_pair(fderr);
95                 }
96
97                 if (cmd->dir && chdir(cmd->dir))
98                         die("exec %s: cd to %s failed (%s)", cmd->argv[0],
99                             cmd->dir, strerror(errno));
100                 if (cmd->env) {
101                         for (; *cmd->env; cmd->env++) {
102                                 if (strchr(*cmd->env, '='))
103                                         putenv((char*)*cmd->env);
104                                 else
105                                         unsetenv(*cmd->env);
106                         }
107                 }
108                 if (cmd->git_cmd) {
109                         execv_git_cmd(cmd->argv);
110                 } else {
111                         execvp(cmd->argv[0], (char *const*) cmd->argv);
112                 }
113                 die("exec %s failed.", cmd->argv[0]);
114         }
115
116         if (need_in)
117                 close(fdin[0]);
118         else if (cmd->in)
119                 close(cmd->in);
120
121         if (need_out)
122                 close(fdout[1]);
123         else if (cmd->out > 1)
124                 close(cmd->out);
125
126         if (need_err)
127                 close(fderr[1]);
128
129         return 0;
130 }
131
132 static int wait_or_whine(pid_t pid)
133 {
134         for (;;) {
135                 int status, code;
136                 pid_t waiting = waitpid(pid, &status, 0);
137
138                 if (waiting < 0) {
139                         if (errno == EINTR)
140                                 continue;
141                         error("waitpid failed (%s)", strerror(errno));
142                         return -ERR_RUN_COMMAND_WAITPID;
143                 }
144                 if (waiting != pid)
145                         return -ERR_RUN_COMMAND_WAITPID_WRONG_PID;
146                 if (WIFSIGNALED(status))
147                         return -ERR_RUN_COMMAND_WAITPID_SIGNAL;
148
149                 if (!WIFEXITED(status))
150                         return -ERR_RUN_COMMAND_WAITPID_NOEXIT;
151                 code = WEXITSTATUS(status);
152                 if (code)
153                         return -code;
154                 return 0;
155         }
156 }
157
158 int finish_command(struct child_process *cmd)
159 {
160         if (cmd->close_in)
161                 close(cmd->in);
162         if (cmd->close_out)
163                 close(cmd->out);
164         return wait_or_whine(cmd->pid);
165 }
166
167 int run_command(struct child_process *cmd)
168 {
169         int code = start_command(cmd);
170         if (code)
171                 return code;
172         return finish_command(cmd);
173 }
174
175 static void prepare_run_command_v_opt(struct child_process *cmd,
176                                       const char **argv,
177                                       int opt)
178 {
179         memset(cmd, 0, sizeof(*cmd));
180         cmd->argv = argv;
181         cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
182         cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
183         cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
184 }
185
186 int run_command_v_opt(const char **argv, int opt)
187 {
188         struct child_process cmd;
189         prepare_run_command_v_opt(&cmd, argv, opt);
190         return run_command(&cmd);
191 }
192
193 int run_command_v_opt_cd(const char **argv, int opt, const char *dir)
194 {
195         struct child_process cmd;
196         prepare_run_command_v_opt(&cmd, argv, opt);
197         cmd.dir = dir;
198         return run_command(&cmd);
199 }
200
201 int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
202 {
203         struct child_process cmd;
204         prepare_run_command_v_opt(&cmd, argv, opt);
205         cmd.dir = dir;
206         cmd.env = env;
207         return run_command(&cmd);
208 }
209
210 int start_async(struct async *async)
211 {
212         int pipe_out[2];
213
214         if (pipe(pipe_out) < 0)
215                 return error("cannot create pipe: %s", strerror(errno));
216
217         async->pid = fork();
218         if (async->pid < 0) {
219                 error("fork (async) failed: %s", strerror(errno));
220                 close_pair(pipe_out);
221                 return -1;
222         }
223         if (!async->pid) {
224                 close(pipe_out[0]);
225                 exit(!!async->proc(pipe_out[1], async->data));
226         }
227         async->out = pipe_out[0];
228         close(pipe_out[1]);
229         return 0;
230 }
231
232 int finish_async(struct async *async)
233 {
234         int ret = 0;
235
236         if (wait_or_whine(async->pid))
237                 ret = error("waitpid (async) failed");
238         return ret;
239 }