lib/pipe.c

   1 /* Creation of subprocesses, communicating via pipes.
   2    Copyright (C) 2001-2004 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 /* Specification.  */
  25 #include "pipe.h"
  26
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <stdlib.h>
  30 #include <signal.h>
  31
  32 #ifdef HAVE_UNISTD_H
  33 # include <unistd.h>
  34 #endif
  35
  36 #include "error.h"
  37 #include "exit.h"
  38 #include "fatal-signal.h"
  39 #include "wait-process.h"
  40 #include "gettext.h"
  41
  42 #define _(str) gettext (str)
  43
  44 #if defined _MSC_VER || defined __MINGW32__
  45
  46 /* Native Woe32 API.  */
  47 # include <process.h>
  48 # include "w32spawn.h"
  49
  50 #else
  51
  52 /* Unix API.  */
  53 # ifdef HAVE_POSIX_SPAWN
  54 #  include <spawn.h>
  55 # else
  56 #  ifdef HAVE_VFORK_H
  57 #   include <vfork.h>
  58 #  endif
  59 # endif
  60
  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().
  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 /* Open a pipe connected to a child process.
 111  *
 112  *           write       system                read
 113  *    parent  ->   fd[1]   ->   STDIN_FILENO    ->   child       if pipe_stdin
 114  *    parent  <-   fd[0]   <-   STDOUT_FILENO   <-   child       if pipe_stdout
 115  *           read        system                write
 116  *
 117  * At least one of pipe_stdin, pipe_stdout must be true.
 118  * pipe_stdin and prog_stdin together determine the child's standard input.
 119  * pipe_stdout and prog_stdout together determine the child's standard output.
 120  * If pipe_stdin is true, prog_stdin is ignored.
 121  * If pipe_stdout is true, prog_stdout is ignored.
 122  */
 123 static pid_t
 124 create_pipe (const char *progname,
 125              const char *prog_path, char **prog_argv,
 126              bool pipe_stdin, bool pipe_stdout,
 127              const char *prog_stdin, const char *prog_stdout,
 128              bool null_stderr,
 129              bool slave_process, bool exit_on_error,
 130              int fd[2])
 131 {
 132 #if defined _MSC_VER || defined __MINGW32__
 133
 134   /* Native Woe32 API.
 135      This uses _pipe(), dup2(), and spawnv().  It could also be implemented
 136      using the low-level functions CreatePipe(), DuplicateHandle(),
 137      CreateProcess() and _open_osfhandle(); see the GNU make and GNU clisp
 138      and cvs source code.  */
 139   int ifd[2];
 140   int ofd[2];
 141   int orig_stdin;
 142   int orig_stdout;
 143   int orig_stderr;
 144   int child;
 145   int nulloutfd;
 146   int stdinfd;
 147   int stdoutfd;
 148
 149   prog_argv = prepare_spawn (prog_argv);
 150
 151   if (pipe_stdout)
 152     if (_pipe (ifd, 4096, O_BINARY | O_NOINHERIT) < 0)
 153       error (EXIT_FAILURE, errno, _("cannot create pipe"));
 154   if (pipe_stdin)
 155     if (_pipe (ofd, 4096, O_BINARY | O_NOINHERIT) < 0)
 156       error (EXIT_FAILURE, errno, _("cannot create pipe"));
 157 /* Data flow diagram:
 158  *
 159  *           write        system         read
 160  *    parent  ->   ofd[1]   ->   ofd[0]   ->   child       if pipe_stdin
 161  *    parent  <-   ifd[0]   <-   ifd[1]   <-   child       if pipe_stdout
 162  *           read         system         write
 163  *
 164  */
 165
 166   /* Save standard file handles of parent process.  */
 167   if (pipe_stdin || prog_stdin != NULL)
 168     orig_stdin = dup_noinherit (STDIN_FILENO);
 169   if (pipe_stdout || prog_stdout != NULL)
 170     orig_stdout = dup_noinherit (STDOUT_FILENO);
 171   if (null_stderr)
 172     orig_stderr = dup_noinherit (STDERR_FILENO);
 173   child = -1;
 174
 175   /* Create standard file handles of child process.  */
 176   nulloutfd = -1;
 177   stdinfd = -1;
 178   stdoutfd = -1;
 179   if ((!pipe_stdin || dup2 (ofd[0], STDIN_FILENO) >= 0)
 180       && (!pipe_stdout || dup2 (ifd[1], STDOUT_FILENO) >= 0)
 181       && (!null_stderr
 182           || ((nulloutfd = open ("NUL", O_RDWR, 0)) >= 0
 183               && (nulloutfd == STDERR_FILENO
 184                   || (dup2 (nulloutfd, STDERR_FILENO) >= 0
 185                       && close (nulloutfd) >= 0))))
 186       && (pipe_stdin
 187           || prog_stdin == NULL
 188           || ((stdinfd = open (prog_stdin, O_RDONLY, 0)) >= 0
 189               && (stdinfd == STDIN_FILENO
 190                   || (dup2 (stdinfd, STDIN_FILENO) >= 0
 191                       && close (stdinfd) >= 0))))
 192       && (pipe_stdout
 193           || prog_stdout == NULL
 194           || ((stdoutfd = open (prog_stdout, O_WRONLY, 0)) >= 0
 195               && (stdoutfd == STDOUT_FILENO
 196                   || (dup2 (stdoutfd, STDOUT_FILENO) >= 0
 197                       && close (stdoutfd) >= 0)))))
 198     /* The child process doesn't inherit ifd[0], ifd[1], ofd[0], ofd[1],
 199        but it inherits all open()ed or dup2()ed file handles (which is what
 200        we want in the case of STD*_FILENO) and also orig_stdin,
 201        orig_stdout, orig_stderr (which is not explicitly wanted but
 202        harmless).  */
 203     child = spawnvp (P_NOWAIT, prog_path, prog_argv);
 204   if (stdinfd >= 0)
 205     close (stdinfd);
 206   if (stdoutfd >= 0)
 207     close (stdoutfd);
 208   if (nulloutfd >= 0)
 209     close (nulloutfd);
 210
 211   /* Restore standard file handles of parent process.  */
 212   if (null_stderr)
 213     dup2 (orig_stderr, STDERR_FILENO), close (orig_stderr);
 214   if (pipe_stdout || prog_stdout != NULL)
 215     dup2 (orig_stdout, STDOUT_FILENO), close (orig_stdout);
 216   if (pipe_stdin || prog_stdin != NULL)
 217     dup2 (orig_stdin, STDIN_FILENO), close (orig_stdin);
 218
 219   if (pipe_stdin)
 220     close (ofd[0]);
 221   if (pipe_stdout)
 222     close (ifd[1]);
 223   if (child == -1)
 224     {
 225       if (exit_on_error || !null_stderr)
 226         error (exit_on_error ? EXIT_FAILURE : 0, errno,
 227                _("%s subprocess failed"), progname);
 228       if (pipe_stdout)
 229         close (ifd[0]);
 230       if (pipe_stdin)
 231         close (ofd[1]);
 232       return -1;
 233     }
 234
 235   if (pipe_stdout)
 236     fd[0] = ifd[0];
 237   if (pipe_stdin)
 238     fd[1] = ofd[1];
 239   return child;
 240
 241 #else
 242
 243   /* Unix API.  */
 244   int ifd[2];
 245   int ofd[2];
 246 # if HAVE_POSIX_SPAWN
 247   sigset_t blocked_signals;
 248   posix_spawn_file_actions_t actions;
 249   bool actions_allocated;
 250   posix_spawnattr_t attrs;
 251   bool attrs_allocated;
 252   int err;
 253   pid_t child;
 254 # else
 255   int child;
 256 # endif
 257
 258   if (pipe_stdout)
 259     if (pipe (ifd) < 0)
 260       error (EXIT_FAILURE, errno, _("cannot create pipe"));
 261   if (pipe_stdin)
 262     if (pipe (ofd) < 0)
 263       error (EXIT_FAILURE, errno, _("cannot create pipe"));
 264 /* Data flow diagram:
 265  *
 266  *           write        system         read
 267  *    parent  ->   ofd[1]   ->   ofd[0]   ->   child       if pipe_stdin
 268  *    parent  <-   ifd[0]   <-   ifd[1]   <-   child       if pipe_stdout
 269  *           read         system         write
 270  *
 271  */
 272
 273 # if HAVE_POSIX_SPAWN
 274   if (slave_process)
 275     {
 276       sigprocmask (SIG_SETMASK, NULL, &blocked_signals);
 277       block_fatal_signals ();
 278     }
 279   actions_allocated = false;
 280   attrs_allocated = false;
 281   if ((err = posix_spawn_file_actions_init (&actions)) != 0
 282       || (actions_allocated = true,
 283           (pipe_stdin
 284            && (err = posix_spawn_file_actions_adddup2 (&actions,
 285                                                        ofd[0], STDIN_FILENO))
 286               != 0)
 287           || (pipe_stdout
 288               && (err = posix_spawn_file_actions_adddup2 (&actions,
 289                                                           ifd[1], STDOUT_FILENO))
 290                  != 0)
 291           || (pipe_stdin
 292               && (err = posix_spawn_file_actions_addclose (&actions, ofd[0]))
 293                  != 0)
 294           || (pipe_stdout
 295               && (err = posix_spawn_file_actions_addclose (&actions, ifd[1]))
 296                  != 0)
 297           || (pipe_stdin
 298               && (err = posix_spawn_file_actions_addclose (&actions, ofd[1]))
 299                  != 0)
 300           || (pipe_stdout
 301               && (err = posix_spawn_file_actions_addclose (&actions, ifd[0]))
 302                  != 0)
 303           || (null_stderr
 304               && (err = posix_spawn_file_actions_addopen (&actions,
 305                                                           STDERR_FILENO,
 306                                                           "/dev/null", O_RDWR,
 307                                                           0))
 308                  != 0)
 309           || (!pipe_stdin
 310               && prog_stdin != NULL
 311               && (err = posix_spawn_file_actions_addopen (&actions,
 312                                                           STDIN_FILENO,
 313                                                           prog_stdin, O_RDONLY,
 314                                                           0))
 315                  != 0)
 316           || (!pipe_stdout
 317               && prog_stdout != NULL
 318               && (err = posix_spawn_file_actions_addopen (&actions,
 319                                                           STDOUT_FILENO,
 320                                                           prog_stdout, O_WRONLY,
 321                                                           0))
 322                  != 0)
 323           || (slave_process
 324               && ((err = posix_spawnattr_init (&attrs)) != 0
 325                   || (attrs_allocated = true,
 326                       (err = posix_spawnattr_setsigmask (&attrs,
 327                                                          &blocked_signals))
 328                       != 0
 329                       || (err = posix_spawnattr_setflags (&attrs,
 330                                                         POSIX_SPAWN_SETSIGMASK))
 331                          != 0)))
 332           || (err = posix_spawnp (&child, prog_path, &actions,
 333                                   attrs_allocated ? &attrs : NULL, prog_argv,
 334                                   environ))
 335              != 0))
 336     {
 337       if (actions_allocated)
 338         posix_spawn_file_actions_destroy (&actions);
 339       if (attrs_allocated)
 340         posix_spawnattr_destroy (&attrs);
 341       if (slave_process)
 342         unblock_fatal_signals ();
 343       if (exit_on_error || !null_stderr)
 344         error (exit_on_error ? EXIT_FAILURE : 0, err,
 345                _("%s subprocess failed"), progname);
 346       if (pipe_stdout)
 347         {
 348           close (ifd[0]);
 349           close (ifd[1]);
 350         }
 351       if (pipe_stdin)
 352         {
 353           close (ofd[0]);
 354           close (ofd[1]);
 355         }
 356       return -1;
 357     }
 358   posix_spawn_file_actions_destroy (&actions);
 359   if (attrs_allocated)
 360     posix_spawnattr_destroy (&attrs);
 361 # else
 362   if (slave_process)
 363     block_fatal_signals ();
 364   /* Use vfork() instead of fork() for efficiency.  */
 365   if ((child = vfork ()) == 0)
 366     {
 367       /* Child process code.  */
 368       int nulloutfd;
 369       int stdinfd;
 370       int stdoutfd;
 371
 372       if ((!pipe_stdin || dup2 (ofd[0], STDIN_FILENO) >= 0)
 373           && (!pipe_stdout || dup2 (ifd[1], STDOUT_FILENO) >= 0)
 374           && (!pipe_stdin || close (ofd[0]) >= 0)
 375           && (!pipe_stdout || close (ifd[1]) >= 0)
 376           && (!pipe_stdin || close (ofd[1]) >= 0)
 377           && (!pipe_stdout || close (ifd[0]) >= 0)
 378           && (!null_stderr
 379               || ((nulloutfd = open ("/dev/null", O_RDWR, 0)) >= 0
 380                   && (nulloutfd == STDERR_FILENO
 381                       || (dup2 (nulloutfd, STDERR_FILENO) >= 0
 382                           && close (nulloutfd) >= 0))))
 383           && (pipe_stdin
 384               || prog_stdin == NULL
 385               || ((stdinfd = open (prog_stdin, O_RDONLY, 0)) >= 0
 386                   && (stdinfd == STDIN_FILENO
 387                       || (dup2 (stdinfd, STDIN_FILENO) >= 0
 388                           && close (stdinfd) >= 0))))
 389           && (pipe_stdout
 390               || prog_stdout == NULL
 391               || ((stdoutfd = open (prog_stdout, O_WRONLY, 0)) >= 0
 392                   && (stdoutfd == STDOUT_FILENO
 393                       || (dup2 (stdoutfd, STDOUT_FILENO) >= 0
 394                           && close (stdoutfd) >= 0))))
 395           && (!slave_process || (unblock_fatal_signals (), true)))
 396         execvp (prog_path, prog_argv);
 397       _exit (127);
 398     }
 399   if (child == -1)
 400     {
 401       if (slave_process)
 402         unblock_fatal_signals ();
 403       if (exit_on_error || !null_stderr)
 404         error (exit_on_error ? EXIT_FAILURE : 0, errno,
 405                _("%s subprocess failed"), progname);
 406       if (pipe_stdout)
 407         {
 408           close (ifd[0]);
 409           close (ifd[1]);
 410         }
 411       if (pipe_stdin)
 412         {
 413           close (ofd[0]);
 414           close (ofd[1]);
 415         }
 416       return -1;
 417     }
 418 # endif
 419   if (slave_process)
 420     {
 421       register_slave_subprocess (child);
 422       unblock_fatal_signals ();
 423     }
 424   if (pipe_stdin)
 425     close (ofd[0]);
 426   if (pipe_stdout)
 427     close (ifd[1]);
 428
 429   if (pipe_stdout)
 430     fd[0] = ifd[0];
 431   if (pipe_stdin)
 432     fd[1] = ofd[1];
 433   return child;
 434
 435 #endif
 436 }
 437
 438 /* Open a bidirectional pipe.
 439  *
 440  *           write       system                read
 441  *    parent  ->   fd[1]   ->   STDIN_FILENO    ->   child
 442  *    parent  <-   fd[0]   <-   STDOUT_FILENO   <-   child
 443  *           read        system                write
 444  *
 445  */
 446 pid_t
 447 create_pipe_bidi (const char *progname,
 448                   const char *prog_path, char **prog_argv,
 449                   bool null_stderr,
 450                   bool slave_process, bool exit_on_error,
 451                   int fd[2])
 452 {
 453   pid_t result = create_pipe (progname, prog_path, prog_argv,
 454                               true, true, NULL, NULL,
 455                               null_stderr, slave_process, exit_on_error,
 456                               fd);
 457   return result;
 458 }
 459
 460 /* Open a pipe for input from a child process.
 461  * The child's stdin comes from a file.
 462  *
 463  *           read        system                write
 464  *    parent  <-   fd[0]   <-   STDOUT_FILENO   <-   child
 465  *
 466  */
 467 pid_t
 468 create_pipe_in (const char *progname,
 469                 const char *prog_path, char **prog_argv,
 470                 const char *prog_stdin, bool null_stderr,
 471                 bool slave_process, bool exit_on_error,
 472                 int fd[1])
 473 {
 474   int iofd[2];
 475   pid_t result = create_pipe (progname, prog_path, prog_argv,
 476                               false, true, prog_stdin, NULL,
 477                               null_stderr, slave_process, exit_on_error,
 478                               iofd);
 479   if (result != -1)
 480     fd[0] = iofd[0];
 481   return result;
 482 }
 483
 484 /* Open a pipe for output to a child process.
 485  * The child's stdout goes to a file.
 486  *
 487  *           write       system                read
 488  *    parent  ->   fd[0]   ->   STDIN_FILENO    ->   child
 489  *
 490  */
 491 pid_t
 492 create_pipe_out (const char *progname,
 493                  const char *prog_path, char **prog_argv,
 494                  const char *prog_stdout, bool null_stderr,
 495                  bool slave_process, bool exit_on_error,
 496                  int fd[1])
 497 {
 498   int iofd[2];
 499   pid_t result = create_pipe (progname, prog_path, prog_argv,
 500                               true, false, NULL, prog_stdout,
 501                               null_stderr, slave_process, exit_on_error,
 502                               iofd);
 503   if (result != -1)
 504     fd[0] = iofd[1];
 505   return result;
 506 }