1 #include <unistd.h>
2 #include <sys/types.h>
3 #include <sys/stat.h>
4 #include <fcntl.h>
5 #include <string.h>
6 #include <linux/string.h>
7 #include <errno.h>
8 #include <sys/wait.h>
9 #include "subcmd-util.h"
10 #include "run-command.h"
11 #include "exec-cmd.h"
12
13 #define STRERR_BUFSIZE 128
14
close_pair(int fd[2])15 static inline void close_pair(int fd[2])
16 {
17 close(fd[0]);
18 close(fd[1]);
19 }
20
dup_devnull(int to)21 static inline void dup_devnull(int to)
22 {
23 int fd = open("/dev/null", O_RDWR);
24 dup2(fd, to);
25 close(fd);
26 }
27
start_command(struct child_process * cmd)28 int start_command(struct child_process *cmd)
29 {
30 int need_in, need_out, need_err;
31 int fdin[2], fdout[2], fderr[2];
32 char sbuf[STRERR_BUFSIZE];
33
34 /*
35 * In case of errors we must keep the promise to close FDs
36 * that have been passed in via ->in and ->out.
37 */
38
39 need_in = !cmd->no_stdin && cmd->in < 0;
40 if (need_in) {
41 if (pipe(fdin) < 0) {
42 if (cmd->out > 0)
43 close(cmd->out);
44 return -ERR_RUN_COMMAND_PIPE;
45 }
46 cmd->in = fdin[1];
47 }
48
49 need_out = !cmd->no_stdout
50 && !cmd->stdout_to_stderr
51 && cmd->out < 0;
52 if (need_out) {
53 if (pipe(fdout) < 0) {
54 if (need_in)
55 close_pair(fdin);
56 else if (cmd->in)
57 close(cmd->in);
58 return -ERR_RUN_COMMAND_PIPE;
59 }
60 cmd->out = fdout[0];
61 }
62
63 need_err = !cmd->no_stderr && cmd->err < 0;
64 if (need_err) {
65 if (pipe(fderr) < 0) {
66 if (need_in)
67 close_pair(fdin);
68 else if (cmd->in)
69 close(cmd->in);
70 if (need_out)
71 close_pair(fdout);
72 else if (cmd->out)
73 close(cmd->out);
74 return -ERR_RUN_COMMAND_PIPE;
75 }
76 cmd->err = fderr[0];
77 }
78
79 fflush(NULL);
80 cmd->pid = fork();
81 if (!cmd->pid) {
82 if (cmd->no_stdin)
83 dup_devnull(0);
84 else if (need_in) {
85 dup2(fdin[0], 0);
86 close_pair(fdin);
87 } else if (cmd->in) {
88 dup2(cmd->in, 0);
89 close(cmd->in);
90 }
91
92 if (cmd->no_stderr)
93 dup_devnull(2);
94 else if (need_err) {
95 dup2(fderr[1], 2);
96 close_pair(fderr);
97 }
98
99 if (cmd->no_stdout)
100 dup_devnull(1);
101 else if (cmd->stdout_to_stderr)
102 dup2(2, 1);
103 else if (need_out) {
104 dup2(fdout[1], 1);
105 close_pair(fdout);
106 } else if (cmd->out > 1) {
107 dup2(cmd->out, 1);
108 close(cmd->out);
109 }
110
111 if (cmd->dir && chdir(cmd->dir))
112 die("exec %s: cd to %s failed (%s)", cmd->argv[0],
113 cmd->dir, str_error_r(errno, sbuf, sizeof(sbuf)));
114 if (cmd->env) {
115 for (; *cmd->env; cmd->env++) {
116 if (strchr(*cmd->env, '='))
117 putenv((char*)*cmd->env);
118 else
119 unsetenv(*cmd->env);
120 }
121 }
122 if (cmd->preexec_cb)
123 cmd->preexec_cb();
124 if (cmd->exec_cmd) {
125 execv_cmd(cmd->argv);
126 } else {
127 execvp(cmd->argv[0], (char *const*) cmd->argv);
128 }
129 exit(127);
130 }
131
132 if (cmd->pid < 0) {
133 int err = errno;
134 if (need_in)
135 close_pair(fdin);
136 else if (cmd->in)
137 close(cmd->in);
138 if (need_out)
139 close_pair(fdout);
140 else if (cmd->out)
141 close(cmd->out);
142 if (need_err)
143 close_pair(fderr);
144 return err == ENOENT ?
145 -ERR_RUN_COMMAND_EXEC :
146 -ERR_RUN_COMMAND_FORK;
147 }
148
149 if (need_in)
150 close(fdin[0]);
151 else if (cmd->in)
152 close(cmd->in);
153
154 if (need_out)
155 close(fdout[1]);
156 else if (cmd->out)
157 close(cmd->out);
158
159 if (need_err)
160 close(fderr[1]);
161
162 return 0;
163 }
164
wait_or_whine(pid_t pid)165 static int wait_or_whine(pid_t pid)
166 {
167 char sbuf[STRERR_BUFSIZE];
168
169 for (;;) {
170 int status, code;
171 pid_t waiting = waitpid(pid, &status, 0);
172
173 if (waiting < 0) {
174 if (errno == EINTR)
175 continue;
176 fprintf(stderr, " Error: waitpid failed (%s)",
177 str_error_r(errno, sbuf, sizeof(sbuf)));
178 return -ERR_RUN_COMMAND_WAITPID;
179 }
180 if (waiting != pid)
181 return -ERR_RUN_COMMAND_WAITPID_WRONG_PID;
182 if (WIFSIGNALED(status))
183 return -ERR_RUN_COMMAND_WAITPID_SIGNAL;
184
185 if (!WIFEXITED(status))
186 return -ERR_RUN_COMMAND_WAITPID_NOEXIT;
187 code = WEXITSTATUS(status);
188 switch (code) {
189 case 127:
190 return -ERR_RUN_COMMAND_EXEC;
191 case 0:
192 return 0;
193 default:
194 return -code;
195 }
196 }
197 }
198
finish_command(struct child_process * cmd)199 int finish_command(struct child_process *cmd)
200 {
201 return wait_or_whine(cmd->pid);
202 }
203
run_command(struct child_process * cmd)204 int run_command(struct child_process *cmd)
205 {
206 int code = start_command(cmd);
207 if (code)
208 return code;
209 return finish_command(cmd);
210 }
211
prepare_run_command_v_opt(struct child_process * cmd,const char ** argv,int opt)212 static void prepare_run_command_v_opt(struct child_process *cmd,
213 const char **argv,
214 int opt)
215 {
216 memset(cmd, 0, sizeof(*cmd));
217 cmd->argv = argv;
218 cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
219 cmd->exec_cmd = opt & RUN_EXEC_CMD ? 1 : 0;
220 cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
221 }
222
run_command_v_opt(const char ** argv,int opt)223 int run_command_v_opt(const char **argv, int opt)
224 {
225 struct child_process cmd;
226 prepare_run_command_v_opt(&cmd, argv, opt);
227 return run_command(&cmd);
228 }
229