libio/oldiopopen.c

   1 /* Copyright (C) 1998,99,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 #include <shlib-compat.h>
  28 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
  29
  30 #define _IO_USE_OLD_IO_FILE
  31 #ifndef _POSIX_SOURCE
  32 # define _POSIX_SOURCE
  33 #endif
  34 #include "libioP.h"
  35 #if _IO_HAVE_SYS_WAIT
  36 #include <signal.h>
  37 #include <unistd.h>
  38 #ifdef __STDC__
  39 #include <stdlib.h>
  40 #endif
  41 #ifdef _LIBC
  42 # include <unistd.h>
  43 #endif
  44 #include <sys/types.h>
  45 #include <sys/wait.h>
  46
  47 #ifndef _IO_fork
  48 #ifdef _LIBC
  49 #define _IO_fork __vfork
  50 #else
  51 #define _IO_fork vfork /* defined in libiberty, if needed */
  52 #endif
  53 extern _IO_pid_t _IO_fork __P ((void));
  54 #endif
  55
  56 #endif /* _IO_HAVE_SYS_WAIT */
  57
  58 #ifndef _IO_pipe
  59 #ifdef _LIBC
  60 #define _IO_pipe __pipe
  61 #else
  62 #define _IO_pipe pipe
  63 #endif
  64 extern int _IO_pipe __P ((int des[2]));
  65 #endif
  66
  67 #ifndef _IO_dup2
  68 #ifdef _LIBC
  69 #define _IO_dup2 __dup2
  70 #else
  71 #define _IO_dup2 dup2
  72 #endif
  73 extern int _IO_dup2 __P ((int fd, int fd2));
  74 #endif
  75
  76 #ifndef _IO_waitpid
  77 #ifdef _LIBC
  78 #define _IO_waitpid __waitpid
  79 #else
  80 #define _IO_waitpid waitpid
  81 #endif
  82 #endif
  83
  84 #ifndef _IO_execl
  85 #define _IO_execl execl
  86 #endif
  87 #ifndef _IO__exit
  88 #define _IO__exit _exit
  89 #endif
  90
  91 #ifndef _IO_close
  92 #ifdef _LIBC
  93 #define _IO_close __close
  94 #else
  95 #define _IO_close close
  96 #endif
  97 #endif
  98
  99 struct _IO_proc_file
 100 {
 101   struct _IO_FILE_plus file;
 102   /* Following fields must match those in class procbuf (procbuf.h) */
 103   _IO_pid_t pid;
 104   struct _IO_proc_file *next;
 105 };
 106 typedef struct _IO_proc_file _IO_proc_file;
 107
 108 static struct _IO_proc_file *old_proc_file_chain;
 109
 110 _IO_FILE *
 111 _IO_old_proc_open (fp, command, mode)
 112      _IO_FILE *fp;
 113      const char *command;
 114      const char *mode;
 115 {
 116 #if _IO_HAVE_SYS_WAIT
 117   volatile int read_or_write;
 118   volatile int parent_end, child_end;
 119   int pipe_fds[2];
 120   _IO_pid_t child_pid;
 121   if (_IO_file_is_open (fp))
 122     return NULL;
 123   if (_IO_pipe (pipe_fds) < 0)
 124     return NULL;
 125   if (mode[0] == 'r' && mode[1] == '\0')
 126     {
 127       parent_end = pipe_fds[0];
 128       child_end = pipe_fds[1];
 129       read_or_write = _IO_NO_WRITES;
 130     }
 131   else if (mode[0] == 'w' && mode[1] == '\0')
 132     {
 133       parent_end = pipe_fds[1];
 134       child_end = pipe_fds[0];
 135       read_or_write = _IO_NO_READS;
 136     }
 137   else
 138     {
 139       _IO_close (pipe_fds[0]);
 140       _IO_close (pipe_fds[1]);
 141       __set_errno (EINVAL);
 142       return NULL;
 143     }
 144   ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork ();
 145   if (child_pid == 0)
 146     {
 147       int child_std_end = mode[0] == 'r' ? 1 : 0;
 148       struct _IO_proc_file *p;
 149
 150       _IO_close (parent_end);
 151       if (child_end != child_std_end)
 152         {
 153           _IO_dup2 (child_end, child_std_end);
 154           _IO_close (child_end);
 155         }
 156       /* POSIX.2:  "popen() shall ensure that any streams from previous
 157          popen() calls that remain open in the parent process are closed
 158          in the new child process." */
 159       for (p = old_proc_file_chain; p; p = p->next)
 160         _IO_close (_IO_fileno ((_IO_FILE *) p));
 161
 162       _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0);
 163       _IO__exit (127);
 164     }
 165   _IO_close (child_end);
 166   if (child_pid < 0)
 167     {
 168       _IO_close (parent_end);
 169       return NULL;
 170     }
 171   _IO_fileno (fp) = parent_end;
 172
 173   /* Link into old_proc_file_chain. */
 174   ((_IO_proc_file *) fp)->next = old_proc_file_chain;
 175   old_proc_file_chain = (_IO_proc_file *) fp;
 176
 177   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
 178   return fp;
 179 #else /* !_IO_HAVE_SYS_WAIT */
 180   return NULL;
 181 #endif
 182 }
 183
 184 _IO_FILE *
 185 _IO_old_popen (command, mode)
 186      const char *command;
 187      const char *mode;
 188 {
 189   struct locked_FILE
 190   {
 191     struct _IO_proc_file fpx;
 192 #ifdef _IO_MTSAFE_IO
 193     _IO_lock_t lock;
 194 #endif
 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_init (fp, 0);
 206   _IO_JUMPS (&new_f->fpx.file) = &_IO_old_proc_jumps;
 207   _IO_old_file_init (&new_f->fpx.file);
 208 #if  !_IO_UNIFIED_JUMPTABLES
 209   new_f->fpx.file.vtable = NULL;
 210 #endif
 211   if (_IO_old_proc_open (fp, command, mode) != NULL)
 212     return fp;
 213   _IO_un_link (&new_f->fpx.file);
 214   free (new_f);
 215   return NULL;
 216 }
 217
 218 int
 219 _IO_old_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 = &old_proc_file_chain;
 226   _IO_pid_t wait_pid;
 227   int status = -1;
 228
 229   /* Unlink from old_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_old_proc_jumps = {
 260   JUMP_INIT_DUMMY,
 261   JUMP_INIT(finish, _IO_old_file_finish),
 262   JUMP_INIT(overflow, _IO_old_file_overflow),
 263   JUMP_INIT(underflow, _IO_old_file_underflow),
 264   JUMP_INIT(uflow, _IO_default_uflow),
 265   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 266   JUMP_INIT(xsputn, _IO_old_file_xsputn),
 267   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 268   JUMP_INIT(seekoff, _IO_old_file_seekoff),
 269   JUMP_INIT(seekpos, _IO_default_seekpos),
 270   JUMP_INIT(setbuf, _IO_old_file_setbuf),
 271   JUMP_INIT(sync, _IO_old_file_sync),
 272   JUMP_INIT(doallocate, _IO_file_doallocate),
 273   JUMP_INIT(read, _IO_file_read),
 274   JUMP_INIT(write, _IO_old_file_write),
 275   JUMP_INIT(seek, _IO_file_seek),
 276   JUMP_INIT(close, _IO_old_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 strong_alias (_IO_old_popen, __old_popen)
 283 compat_symbol (libc, _IO_old_popen, _IO_popen, GLIBC_2_0);
 284 compat_symbol (libc, __old_popen, popen, GLIBC_2_0);
 285 compat_symbol (libc, _IO_old_proc_open, _IO_proc_open, GLIBC_2_0);
 286 compat_symbol (libc, _IO_old_proc_close, _IO_proc_close, GLIBC_2_0);
 287
 288 #endif