libio/oldiopopen.c

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