libio/oldiopopen.c

   1 /* Copyright (C) 1998-2002, 2004, 2012 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 #define _IO_USE_OLD_IO_FILE
  30 #ifndef _POSIX_SOURCE
  31 # define _POSIX_SOURCE
  32 #endif
  33 #include "libioP.h"
  34 #if _IO_HAVE_SYS_WAIT
  35 #include <signal.h>
  36 #include <unistd.h>
  37 #include <stdlib.h>
  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 __fork
  47 #else
  48 #define _IO_fork fork /* defined in libiberty, if needed */
  49 #endif
  50 extern _IO_pid_t _IO_fork (void) __THROW;
  51 #endif
  52
  53 #endif /* _IO_HAVE_SYS_WAIT */
  54
  55 #include <shlib-compat.h>
  56 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
  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 (int des[2]) __THROW;
  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 (int fd, int fd2) __THROW;
  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_complete_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 #ifdef _IO_MTSAFE_IO
 111 static _IO_lock_t proc_file_chain_lock = _IO_lock_initializer;
 112
 113 static void
 114 unlock (void *not_used)
 115 {
 116   _IO_lock_unlock (proc_file_chain_lock);
 117 }
 118 #endif
 119
 120 _IO_FILE *
 121 attribute_compat_text_section
 122 _IO_old_proc_open (fp, command, mode)
 123      _IO_FILE *fp;
 124      const char *command;
 125      const char *mode;
 126 {
 127 #if _IO_HAVE_SYS_WAIT
 128   volatile int read_or_write;
 129   volatile int parent_end, child_end;
 130   int pipe_fds[2];
 131   _IO_pid_t child_pid;
 132   if (_IO_file_is_open (fp))
 133     return NULL;
 134   if (_IO_pipe (pipe_fds) < 0)
 135     return NULL;
 136   if (mode[0] == 'r' && mode[1] == '\0')
 137     {
 138       parent_end = pipe_fds[0];
 139       child_end = pipe_fds[1];
 140       read_or_write = _IO_NO_WRITES;
 141     }
 142   else if (mode[0] == 'w' && mode[1] == '\0')
 143     {
 144       parent_end = pipe_fds[1];
 145       child_end = pipe_fds[0];
 146       read_or_write = _IO_NO_READS;
 147     }
 148   else
 149     {
 150       _IO_close (pipe_fds[0]);
 151       _IO_close (pipe_fds[1]);
 152       __set_errno (EINVAL);
 153       return NULL;
 154     }
 155   ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork ();
 156   if (child_pid == 0)
 157     {
 158       int child_std_end = mode[0] == 'r' ? 1 : 0;
 159       struct _IO_proc_file *p;
 160
 161       _IO_close (parent_end);
 162       if (child_end != child_std_end)
 163         {
 164           _IO_dup2 (child_end, child_std_end);
 165           _IO_close (child_end);
 166         }
 167       /* POSIX.2:  "popen() shall ensure that any streams from previous
 168          popen() calls that remain open in the parent process are closed
 169          in the new child process." */
 170       for (p = old_proc_file_chain; p; p = p->next)
 171         _IO_close (_IO_fileno ((_IO_FILE *) p));
 172
 173       _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0);
 174       _IO__exit (127);
 175     }
 176   _IO_close (child_end);
 177   if (child_pid < 0)
 178     {
 179       _IO_close (parent_end);
 180       return NULL;
 181     }
 182   _IO_fileno (fp) = parent_end;
 183
 184   /* Link into old_proc_file_chain. */
 185 #ifdef _IO_MTSAFE_IO
 186   _IO_cleanup_region_start_noarg (unlock);
 187   _IO_lock_lock (proc_file_chain_lock);
 188 #endif
 189   ((_IO_proc_file *) fp)->next = old_proc_file_chain;
 190   old_proc_file_chain = (_IO_proc_file *) fp;
 191 #ifdef _IO_MTSAFE_IO
 192   _IO_lock_unlock (proc_file_chain_lock);
 193   _IO_cleanup_region_end (0);
 194 #endif
 195
 196   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
 197   return fp;
 198 #else /* !_IO_HAVE_SYS_WAIT */
 199   return NULL;
 200 #endif
 201 }
 202
 203 _IO_FILE *
 204 attribute_compat_text_section
 205 _IO_old_popen (command, mode)
 206      const char *command;
 207      const char *mode;
 208 {
 209   struct locked_FILE
 210   {
 211     struct _IO_proc_file fpx;
 212 #ifdef _IO_MTSAFE_IO
 213     _IO_lock_t lock;
 214 #endif
 215   } *new_f;
 216   _IO_FILE *fp;
 217
 218   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 219   if (new_f == NULL)
 220     return NULL;
 221 #ifdef _IO_MTSAFE_IO
 222   new_f->fpx.file.file._file._lock = &new_f->lock;
 223 #endif
 224   fp = &new_f->fpx.file.file._file;
 225   _IO_old_init (fp, 0);
 226   _IO_JUMPS ((struct _IO_FILE_plus *) &new_f->fpx.file) = &_IO_old_proc_jumps;
 227   _IO_old_file_init ((struct _IO_FILE_plus *) &new_f->fpx.file);
 228 #if  !_IO_UNIFIED_JUMPTABLES
 229   new_f->fpx.file.vtable = NULL;
 230 #endif
 231   if (_IO_old_proc_open (fp, command, mode) != NULL)
 232     return fp;
 233   INTUSE(_IO_un_link) ((struct _IO_FILE_plus *) &new_f->fpx.file);
 234   free (new_f);
 235   return NULL;
 236 }
 237
 238 int
 239 attribute_compat_text_section
 240 _IO_old_proc_close (fp)
 241      _IO_FILE *fp;
 242 {
 243   /* This is not name-space clean. FIXME! */
 244 #if _IO_HAVE_SYS_WAIT
 245   int wstatus;
 246   _IO_proc_file **ptr = &old_proc_file_chain;
 247   _IO_pid_t wait_pid;
 248   int status = -1;
 249
 250   /* Unlink from old_proc_file_chain. */
 251 #ifdef _IO_MTSAFE_IO
 252   _IO_cleanup_region_start_noarg (unlock);
 253   _IO_lock_lock (proc_file_chain_lock);
 254 #endif
 255   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
 256     {
 257       if (*ptr == (_IO_proc_file *) fp)
 258         {
 259           *ptr = (*ptr)->next;
 260           status = 0;
 261           break;
 262         }
 263     }
 264 #ifdef _IO_MTSAFE_IO
 265   _IO_lock_unlock (proc_file_chain_lock);
 266   _IO_cleanup_region_end (0);
 267 #endif
 268
 269   if (status < 0 || _IO_close (_IO_fileno(fp)) < 0)
 270     return -1;
 271   /* POSIX.2 Rationale:  "Some historical implementations either block
 272      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
 273      for the child process to terminate.  Since this behavior is not
 274      described in POSIX.2, such implementations are not conforming." */
 275   do
 276     {
 277       wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
 278     }
 279   while (wait_pid == -1 && errno == EINTR);
 280   if (wait_pid == -1)
 281     return -1;
 282   return wstatus;
 283 #else /* !_IO_HAVE_SYS_WAIT */
 284   return -1;
 285 #endif
 286 }
 287
 288 const struct _IO_jump_t _IO_old_proc_jumps = {
 289   JUMP_INIT_DUMMY,
 290   JUMP_INIT(finish, _IO_old_file_finish),
 291   JUMP_INIT(overflow, _IO_old_file_overflow),
 292   JUMP_INIT(underflow, _IO_old_file_underflow),
 293   JUMP_INIT(uflow, INTUSE(_IO_default_uflow)),
 294   JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)),
 295   JUMP_INIT(xsputn, _IO_old_file_xsputn),
 296   JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)),
 297   JUMP_INIT(seekoff, _IO_old_file_seekoff),
 298   JUMP_INIT(seekpos, _IO_default_seekpos),
 299   JUMP_INIT(setbuf, _IO_old_file_setbuf),
 300   JUMP_INIT(sync, _IO_old_file_sync),
 301   JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)),
 302   JUMP_INIT(read, INTUSE(_IO_file_read)),
 303   JUMP_INIT(write, _IO_old_file_write),
 304   JUMP_INIT(seek, INTUSE(_IO_file_seek)),
 305   JUMP_INIT(close, _IO_old_proc_close),
 306   JUMP_INIT(stat, INTUSE(_IO_file_stat)),
 307   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 308   JUMP_INIT(imbue, _IO_default_imbue)
 309 };
 310
 311 strong_alias (_IO_old_popen, __old_popen)
 312 compat_symbol (libc, _IO_old_popen, _IO_popen, GLIBC_2_0);
 313 compat_symbol (libc, __old_popen, popen, GLIBC_2_0);
 314 compat_symbol (libc, _IO_old_proc_open, _IO_proc_open, GLIBC_2_0);
 315 compat_symbol (libc, _IO_old_proc_close, _IO_proc_close, GLIBC_2_0);
 316
 317 #endif