1 /* Creation of autonomous subprocesses. 2 Copyright (C) 2001-2004, 2006 Free Software Foundation, Inc. 3 Written by Bruno Haible <haible@clisp.cons.org>, 2001. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2, or (at your option) 8 any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software Foundation, 17 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ 18 19 20 #include <config.h> 21 22 /* Specification. */ 23 #include "execute.h" 24 25 #include <errno.h> 26 #include <fcntl.h> 27 #include <stdbool.h> 28 #include <stdlib.h> 29 #include <signal.h> 30 #include <unistd.h> 31 32 #include "error.h" 33 #include "exit.h" 34 #include "fatal-signal.h" 35 #include "wait-process.h" 36 #include "gettext.h" 37 38 #define _(str) gettext (str) 39 40 #if defined _MSC_VER || defined __MINGW32__ 41 42 /* Native Woe32 API. */ 43 # include <process.h> 44 # include "w32spawn.h" 45 46 #else 47 48 /* Unix API. */ 49 # ifdef HAVE_POSIX_SPAWN 50 # include <spawn.h> 51 # else 52 # ifdef HAVE_VFORK_H 53 # include <vfork.h> 54 # endif 55 # endif 56 57 #endif 58 59 #ifndef HAVE_ENVIRON_DECL 60 extern char **environ; 61 #endif 62 63 #ifndef STDIN_FILENO 64 # define STDIN_FILENO 0 65 #endif 66 #ifndef STDOUT_FILENO 67 # define STDOUT_FILENO 1 68 #endif 69 #ifndef STDERR_FILENO 70 # define STDERR_FILENO 2 71 #endif 72 73 74 #ifdef EINTR 75 76 /* EINTR handling for close(), open(). 77 These functions can return -1/EINTR even though we don't have any 78 signal handlers set up, namely when we get interrupted via SIGSTOP. */ 79 80 static inline int 81 nonintr_close (int fd) 82 { 83 int retval; 84 85 do 86 retval = close (fd); 87 while (retval < 0 && errno == EINTR); 88 89 return retval; 90 } 91 #define close nonintr_close 92 93 static inline int 94 nonintr_open (const char *pathname, int oflag, mode_t mode) 95 { 96 int retval; 97 98 do 99 retval = open (pathname, oflag, mode); 100 while (retval < 0 && errno == EINTR); 101 102 return retval; 103 } 104 #undef open /* avoid warning on VMS */ 105 #define open nonintr_open 106 107 #endif 108 109 110 /* Execute a command, optionally redirecting any of the three standard file 111 descriptors to /dev/null. Return its exit code. 112 If it didn't terminate correctly, exit if exit_on_error is true, otherwise 113 return 127. 114 If slave_process is true, the child process will be terminated when its 115 creator receives a catchable fatal signal. */ 116 int 117 execute (const char *progname, 118 const char *prog_path, char **prog_argv, 119 bool ignore_sigpipe, 120 bool null_stdin, bool null_stdout, bool null_stderr, 121 bool slave_process, bool exit_on_error) 122 { 123 #if defined _MSC_VER || defined __MINGW32__ 124 125 /* Native Woe32 API. */ 126 int orig_stdin; 127 int orig_stdout; 128 int orig_stderr; 129 int exitcode; 130 int nullinfd; 131 int nulloutfd; 132 133 prog_argv = prepare_spawn (prog_argv); 134 135 /* Save standard file handles of parent process. */ 136 if (null_stdin) 137 orig_stdin = dup_noinherit (STDIN_FILENO); 138 if (null_stdout) 139 orig_stdout = dup_noinherit (STDOUT_FILENO); 140 if (null_stderr) 141 orig_stderr = dup_noinherit (STDERR_FILENO); 142 exitcode = -1; 143 144 /* Create standard file handles of child process. */ 145 nullinfd = -1; 146 nulloutfd = -1; 147 if ((!null_stdin 148 || ((nullinfd = open ("NUL", O_RDONLY, 0)) >= 0 149 && (nullinfd == STDIN_FILENO 150 || (dup2 (nullinfd, STDIN_FILENO) >= 0 151 && close (nullinfd) >= 0)))) 152 && (!(null_stdout || null_stderr) 153 || ((nulloutfd = open ("NUL", O_RDWR, 0)) >= 0 154 && (!null_stdout 155 || nulloutfd == STDOUT_FILENO 156 || dup2 (nulloutfd, STDOUT_FILENO) >= 0) 157 && (!null_stderr 158 || nulloutfd == STDERR_FILENO 159 || dup2 (nulloutfd, STDERR_FILENO) >= 0) 160 && ((null_stdout && nulloutfd == STDOUT_FILENO) 161 || (null_stderr && nulloutfd == STDERR_FILENO) 162 || close (nulloutfd) >= 0)))) 163 exitcode = spawnvp (P_WAIT, prog_path, prog_argv); 164 if (nulloutfd >= 0) 165 close (nulloutfd); 166 if (nullinfd >= 0) 167 close (nullinfd); 168 169 /* Restore standard file handles of parent process. */ 170 if (null_stderr) 171 dup2 (orig_stderr, STDERR_FILENO), close (orig_stderr); 172 if (null_stdout) 173 dup2 (orig_stdout, STDOUT_FILENO), close (orig_stdout); 174 if (null_stdin) 175 dup2 (orig_stdin, STDIN_FILENO), close (orig_stdin); 176 177 if (exitcode == -1) 178 { 179 if (exit_on_error || !null_stderr) 180 error (exit_on_error ? EXIT_FAILURE : 0, errno, 181 _("%s subprocess failed"), progname); 182 return 127; 183 } 184 185 return exitcode; 186 187 #else 188 189 /* Unix API. */ 190 /* Note about 127: Some errors during posix_spawnp() cause the function 191 posix_spawnp() to return an error code; some other errors cause the 192 subprocess to exit with return code 127. It is implementation 193 dependent which error is reported which way. We treat both cases as 194 equivalent. */ 195 #if HAVE_POSIX_SPAWN 196 sigset_t blocked_signals; 197 posix_spawn_file_actions_t actions; 198 bool actions_allocated; 199 posix_spawnattr_t attrs; 200 bool attrs_allocated; 201 int err; 202 pid_t child; 203 #else 204 int child; 205 #endif 206 207 #if HAVE_POSIX_SPAWN 208 if (slave_process) 209 { 210 sigprocmask (SIG_SETMASK, NULL, &blocked_signals); 211 block_fatal_signals (); 212 } 213 actions_allocated = false; 214 attrs_allocated = false; 215 if ((err = posix_spawn_file_actions_init (&actions)) != 0 216 || (actions_allocated = true, 217 (null_stdin 218 && (err = posix_spawn_file_actions_addopen (&actions, 219 STDIN_FILENO, 220 "/dev/null", O_RDONLY, 221 0)) 222 != 0) 223 || (null_stdout 224 && (err = posix_spawn_file_actions_addopen (&actions, 225 STDOUT_FILENO, 226 "/dev/null", O_RDWR, 227 0)) 228 != 0) 229 || (null_stderr 230 && (err = posix_spawn_file_actions_addopen (&actions, 231 STDERR_FILENO, 232 "/dev/null", O_RDWR, 233 0)) 234 != 0) 235 || (slave_process 236 && ((err = posix_spawnattr_init (&attrs)) != 0 237 || (attrs_allocated = true, 238 (err = posix_spawnattr_setsigmask (&attrs, 239 &blocked_signals)) 240 != 0 241 || (err = posix_spawnattr_setflags (&attrs, 242 POSIX_SPAWN_SETSIGMASK)) 243 != 0))) 244 || (err = posix_spawnp (&child, prog_path, &actions, 245 attrs_allocated ? &attrs : NULL, prog_argv, 246 environ)) 247 != 0)) 248 { 249 if (actions_allocated) 250 posix_spawn_file_actions_destroy (&actions); 251 if (attrs_allocated) 252 posix_spawnattr_destroy (&attrs); 253 if (slave_process) 254 unblock_fatal_signals (); 255 if (exit_on_error || !null_stderr) 256 error (exit_on_error ? EXIT_FAILURE : 0, err, 257 _("%s subprocess failed"), progname); 258 return 127; 259 } 260 posix_spawn_file_actions_destroy (&actions); 261 if (attrs_allocated) 262 posix_spawnattr_destroy (&attrs); 263 #else 264 if (slave_process) 265 block_fatal_signals (); 266 /* Use vfork() instead of fork() for efficiency. */ 267 if ((child = vfork ()) == 0) 268 { 269 /* Child process code. */ 270 int nullinfd; 271 int nulloutfd; 272 273 if ((!null_stdin 274 || ((nullinfd = open ("/dev/null", O_RDONLY, 0)) >= 0 275 && (nullinfd == STDIN_FILENO 276 || (dup2 (nullinfd, STDIN_FILENO) >= 0 277 && close (nullinfd) >= 0)))) 278 && (!(null_stdout || null_stderr) 279 || ((nulloutfd = open ("/dev/null", O_RDWR, 0)) >= 0 280 && (!null_stdout 281 || nulloutfd == STDOUT_FILENO 282 || dup2 (nulloutfd, STDOUT_FILENO) >= 0) 283 && (!null_stderr 284 || nulloutfd == STDERR_FILENO 285 || dup2 (nulloutfd, STDERR_FILENO) >= 0) 286 && ((null_stdout && nulloutfd == STDOUT_FILENO) 287 || (null_stderr && nulloutfd == STDERR_FILENO) 288 || close (nulloutfd) >= 0))) 289 && (!slave_process || (unblock_fatal_signals (), true))) 290 execvp (prog_path, prog_argv); 291 _exit (127); 292 } 293 if (child == -1) 294 { 295 if (slave_process) 296 unblock_fatal_signals (); 297 if (exit_on_error || !null_stderr) 298 error (exit_on_error ? EXIT_FAILURE : 0, errno, 299 _("%s subprocess failed"), progname); 300 return 127; 301 } 302 #endif 303 if (slave_process) 304 { 305 register_slave_subprocess (child); 306 unblock_fatal_signals (); 307 } 308 309 return wait_subprocess (child, progname, ignore_sigpipe, null_stderr, 310 slave_process, exit_on_error); 311 312 #endif 313 } 314