libio/iopopen.c

   1 /* Copyright (C) 1993, 1997, 1998, 1999, 2000 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 # include <shlib-compat.h>
  40 #endif
  41 #include <sys/types.h>
  42 #include <sys/wait.h>
  43
  44 #ifndef _IO_fork
  45 #ifdef _LIBC
  46 #define _IO_fork __vfork
  47 #else
  48 #define _IO_fork vfork /* defined in libiberty, if needed */
  49 #endif
  50 extern _IO_pid_t _IO_fork __P ((void));
  51 #endif
  52
  53 #endif /* _IO_HAVE_SYS_WAIT */
  54
  55 #ifndef _IO_pipe
  56 #ifdef _LIBC
  57 #define _IO_pipe __pipe
  58 #else
  59 #define _IO_pipe pipe
  60 #endif
  61 extern int _IO_pipe __P ((int des[2]));
  62 #endif
  63
  64 #ifndef _IO_dup2
  65 #ifdef _LIBC
  66 #define _IO_dup2 __dup2
  67 #else
  68 #define _IO_dup2 dup2
  69 #endif
  70 extern int _IO_dup2 __P ((int fd, int fd2));
  71 #endif
  72
  73 #ifndef _IO_waitpid
  74 #ifdef _LIBC
  75 #define _IO_waitpid __waitpid
  76 #else
  77 #define _IO_waitpid waitpid
  78 #endif
  79 #endif
  80
  81 #ifndef _IO_execl
  82 #define _IO_execl execl
  83 #endif
  84 #ifndef _IO__exit
  85 #define _IO__exit _exit
  86 #endif
  87
  88 #ifndef _IO_close
  89 #ifdef _LIBC
  90 #define _IO_close __close
  91 #else
  92 #define _IO_close close
  93 #endif
  94 #endif
  95
  96 struct _IO_proc_file
  97 {
  98   struct _IO_FILE_plus file;
  99   /* Following fields must match those in class procbuf (procbuf.h) */
 100   _IO_pid_t pid;
 101   struct _IO_proc_file *next;
 102 };
 103 typedef struct _IO_proc_file _IO_proc_file;
 104
 105 static struct _IO_jump_t _IO_wproc_jumps;
 106
 107 static struct _IO_proc_file *proc_file_chain;
 108
 109 _IO_FILE *
 110 _IO_new_proc_open (fp, command, mode)
 111      _IO_FILE *fp;
 112      const char *command;
 113      const char *mode;
 114 {
 115 #if _IO_HAVE_SYS_WAIT
 116   volatile int read_or_write;
 117   volatile int parent_end, child_end;
 118   int pipe_fds[2];
 119   _IO_pid_t child_pid;
 120   if (_IO_file_is_open (fp))
 121     return NULL;
 122   if (_IO_pipe (pipe_fds) < 0)
 123     return NULL;
 124   if (mode[0] == 'r' && mode[1] == '\0')
 125     {
 126       parent_end = pipe_fds[0];
 127       child_end = pipe_fds[1];
 128       read_or_write = _IO_NO_WRITES;
 129     }
 130   else if (mode[0] == 'w' && mode[1] == '\0')
 131     {
 132       parent_end = pipe_fds[1];
 133       child_end = pipe_fds[0];
 134       read_or_write = _IO_NO_READS;
 135     }
 136   else
 137     {
 138       _IO_close (pipe_fds[0]);
 139       _IO_close (pipe_fds[1]);
 140       __set_errno (EINVAL);
 141       return NULL;
 142     }
 143   ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork ();
 144   if (child_pid == 0)
 145     {
 146       int child_std_end = mode[0] == 'r' ? 1 : 0;
 147       struct _IO_proc_file *p;
 148
 149       _IO_close (parent_end);
 150       if (child_end != child_std_end)
 151         {
 152           _IO_dup2 (child_end, child_std_end);
 153           _IO_close (child_end);
 154         }
 155       /* POSIX.2:  "popen() shall ensure that any streams from previous
 156          popen() calls that remain open in the parent process are closed
 157          in the new child process." */
 158       for (p = proc_file_chain; p; p = p->next)
 159         _IO_close (_IO_fileno ((_IO_FILE *) p));
 160
 161       _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0);
 162       _IO__exit (127);
 163     }
 164   _IO_close (child_end);
 165   if (child_pid < 0)
 166     {
 167       _IO_close (parent_end);
 168       return NULL;
 169     }
 170   _IO_fileno (fp) = parent_end;
 171
 172   /* Link into proc_file_chain. */
 173   ((_IO_proc_file *) fp)->next = proc_file_chain;
 174   proc_file_chain = (_IO_proc_file *) fp;
 175
 176   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
 177   return fp;
 178 #else /* !_IO_HAVE_SYS_WAIT */
 179   return NULL;
 180 #endif
 181 }
 182
 183 _IO_FILE *
 184 _IO_new_popen (command, mode)
 185      const char *command;
 186      const char *mode;
 187 {
 188   struct locked_FILE
 189   {
 190     struct _IO_proc_file fpx;
 191 #ifdef _IO_MTSAFE_IO
 192     _IO_lock_t lock;
 193 #endif
 194     struct _IO_wide_data wd;
 195   } *new_f;
 196   _IO_FILE *fp;
 197
 198   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 199   if (new_f == NULL)
 200     return NULL;
 201 #ifdef _IO_MTSAFE_IO
 202   new_f->fpx.file.file._lock = &new_f->lock;
 203 #endif
 204   fp = &new_f->fpx.file.file;
 205   _IO_no_init (fp, 0, 0, &new_f->wd, &_IO_wproc_jumps);
 206   _IO_JUMPS (&new_f->fpx.file) = &_IO_proc_jumps;
 207   _IO_new_file_init (&new_f->fpx.file);
 208 #if  !_IO_UNIFIED_JUMPTABLES
 209   new_f->fpx.file.vtable = NULL;
 210 #endif
 211   if (_IO_new_proc_open (fp, command, mode) != NULL)
 212     return (_IO_FILE *) &new_f->fpx.file;
 213   _IO_un_link (&new_f->fpx.file);
 214   free (new_f);
 215   return NULL;
 216 }
 217
 218 int
 219 _IO_new_proc_close (fp)
 220      _IO_FILE *fp;
 221 {
 222   /* This is not name-space clean. FIXME! */
 223 #if _IO_HAVE_SYS_WAIT
 224   int wstatus;
 225   _IO_proc_file **ptr = &proc_file_chain;
 226   _IO_pid_t wait_pid;
 227   int status = -1;
 228
 229   /* Unlink from proc_file_chain. */
 230   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
 231     {
 232       if (*ptr == (_IO_proc_file *) fp)
 233         {
 234           *ptr = (*ptr)->next;
 235           status = 0;
 236           break;
 237         }
 238     }
 239
 240   if (status < 0 || _IO_close (_IO_fileno(fp)) < 0)
 241     return -1;
 242   /* POSIX.2 Rationale:  "Some historical implementations either block
 243      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
 244      for the child process to terminate.  Since this behavior is not
 245      described in POSIX.2, such implementations are not conforming." */
 246   do
 247     {
 248       wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
 249     }
 250   while (wait_pid == -1 && errno == EINTR);
 251   if (wait_pid == -1)
 252     return -1;
 253   return wstatus;
 254 #else /* !_IO_HAVE_SYS_WAIT */
 255   return -1;
 256 #endif
 257 }
 258
 259 struct _IO_jump_t _IO_proc_jumps = {
 260   JUMP_INIT_DUMMY,
 261   JUMP_INIT(finish, _IO_new_file_finish),
 262   JUMP_INIT(overflow, _IO_new_file_overflow),
 263   JUMP_INIT(underflow, _IO_new_file_underflow),
 264   JUMP_INIT(uflow, _IO_default_uflow),
 265   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 266   JUMP_INIT(xsputn, _IO_new_file_xsputn),
 267   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 268   JUMP_INIT(seekoff, _IO_new_file_seekoff),
 269   JUMP_INIT(seekpos, _IO_default_seekpos),
 270   JUMP_INIT(setbuf, _IO_new_file_setbuf),
 271   JUMP_INIT(sync, _IO_new_file_sync),
 272   JUMP_INIT(doallocate, _IO_file_doallocate),
 273   JUMP_INIT(read, _IO_file_read),
 274   JUMP_INIT(write, _IO_new_file_write),
 275   JUMP_INIT(seek, _IO_file_seek),
 276   JUMP_INIT(close, _IO_new_proc_close),
 277   JUMP_INIT(stat, _IO_file_stat),
 278   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 279   JUMP_INIT(imbue, _IO_default_imbue)
 280 };
 281
 282 static struct _IO_jump_t _IO_wproc_jumps = {
 283   JUMP_INIT_DUMMY,
 284   JUMP_INIT(finish, _IO_new_file_finish),
 285   JUMP_INIT(overflow, _IO_new_file_overflow),
 286   JUMP_INIT(underflow, _IO_new_file_underflow),
 287   JUMP_INIT(uflow, _IO_default_uflow),
 288   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 289   JUMP_INIT(xsputn, _IO_new_file_xsputn),
 290   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 291   JUMP_INIT(seekoff, _IO_new_file_seekoff),
 292   JUMP_INIT(seekpos, _IO_default_seekpos),
 293   JUMP_INIT(setbuf, _IO_new_file_setbuf),
 294   JUMP_INIT(sync, _IO_new_file_sync),
 295   JUMP_INIT(doallocate, _IO_file_doallocate),
 296   JUMP_INIT(read, _IO_file_read),
 297   JUMP_INIT(write, _IO_new_file_write),
 298   JUMP_INIT(seek, _IO_file_seek),
 299   JUMP_INIT(close, _IO_new_proc_close),
 300   JUMP_INIT(stat, _IO_file_stat),
 301   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 302   JUMP_INIT(imbue, _IO_default_imbue)
 303 };
 304
 305 strong_alias (_IO_new_popen, __new_popen)
 306 versioned_symbol (libc, _IO_new_popen, _IO_popen, GLIBC_2_1);
 307 versioned_symbol (libc, __new_popen, popen, GLIBC_2_1);
 308 versioned_symbol (libc, _IO_new_proc_open, _IO_proc_open, GLIBC_2_1);
 309 versioned_symbol (libc, _IO_new_proc_close, _IO_proc_close, GLIBC_2_1);