libio/oldiopopen.c

   1 /* Copyright (C) 1998, 1999 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 #define _IO_USE_OLD_IO_FILE
  28 #ifndef _POSIX_SOURCE
  29 # define _POSIX_SOURCE
  30 #endif
  31 #include "libioP.h"
  32 #if _IO_HAVE_SYS_WAIT
  33 #include <signal.h>
  34 #include <unistd.h>
  35 #ifdef __STDC__
  36 #include <stdlib.h>
  37 #endif
  38 #ifdef _LIBC
  39 # include <unistd.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_proc_file *old_proc_file_chain;
 106
 107 _IO_FILE *
 108 _IO_old_proc_open (fp, command, mode)
 109      _IO_FILE *fp;
 110      const char *command;
 111      const char *mode;
 112 {
 113 #if _IO_HAVE_SYS_WAIT
 114   volatile int read_or_write;
 115   volatile int parent_end, child_end;
 116   int pipe_fds[2];
 117   _IO_pid_t child_pid;
 118   if (_IO_file_is_open (fp))
 119     return NULL;
 120   if (_IO_pipe (pipe_fds) < 0)
 121     return NULL;
 122   if (mode[0] == 'r' && mode[1] == '\0')
 123     {
 124       parent_end = pipe_fds[0];
 125       child_end = pipe_fds[1];
 126       read_or_write = _IO_NO_WRITES;
 127     }
 128   else if (mode[0] == 'w' && mode[1] == '\0')
 129     {
 130       parent_end = pipe_fds[1];
 131       child_end = pipe_fds[0];
 132       read_or_write = _IO_NO_READS;
 133     }
 134   else
 135     {
 136       __set_errno (EINVAL);
 137       return NULL;
 138     }
 139   ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork ();
 140   if (child_pid == 0)
 141     {
 142       int child_std_end = mode[0] == 'r' ? 1 : 0;
 143       struct _IO_proc_file *p;
 144
 145       _IO_close (parent_end);
 146       if (child_end != child_std_end)
 147         {
 148           _IO_dup2 (child_end, child_std_end);
 149           _IO_close (child_end);
 150         }
 151       /* POSIX.2:  "popen() shall ensure that any streams from previous
 152          popen() calls that remain open in the parent process are closed
 153          in the new child process." */
 154       for (p = old_proc_file_chain; p; p = p->next)
 155         _IO_close (_IO_fileno ((_IO_FILE *) p));
 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 old_proc_file_chain. */
 169   ((_IO_proc_file *) fp)->next = old_proc_file_chain;
 170   old_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_old_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_old_proc_jumps;
 202   _IO_old_file_init (fp);
 203 #if  !_IO_UNIFIED_JUMPTABLES
 204   new_f->fpx.file.vtable = NULL;
 205 #endif
 206   if (_IO_old_proc_open (fp, command, mode) != NULL)
 207     return fp;
 208   _IO_un_link (fp);
 209   free (new_f);
 210   return NULL;
 211 }
 212
 213 int
 214 _IO_old_proc_close (fp)
 215      _IO_FILE *fp;
 216 {
 217   /* This is not name-space clean. FIXME! */
 218 #if _IO_HAVE_SYS_WAIT
 219   int wstatus;
 220   _IO_proc_file **ptr = &old_proc_file_chain;
 221   _IO_pid_t wait_pid;
 222   int status = -1;
 223
 224   /* Unlink from old_proc_file_chain. */
 225   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
 226     {
 227       if (*ptr == (_IO_proc_file *) fp)
 228         {
 229           *ptr = (*ptr)->next;
 230           status = 0;
 231           break;
 232         }
 233     }
 234
 235   if (status < 0 || _IO_close (_IO_fileno(fp)) < 0)
 236     return -1;
 237   /* POSIX.2 Rationale:  "Some historical implementations either block
 238      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
 239      for the child process to terminate.  Since this behavior is not
 240      described in POSIX.2, such implementations are not conforming." */
 241   do
 242     {
 243       wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
 244     }
 245   while (wait_pid == -1 && errno == EINTR);
 246   if (wait_pid == -1)
 247     return -1;
 248   return wstatus;
 249 #else /* !_IO_HAVE_SYS_WAIT */
 250   return -1;
 251 #endif
 252 }
 253
 254 struct _IO_jump_t _IO_old_proc_jumps = {
 255   JUMP_INIT_DUMMY,
 256   JUMP_INIT(finish, _IO_old_file_finish),
 257   JUMP_INIT(overflow, _IO_old_file_overflow),
 258   JUMP_INIT(underflow, _IO_old_file_underflow),
 259   JUMP_INIT(uflow, _IO_default_uflow),
 260   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 261   JUMP_INIT(xsputn, _IO_old_file_xsputn),
 262   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 263   JUMP_INIT(seekoff, _IO_old_file_seekoff),
 264   JUMP_INIT(seekpos, _IO_default_seekpos),
 265   JUMP_INIT(setbuf, _IO_old_file_setbuf),
 266   JUMP_INIT(sync, _IO_old_file_sync),
 267   JUMP_INIT(doallocate, _IO_file_doallocate),
 268   JUMP_INIT(read, _IO_file_read),
 269   JUMP_INIT(write, _IO_old_file_write),
 270   JUMP_INIT(seek, _IO_file_seek),
 271   JUMP_INIT(close, _IO_old_proc_close),
 272   JUMP_INIT(stat, _IO_file_stat),
 273   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 274   JUMP_INIT(imbue, _IO_default_imbue)
 275 };
 276
 277 strong_alias (_IO_old_popen, __old_popen)
 278 symbol_version (_IO_old_popen, _IO_popen, GLIBC_2.0);
 279 symbol_version (__old_popen, popen, GLIBC_2.0);
 280 symbol_version (_IO_old_proc_open, _IO_proc_open, GLIBC_2.0);
 281 symbol_version (_IO_old_proc_close, _IO_proc_close, GLIBC_2.0);