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