libio/iopopen.c

   1 /* Copyright (C) 1993, 1997, 1998 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3    Written by Per Bothner <bothner@cygnus.com>.
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2, or (at
   8    your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this library; see the file COPYING.  If not, write to
  17    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  18    MA 02111-1307, USA.
  19
  20    As a special exception, if you link this library with files
  21    compiled with a GNU compiler to produce an executable, this does
  22    not cause the resulting executable to be covered by the GNU General
  23    Public License.  This exception does not however invalidate any
  24    other reasons why the executable file might be covered by the GNU
  25    General Public License.  */
  26
  27 #ifndef _POSIX_SOURCE
  28 # define _POSIX_SOURCE
  29 #endif
  30 #include "libioP.h"
  31 #if _IO_HAVE_SYS_WAIT
  32 #include <signal.h>
  33 #include <unistd.h>
  34 #ifdef __STDC__
  35 #include <stdlib.h>
  36 #endif
  37 #ifdef _LIBC
  38 # include <unistd.h>
  39 #endif
  40 #include <sys/types.h>
  41 #include <sys/wait.h>
  42
  43 #ifndef _IO_fork
  44 #ifdef _LIBC
  45 #define _IO_fork __vfork
  46 #else
  47 #define _IO_fork vfork /* defined in libiberty, if needed */
  48 #endif
  49 extern _IO_pid_t _IO_fork __P ((void));
  50 #endif
  51
  52 #endif /* _IO_HAVE_SYS_WAIT */
  53
  54 #ifndef _IO_pipe
  55 #ifdef _LIBC
  56 #define _IO_pipe __pipe
  57 #else
  58 #define _IO_pipe pipe
  59 #endif
  60 extern int _IO_pipe __P ((int des[2]));
  61 #endif
  62
  63 #ifndef _IO_dup2
  64 #ifdef _LIBC
  65 #define _IO_dup2 __dup2
  66 #else
  67 #define _IO_dup2 dup2
  68 #endif
  69 extern int _IO_dup2 __P ((int fd, int fd2));
  70 #endif
  71
  72 #ifndef _IO_waitpid
  73 #ifdef _LIBC
  74 #define _IO_waitpid __waitpid
  75 #else
  76 #define _IO_waitpid waitpid
  77 #endif
  78 #endif
  79
  80 #ifndef _IO_execl
  81 #define _IO_execl execl
  82 #endif
  83 #ifndef _IO__exit
  84 #define _IO__exit _exit
  85 #endif
  86
  87 #ifndef _IO_close
  88 #ifdef _LIBC
  89 #define _IO_close __close
  90 #else
  91 #define _IO_close close
  92 #endif
  93 #endif
  94
  95 struct _IO_proc_file
  96 {
  97   struct _IO_FILE_plus file;
  98   /* Following fields must match those in class procbuf (procbuf.h) */
  99   _IO_pid_t pid;
 100   struct _IO_proc_file *next;
 101 };
 102 typedef struct _IO_proc_file _IO_proc_file;
 103
 104 static struct _IO_proc_file *proc_file_chain = NULL;
 105
 106 _IO_FILE *
 107 _IO_proc_open (fp, command, mode)
 108      _IO_FILE *fp;
 109      const char *command;
 110      const char *mode;
 111 {
 112 #if _IO_HAVE_SYS_WAIT
 113   volatile int read_or_write;
 114   volatile int parent_end, child_end;
 115   int pipe_fds[2];
 116   _IO_pid_t child_pid;
 117   if (_IO_file_is_open (fp))
 118     return NULL;
 119   if (_IO_pipe (pipe_fds) < 0)
 120     return NULL;
 121   if (mode[0] == 'r' && mode[1] == '\0')
 122     {
 123       parent_end = pipe_fds[0];
 124       child_end = pipe_fds[1];
 125       read_or_write = _IO_NO_WRITES;
 126     }
 127   else if (mode[0] == 'w' && mode[1] == '\0')
 128     {
 129       parent_end = pipe_fds[1];
 130       child_end = pipe_fds[0];
 131       read_or_write = _IO_NO_READS;
 132     }
 133   else
 134     {
 135       __set_errno (EINVAL);
 136       return NULL;
 137     }
 138   ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork ();
 139   if (child_pid == 0)
 140     {
 141       int child_std_end = mode[0] == 'r' ? 1 : 0;
 142       _IO_close (parent_end);
 143       if (child_end != child_std_end)
 144         {
 145           _IO_dup2 (child_end, child_std_end);
 146           _IO_close (child_end);
 147         }
 148       /* POSIX.2:  "popen() shall ensure that any streams from previous
 149          popen() calls that remain open in the parent process are closed
 150          in the new child process." */
 151       while (proc_file_chain)
 152         {
 153           _IO_close (_IO_fileno ((_IO_FILE *) proc_file_chain));
 154           proc_file_chain = proc_file_chain->next;
 155         }
 156
 157       _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0);
 158       _IO__exit (127);
 159     }
 160   _IO_close (child_end);
 161   if (child_pid < 0)
 162     {
 163       _IO_close (parent_end);
 164       return NULL;
 165     }
 166   _IO_fileno (fp) = parent_end;
 167
 168   /* Link into proc_file_chain. */
 169   ((_IO_proc_file *) fp)->next = proc_file_chain;
 170   proc_file_chain = (_IO_proc_file *) fp;
 171
 172   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
 173   return fp;
 174 #else /* !_IO_HAVE_SYS_WAIT */
 175   return NULL;
 176 #endif
 177 }
 178
 179 _IO_FILE *
 180 _IO_popen (command, mode)
 181      const char *command;
 182      const char *mode;
 183 {
 184   struct locked_FILE
 185   {
 186     struct _IO_proc_file fpx;
 187 #ifdef _IO_MTSAFE_IO
 188     _IO_lock_t lock;
 189 #endif
 190   } *new_f;
 191   _IO_FILE *fp;
 192
 193   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 194   if (new_f == NULL)
 195     return NULL;
 196 #ifdef _IO_MTSAFE_IO
 197   new_f->fpx.file.file._lock = &new_f->lock;
 198 #endif
 199   fp = &new_f->fpx.file.file;
 200   _IO_init (fp, 0);
 201   _IO_JUMPS (fp) = &_IO_proc_jumps;
 202   _IO_file_init (fp);
 203 #if  !_IO_UNIFIED_JUMPTABLES
 204   new_f->fpx.file.vtable = NULL;
 205 #endif
 206   if (_IO_proc_open (fp, command, mode) != NULL)
 207     return fp;
 208   _IO_un_link (fp);
 209   free (new_f);
 210   return NULL;
 211 }
 212
 213 #ifdef strong_alias
 214 strong_alias (_IO_popen, popen);
 215 #endif
 216
 217 int
 218 _IO_proc_close (fp)
 219      _IO_FILE *fp;
 220 {
 221   /* This is not name-space clean. FIXME! */
 222 #if _IO_HAVE_SYS_WAIT
 223   int wstatus;
 224   _IO_proc_file **ptr = &proc_file_chain;
 225   _IO_pid_t wait_pid;
 226   int status = -1;
 227
 228   /* Unlink from proc_file_chain. */
 229   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
 230     {
 231       if (*ptr == (_IO_proc_file *) fp)
 232         {
 233           *ptr = (*ptr)->next;
 234           status = 0;
 235           break;
 236         }
 237     }
 238
 239   if (status < 0 || _IO_close (_IO_fileno(fp)) < 0)
 240     return -1;
 241   /* POSIX.2 Rationale:  "Some historical implementations either block
 242      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
 243      for the child process to terminate.  Since this behavior is not
 244      described in POSIX.2, such implementations are not conforming." */
 245   do
 246     {
 247       wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
 248     }
 249   while (wait_pid == -1 && errno == EINTR);
 250   if (wait_pid == -1)
 251     return -1;
 252   return wstatus;
 253 #else /* !_IO_HAVE_SYS_WAIT */
 254   return -1;
 255 #endif
 256 }
 257
 258 struct _IO_jump_t _IO_proc_jumps = {
 259   JUMP_INIT_DUMMY,
 260   JUMP_INIT(finish, _IO_file_finish),
 261   JUMP_INIT(overflow, _IO_file_overflow),
 262   JUMP_INIT(underflow, _IO_file_underflow),
 263   JUMP_INIT(uflow, _IO_default_uflow),
 264   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 265   JUMP_INIT(xsputn, _IO_file_xsputn),
 266   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 267   JUMP_INIT(seekoff, _IO_file_seekoff),
 268   JUMP_INIT(seekpos, _IO_default_seekpos),
 269   JUMP_INIT(setbuf, _IO_file_setbuf),
 270   JUMP_INIT(sync, _IO_file_sync),
 271   JUMP_INIT(doallocate, _IO_file_doallocate),
 272   JUMP_INIT(read, _IO_file_read),
 273   JUMP_INIT(write, _IO_file_write),
 274   JUMP_INIT(seek, _IO_file_seek),
 275   JUMP_INIT(close, _IO_proc_close),
 276   JUMP_INIT(stat, _IO_file_stat),
 277   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 278   JUMP_INIT(imbue, _IO_default_imbue)
 279 };