lib/pipe.c

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