libio/oldiopopen.c

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