1 /* Creation of subprocesses, communicating via pipes. 2 Copyright (C) 2001-2004, 2006-2012 Free Software Foundation, Inc. 3 Written by Bruno Haible <haible (at) 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 3 of the License, or 8 (at your option) 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, see <http://www.gnu.org/licenses/>. */ 17 18 19 #include <config.h> 20 21 /* Specification. */ 22 #include "spawn-pipe.h" 23 24 #include <errno.h> 25 #include <fcntl.h> 26 #include <stdlib.h> 27 #include <signal.h> 28 #include <unistd.h> 29 30 #include "error.h" 31 #include "fatal-signal.h" 32 #include "unistd-safer.h" 33 #include "wait-process.h" 34 #include "gettext.h" 35 36 #define _(str) gettext (str) 37 38 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__ 39 40 /* Native Windows API. */ 41 # include <process.h> 42 # include "w32spawn.h" 43 44 #else 45 46 /* Unix API. */ 47 # include <spawn.h> 48 49 #endif 50 51 /* The results of open() in this file are not used with fchdir, 52 therefore save some unnecessary work in fchdir.c. */ 53 #undef open 54 #undef close 55 56 57 #ifdef EINTR 58 59 /* EINTR handling for close(). 60 These functions can return -1/EINTR even though we don't have any 61 signal handlers set up, namely when we get interrupted via SIGSTOP. */ 62 63 static int 64 nonintr_close (int fd) 65 { 66 int retval; 67 68 do 69 retval = close (fd); 70 while (retval < 0 && errno == EINTR); 71 72 return retval; 73 } 74 #define close nonintr_close 75 76 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__ 77 static int 78 nonintr_open (const char *pathname, int oflag, mode_t mode) 79 { 80 int retval; 81 82 do 83 retval = open (pathname, oflag, mode); 84 while (retval < 0 && errno == EINTR); 85 86 return retval; 87 } 88 # undef open /* avoid warning on VMS */ 89 # define open nonintr_open 90 #endif 91 92 #endif 93 94 95 /* Open a pipe connected to a child process. 96 * 97 * write system read 98 * parent -> fd[1] -> STDIN_FILENO -> child if pipe_stdin 99 * parent <- fd[0] <- STDOUT_FILENO <- child if pipe_stdout 100 * read system write 101 * 102 * At least one of pipe_stdin, pipe_stdout must be true. 103 * pipe_stdin and prog_stdin together determine the child's standard input. 104 * pipe_stdout and prog_stdout together determine the child's standard output. 105 * If pipe_stdin is true, prog_stdin is ignored. 106 * If pipe_stdout is true, prog_stdout is ignored. 107 */ 108 static pid_t 109 create_pipe (const char *progname, 110 const char *prog_path, char **prog_argv, 111 bool pipe_stdin, bool pipe_stdout, 112 const char *prog_stdin, const char *prog_stdout, 113 bool null_stderr, 114 bool slave_process, bool exit_on_error, 115 int fd[2]) 116 { 117 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__ 118 119 /* Native Windows API. 120 This uses _pipe(), dup2(), and spawnv(). It could also be implemented 121 using the low-level functions CreatePipe(), DuplicateHandle(), 122 CreateProcess() and _open_osfhandle(); see the GNU make and GNU clisp 123 and cvs source code. */ 124 int ifd[2]; 125 int ofd[2]; 126 int orig_stdin; 127 int orig_stdout; 128 int orig_stderr; 129 int child; 130 int nulloutfd; 131 int stdinfd; 132 int stdoutfd; 133 int saved_errno; 134 135 /* FIXME: Need to free memory allocated by prepare_spawn. */ 136 prog_argv = prepare_spawn (prog_argv); 137 138 if (pipe_stdout) 139 if (pipe2_safer (ifd, O_BINARY | O_CLOEXEC) < 0) 140 error (EXIT_FAILURE, errno, _("cannot create pipe")); 141 if (pipe_stdin) 142 if (pipe2_safer (ofd, O_BINARY | O_CLOEXEC) < 0) 143 error (EXIT_FAILURE, errno, _("cannot create pipe")); 144 /* Data flow diagram: 145 * 146 * write system read 147 * parent -> ofd[1] -> ofd[0] -> child if pipe_stdin 148 * parent <- ifd[0] <- ifd[1] <- child if pipe_stdout 149 * read system write 150 * 151 */ 152 153 /* Save standard file handles of parent process. */ 154 if (pipe_stdin || prog_stdin != NULL) 155 orig_stdin = dup_safer_noinherit (STDIN_FILENO); 156 if (pipe_stdout || prog_stdout != NULL) 157 orig_stdout = dup_safer_noinherit (STDOUT_FILENO); 158 if (null_stderr) 159 orig_stderr = dup_safer_noinherit (STDERR_FILENO); 160 child = -1; 161 162 /* Create standard file handles of child process. */ 163 nulloutfd = -1; 164 stdinfd = -1; 165 stdoutfd = -1; 166 if ((!pipe_stdin || dup2 (ofd[0], STDIN_FILENO) >= 0) 167 && (!pipe_stdout || dup2 (ifd[1], STDOUT_FILENO) >= 0) 168 && (!null_stderr 169 || ((nulloutfd = open ("NUL", O_RDWR, 0)) >= 0 170 && (nulloutfd == STDERR_FILENO 171 || (dup2 (nulloutfd, STDERR_FILENO) >= 0 172 && close (nulloutfd) >= 0)))) 173 && (pipe_stdin 174 || prog_stdin == NULL 175 || ((stdinfd = open (prog_stdin, O_RDONLY, 0)) >= 0 176 && (stdinfd == STDIN_FILENO 177 || (dup2 (stdinfd, STDIN_FILENO) >= 0 178 && close (stdinfd) >= 0)))) 179 && (pipe_stdout 180 || prog_stdout == NULL 181 || ((stdoutfd = open (prog_stdout, O_WRONLY, 0)) >= 0 182 && (stdoutfd == STDOUT_FILENO 183 || (dup2 (stdoutfd, STDOUT_FILENO) >= 0 184 && close (stdoutfd) >= 0))))) 185 /* The child process doesn't inherit ifd[0], ifd[1], ofd[0], ofd[1], 186 but it inherits all open()ed or dup2()ed file handles (which is what 187 we want in the case of STD*_FILENO). */ 188 /* Use spawnvpe and pass the environment explicitly. This is needed if 189 the program has modified the environment using putenv() or [un]setenv(). 190 On Windows, programs have two environments, one in the "environment 191 block" of the process and managed through SetEnvironmentVariable(), and 192 one inside the process, in the location retrieved by the 'environ' 193 macro. When using spawnvp() without 'e', the child process inherits a 194 copy of the environment block - ignoring the effects of putenv() and 195 [un]setenv(). */ 196 { 197 child = spawnvpe (P_NOWAIT, prog_path, (const char **) prog_argv, 198 (const char **) environ); 199 if (child < 0 && errno == ENOEXEC) 200 { 201 /* prog is not a native executable. Try to execute it as a 202 shell script. Note that prepare_spawn() has already prepended 203 a hidden element "sh.exe" to prog_argv. */ 204 --prog_argv; 205 child = spawnvpe (P_NOWAIT, prog_argv[0], (const char **) prog_argv, 206 (const char **) environ); 207 } 208 } 209 if (child == -1) 210 saved_errno = errno; 211 if (stdinfd >= 0) 212 close (stdinfd); 213 if (stdoutfd >= 0) 214 close (stdoutfd); 215 if (nulloutfd >= 0) 216 close (nulloutfd); 217 218 /* Restore standard file handles of parent process. */ 219 if (null_stderr) 220 undup_safer_noinherit (orig_stderr, STDERR_FILENO); 221 if (pipe_stdout || prog_stdout != NULL) 222 undup_safer_noinherit (orig_stdout, STDOUT_FILENO); 223 if (pipe_stdin || prog_stdin != NULL) 224 undup_safer_noinherit (orig_stdin, STDIN_FILENO); 225 226 if (pipe_stdin) 227 close (ofd[0]); 228 if (pipe_stdout) 229 close (ifd[1]); 230 if (child == -1) 231 { 232 if (exit_on_error || !null_stderr) 233 error (exit_on_error ? EXIT_FAILURE : 0, saved_errno, 234 _("%s subprocess failed"), progname); 235 if (pipe_stdout) 236 close (ifd[0]); 237 if (pipe_stdin) 238 close (ofd[1]); 239 errno = saved_errno; 240 return -1; 241 } 242 243 if (pipe_stdout) 244 fd[0] = ifd[0]; 245 if (pipe_stdin) 246 fd[1] = ofd[1]; 247 return child; 248 249 #else 250 251 /* Unix API. */ 252 int ifd[2]; 253 int ofd[2]; 254 sigset_t blocked_signals; 255 posix_spawn_file_actions_t actions; 256 bool actions_allocated; 257 posix_spawnattr_t attrs; 258 bool attrs_allocated; 259 int err; 260 pid_t child; 261 262 if (pipe_stdout) 263 if (pipe_safer (ifd) < 0) 264 error (EXIT_FAILURE, errno, _("cannot create pipe")); 265 if (pipe_stdin) 266 if (pipe_safer (ofd) < 0) 267 error (EXIT_FAILURE, errno, _("cannot create pipe")); 268 /* Data flow diagram: 269 * 270 * write system read 271 * parent -> ofd[1] -> ofd[0] -> child if pipe_stdin 272 * parent <- ifd[0] <- ifd[1] <- child if pipe_stdout 273 * read system write 274 * 275 */ 276 277 if (slave_process) 278 { 279 sigprocmask (SIG_SETMASK, NULL, &blocked_signals); 280 block_fatal_signals (); 281 } 282 actions_allocated = false; 283 attrs_allocated = false; 284 if ((err = posix_spawn_file_actions_init (&actions)) != 0 285 || (actions_allocated = true, 286 (pipe_stdin 287 && (err = posix_spawn_file_actions_adddup2 (&actions, 288 ofd[0], STDIN_FILENO)) 289 != 0) 290 || (pipe_stdout 291 && (err = posix_spawn_file_actions_adddup2 (&actions, 292 ifd[1], STDOUT_FILENO)) 293 != 0) 294 || (pipe_stdin 295 && (err = posix_spawn_file_actions_addclose (&actions, ofd[0])) 296 != 0) 297 || (pipe_stdout 298 && (err = posix_spawn_file_actions_addclose (&actions, ifd[1])) 299 != 0) 300 || (pipe_stdin 301 && (err = posix_spawn_file_actions_addclose (&actions, ofd[1])) 302 != 0) 303 || (pipe_stdout 304 && (err = posix_spawn_file_actions_addclose (&actions, ifd[0])) 305 != 0) 306 || (null_stderr 307 && (err = posix_spawn_file_actions_addopen (&actions, 308 STDERR_FILENO, 309 "/dev/null", O_RDWR, 310 0)) 311 != 0) 312 || (!pipe_stdin 313 && prog_stdin != NULL 314 && (err = posix_spawn_file_actions_addopen (&actions, 315 STDIN_FILENO, 316 prog_stdin, O_RDONLY, 317 0)) 318 != 0) 319 || (!pipe_stdout 320 && prog_stdout != NULL 321 && (err = posix_spawn_file_actions_addopen (&actions, 322 STDOUT_FILENO, 323 prog_stdout, O_WRONLY, 324 0)) 325 != 0) 326 || (slave_process 327 && ((err = posix_spawnattr_init (&attrs)) != 0 328 || (attrs_allocated = true, 329 (err = posix_spawnattr_setsigmask (&attrs, 330 &blocked_signals)) 331 != 0 332 || (err = posix_spawnattr_setflags (&attrs, 333 POSIX_SPAWN_SETSIGMASK)) 334 != 0))) 335 || (err = posix_spawnp (&child, prog_path, &actions, 336 attrs_allocated ? &attrs : NULL, prog_argv, 337 environ)) 338 != 0)) 339 { 340 if (actions_allocated) 341 posix_spawn_file_actions_destroy (&actions); 342 if (attrs_allocated) 343 posix_spawnattr_destroy (&attrs); 344 if (slave_process) 345 unblock_fatal_signals (); 346 if (exit_on_error || !null_stderr) 347 error (exit_on_error ? EXIT_FAILURE : 0, err, 348 _("%s subprocess failed"), progname); 349 if (pipe_stdout) 350 { 351 close (ifd[0]); 352 close (ifd[1]); 353 } 354 if (pipe_stdin) 355 { 356 close (ofd[0]); 357 close (ofd[1]); 358 } 359 errno = err; 360 return -1; 361 } 362 posix_spawn_file_actions_destroy (&actions); 363 if (attrs_allocated) 364 posix_spawnattr_destroy (&attrs); 365 if (slave_process) 366 { 367 register_slave_subprocess (child); 368 unblock_fatal_signals (); 369 } 370 if (pipe_stdin) 371 close (ofd[0]); 372 if (pipe_stdout) 373 close (ifd[1]); 374 375 if (pipe_stdout) 376 fd[0] = ifd[0]; 377 if (pipe_stdin) 378 fd[1] = ofd[1]; 379 return child; 380 381 #endif 382 } 383 384 /* Open a bidirectional pipe. 385 * 386 * write system read 387 * parent -> fd[1] -> STDIN_FILENO -> child 388 * parent <- fd[0] <- STDOUT_FILENO <- child 389 * read system write 390 * 391 */ 392 pid_t 393 create_pipe_bidi (const char *progname, 394 const char *prog_path, char **prog_argv, 395 bool null_stderr, 396 bool slave_process, bool exit_on_error, 397 int fd[2]) 398 { 399 pid_t result = create_pipe (progname, prog_path, prog_argv, 400 true, true, NULL, NULL, 401 null_stderr, slave_process, exit_on_error, 402 fd); 403 return result; 404 } 405 406 /* Open a pipe for input from a child process. 407 * The child's stdin comes from a file. 408 * 409 * read system write 410 * parent <- fd[0] <- STDOUT_FILENO <- child 411 * 412 */ 413 pid_t 414 create_pipe_in (const char *progname, 415 const char *prog_path, char **prog_argv, 416 const char *prog_stdin, bool null_stderr, 417 bool slave_process, bool exit_on_error, 418 int fd[1]) 419 { 420 int iofd[2]; 421 pid_t result = create_pipe (progname, prog_path, prog_argv, 422 false, true, prog_stdin, NULL, 423 null_stderr, slave_process, exit_on_error, 424 iofd); 425 if (result != -1) 426 fd[0] = iofd[0]; 427 return result; 428 } 429 430 /* Open a pipe for output to a child process. 431 * The child's stdout goes to a file. 432 * 433 * write system read 434 * parent -> fd[0] -> STDIN_FILENO -> child 435 * 436 */ 437 pid_t 438 create_pipe_out (const char *progname, 439 const char *prog_path, char **prog_argv, 440 const char *prog_stdout, bool null_stderr, 441 bool slave_process, bool exit_on_error, 442 int fd[1]) 443 { 444 int iofd[2]; 445 pid_t result = create_pipe (progname, prog_path, prog_argv, 446 true, false, NULL, prog_stdout, 447 null_stderr, slave_process, exit_on_error, 448 iofd); 449 if (result != -1) 450 fd[0] = iofd[1]; 451 return result; 452 } 453
