libio/oldiopopen.c

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