sysdeps/posix/pipestream.c

   1 /* Copyright (C) 1991 Free Software Foundation, Inc.
   2 This file is part of the GNU C Library.
   3
   4 The GNU C Library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 License, or (at your option) any later version.
   8
   9 The GNU C Library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <ansidecl.h>
  20 #include <errno.h>
  21 #include <stddef.h>
  22 #include <signal.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <sys/types.h>
  26 #include <sys/wait.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29
  30 #define SH_PATH "/bin/sh"       /* Shell to run.  */
  31 #define SH_NAME "sh"            /* Name to give it.  */
  32
  33 /* Structure describing a popen child.  */
  34 struct child
  35   {
  36     /* It is important that the first member of this structure be an `int' that
  37        is the file descriptor.  This is because the `fileno' function assumes
  38        that __cookie(STREAM) points to the file descriptor.  */
  39     int fd;
  40     pid_t pid;
  41   };
  42
  43 #ifndef FORK
  44 #define FORK    fork
  45 #endif
  46
  47 /* Open a new stream that is a one-way pipe to a
  48    child process running the given shell command.  */
  49 FILE *
  50 DEFUN(popen, (command, mode), CONST char *command AND CONST char *mode)
  51 {
  52   pid_t pid;
  53   int pipedes[2];
  54   FILE *stream;
  55   struct child *child;
  56
  57   if (command == NULL || mode == NULL || (*mode != 'r' && *mode != 'w'))
  58     {
  59       errno = EINVAL;
  60       return NULL;
  61     }
  62
  63   /* Create the pipe.  */
  64   if (pipe(pipedes) < 0)
  65     return NULL;
  66
  67   /* Fork off the child.  */
  68   pid = FORK();
  69   if (pid == (pid_t) -1)
  70     {
  71       /* The fork failed.  */
  72       (void) close(pipedes[0]);
  73       (void) close(pipedes[1]);
  74       return NULL;
  75     }
  76   else if (pid == (pid_t) 0)
  77     {
  78       /* We are the child side.  Make the write side of
  79          the pipe be stdin or the read side be stdout.  */
  80
  81       CONST char *new_argv[4];
  82
  83       if ((*mode == 'r' ? dup2(pipedes[STDIN_FILENO], STDOUT_FILENO) :
  84           dup2(pipedes[STDOUT_FILENO], STDIN_FILENO)) < 0)
  85         _exit(127);
  86
  87       /* Close the pipe descriptors.  */
  88       (void) close(pipedes[STDIN_FILENO]);
  89       (void) close(pipedes[STDOUT_FILENO]);
  90
  91       /* Exec the shell.  */
  92       new_argv[0] = SH_NAME;
  93       new_argv[1] = "-c";
  94       new_argv[2] = command;
  95       new_argv[3] = NULL;
  96       (void) execve(SH_PATH, (char *CONST *) new_argv, environ);
  97       /* Die if it failed.  */
  98       _exit(127);
  99     }
 100
 101   /* We are the parent side.  */
 102
 103   /* Close the irrelevant side of the pipe and open the relevant side as a
 104      new stream.  Mark our side of the pipe to close on exec, so new popen
 105      children won't see it.  */
 106   if (*mode == 'r')
 107     {
 108       (void) close(pipedes[STDOUT_FILENO]);
 109       (void) fcntl (pipedes[STDIN_FILENO], F_SETFD, FD_CLOEXEC);
 110       stream = fdopen(pipedes[STDIN_FILENO], mode);
 111     }
 112   else
 113     {
 114       (void) close(pipedes[STDIN_FILENO]);
 115       (void) fcntl (pipedes[STDOUT_FILENO], F_SETFD, FD_CLOEXEC);
 116       stream = fdopen(pipedes[STDOUT_FILENO], mode);
 117     }
 118
 119   if (stream == NULL)
 120     goto error;
 121
 122   child = (struct child *) malloc(sizeof(struct child));
 123   if (child == NULL)
 124     goto error;
 125   child->fd = fileno(stream);
 126   child->pid = pid;
 127   stream->__cookie = (PTR) child;
 128   stream->__ispipe = 1;
 129   return stream;
 130
 131  error:;
 132   {
 133     /* The stream couldn't be opened or the child structure couldn't be
 134        allocated.  Kill the child and close the other side of the pipe.  */
 135     int save = errno;
 136     (void) kill(pid, SIGKILL);
 137     if (stream == NULL)
 138       (void) close(pipedes[*mode == 'r' ? STDOUT_FILENO : STDIN_FILENO]);
 139     else
 140       (void) fclose(stream);
 141     (void) waitpid(pid, (int *) NULL, 0);
 142     errno = save;
 143     return NULL;
 144   }
 145 }
 146 \f
 147 /* Close a stream opened by popen and return its status.
 148    Returns -1 if the stream was not opened by popen.  */
 149 int
 150 DEFUN(pclose, (stream), register FILE *stream)
 151 {
 152   pid_t pid;
 153   int status;
 154
 155   if (!__validfp(stream) || !stream->__ispipe)
 156     {
 157       errno = EINVAL;
 158       return -1;
 159     }
 160
 161   pid = ((struct child *) stream->__cookie)->pid;
 162   free(stream->__cookie);
 163   stream->__cookie = (PTR) &stream->__fileno;
 164   stream->__ispipe = 0;
 165   if (fclose(stream))
 166     return -1;
 167
 168   if (waitpid(pid, &status, 0) != pid)
 169     status = -1;
 170   return status;
 171 }