libio/oldiopopen.c

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