libio/oldiopopen.c

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