libio/iopopen.c

   1 /* Copyright (C) 1993, 1997-2002, 2003, 2004 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 #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 #ifdef __STDC__
  37 #include <stdlib.h>
  38 #endif
  39 #ifdef _LIBC
  40 # include <unistd.h>
  41 # include <shlib-compat.h>
  42 # include <not-cancel.h>
  43 #endif
  44 #include <sys/types.h>
  45 #include <sys/wait.h>
  46
  47 #ifndef _IO_fork
  48 #ifdef _LIBC
  49 #define _IO_fork __fork
  50 #else
  51 #define _IO_fork fork /* defined in libiberty, if needed */
  52 #endif
  53 extern _IO_pid_t _IO_fork __P ((void));
  54 #endif
  55
  56 #endif /* _IO_HAVE_SYS_WAIT */
  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 __P ((int des[2]));
  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 __P ((int fd, int fd2));
  74 #endif
  75
  76 #ifndef _IO_waitpid
  77 #ifdef _LIBC
  78 #define _IO_waitpid waitpid_not_cancel
  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_not_cancel
  94 #else
  95 #define _IO_close close
  96 #endif
  97 #endif
  98
  99 struct _IO_proc_file
 100 {
 101   struct _IO_FILE_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 const struct _IO_jump_t _IO_proc_jumps;
 109 static const struct _IO_jump_t _IO_wproc_jumps;
 110
 111 static struct _IO_proc_file *proc_file_chain;
 112
 113 #ifdef _IO_MTSAFE_IO
 114 static _IO_lock_t proc_file_chain_lock = _IO_lock_initializer;
 115
 116 static void
 117 unlock (void *not_used)
 118 {
 119   _IO_lock_unlock (proc_file_chain_lock);
 120 }
 121 #endif
 122
 123 _IO_FILE *
 124 _IO_new_proc_open (fp, command, mode)
 125      _IO_FILE *fp;
 126      const char *command;
 127      const char *mode;
 128 {
 129 #if _IO_HAVE_SYS_WAIT
 130   volatile int read_or_write;
 131   volatile int parent_end, child_end;
 132   int pipe_fds[2];
 133   _IO_pid_t child_pid;
 134   if (_IO_file_is_open (fp))
 135     return NULL;
 136   if (_IO_pipe (pipe_fds) < 0)
 137     return NULL;
 138   if (mode[0] == 'r' && mode[1] == '\0')
 139     {
 140       parent_end = pipe_fds[0];
 141       child_end = pipe_fds[1];
 142       read_or_write = _IO_NO_WRITES;
 143     }
 144   else if (mode[0] == 'w' && mode[1] == '\0')
 145     {
 146       parent_end = pipe_fds[1];
 147       child_end = pipe_fds[0];
 148       read_or_write = _IO_NO_READS;
 149     }
 150   else
 151     {
 152       _IO_close (pipe_fds[0]);
 153       _IO_close (pipe_fds[1]);
 154       __set_errno (EINVAL);
 155       return NULL;
 156     }
 157   ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork ();
 158   if (child_pid == 0)
 159     {
 160       int child_std_end = mode[0] == 'r' ? 1 : 0;
 161       struct _IO_proc_file *p;
 162
 163       _IO_close (parent_end);
 164       if (child_end != child_std_end)
 165         {
 166           _IO_dup2 (child_end, child_std_end);
 167           _IO_close (child_end);
 168         }
 169       /* POSIX.2:  "popen() shall ensure that any streams from previous
 170          popen() calls that remain open in the parent process are closed
 171          in the new child process." */
 172       for (p = proc_file_chain; p; p = p->next)
 173         _IO_close (_IO_fileno ((_IO_FILE *) p));
 174
 175       _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0);
 176       _IO__exit (127);
 177     }
 178   _IO_close (child_end);
 179   if (child_pid < 0)
 180     {
 181       _IO_close (parent_end);
 182       return NULL;
 183     }
 184   _IO_fileno (fp) = parent_end;
 185
 186   /* Link into proc_file_chain. */
 187 #ifdef _IO_MTSAFE_IO
 188   _IO_cleanup_region_start_noarg (unlock);
 189   _IO_lock_lock (proc_file_chain_lock);
 190 #endif
 191   ((_IO_proc_file *) fp)->next = proc_file_chain;
 192   proc_file_chain = (_IO_proc_file *) fp;
 193 #ifdef _IO_MTSAFE_IO
 194   _IO_lock_unlock (proc_file_chain_lock);
 195   _IO_cleanup_region_end (0);
 196 #endif
 197
 198   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
 199   return fp;
 200 #else /* !_IO_HAVE_SYS_WAIT */
 201   return NULL;
 202 #endif
 203 }
 204
 205 _IO_FILE *
 206 _IO_new_popen (command, mode)
 207      const char *command;
 208      const char *mode;
 209 {
 210   struct locked_FILE
 211   {
 212     struct _IO_proc_file fpx;
 213 #ifdef _IO_MTSAFE_IO
 214     _IO_lock_t lock;
 215 #endif
 216     struct _IO_wide_data wd;
 217   } *new_f;
 218   _IO_FILE *fp;
 219
 220   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 221   if (new_f == NULL)
 222     return NULL;
 223 #ifdef _IO_MTSAFE_IO
 224   new_f->fpx.file.file._lock = &new_f->lock;
 225 #endif
 226   fp = &new_f->fpx.file.file;
 227   _IO_no_init (fp, 0, 0, &new_f->wd, &_IO_wproc_jumps);
 228   _IO_JUMPS (&new_f->fpx.file) = &_IO_proc_jumps;
 229   _IO_new_file_init (&new_f->fpx.file);
 230 #if  !_IO_UNIFIED_JUMPTABLES
 231   new_f->fpx.file.vtable = NULL;
 232 #endif
 233   if (_IO_new_proc_open (fp, command, mode) != NULL)
 234     return (_IO_FILE *) &new_f->fpx.file;
 235   INTUSE(_IO_un_link) (&new_f->fpx.file);
 236   free (new_f);
 237   return NULL;
 238 }
 239
 240 int
 241 _IO_new_proc_close (fp)
 242      _IO_FILE *fp;
 243 {
 244   /* This is not name-space clean. FIXME! */
 245 #if _IO_HAVE_SYS_WAIT
 246   int wstatus;
 247   _IO_proc_file **ptr = &proc_file_chain;
 248   _IO_pid_t wait_pid;
 249   int status = -1;
 250
 251   /* Unlink from proc_file_chain. */
 252 #ifdef _IO_MTSAFE_IO
 253   _IO_cleanup_region_start_noarg (unlock);
 254   _IO_lock_lock (proc_file_chain_lock);
 255 #endif
 256   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
 257     {
 258       if (*ptr == (_IO_proc_file *) fp)
 259         {
 260           *ptr = (*ptr)->next;
 261           status = 0;
 262           break;
 263         }
 264     }
 265 #ifdef _IO_MTSAFE_IO
 266   _IO_lock_unlock (proc_file_chain_lock);
 267   _IO_cleanup_region_end (0);
 268 #endif
 269
 270   if (status < 0 || _IO_close (_IO_fileno(fp)) < 0)
 271     return -1;
 272   /* POSIX.2 Rationale:  "Some historical implementations either block
 273      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
 274      for the child process to terminate.  Since this behavior is not
 275      described in POSIX.2, such implementations are not conforming." */
 276   do
 277     {
 278       wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
 279     }
 280   while (wait_pid == -1 && errno == EINTR);
 281   if (wait_pid == -1)
 282     return -1;
 283   return wstatus;
 284 #else /* !_IO_HAVE_SYS_WAIT */
 285   return -1;
 286 #endif
 287 }
 288
 289 static const struct _IO_jump_t _IO_proc_jumps = {
 290   JUMP_INIT_DUMMY,
 291   JUMP_INIT(finish, _IO_new_file_finish),
 292   JUMP_INIT(overflow, _IO_new_file_overflow),
 293   JUMP_INIT(underflow, _IO_new_file_underflow),
 294   JUMP_INIT(uflow, INTUSE(_IO_default_uflow)),
 295   JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)),
 296   JUMP_INIT(xsputn, _IO_new_file_xsputn),
 297   JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)),
 298   JUMP_INIT(seekoff, _IO_new_file_seekoff),
 299   JUMP_INIT(seekpos, _IO_default_seekpos),
 300   JUMP_INIT(setbuf, _IO_new_file_setbuf),
 301   JUMP_INIT(sync, _IO_new_file_sync),
 302   JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)),
 303   JUMP_INIT(read, INTUSE(_IO_file_read)),
 304   JUMP_INIT(write, _IO_new_file_write),
 305   JUMP_INIT(seek, INTUSE(_IO_file_seek)),
 306   JUMP_INIT(close, _IO_new_proc_close),
 307   JUMP_INIT(stat, INTUSE(_IO_file_stat)),
 308   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 309   JUMP_INIT(imbue, _IO_default_imbue)
 310 };
 311
 312 static const struct _IO_jump_t _IO_wproc_jumps = {
 313   JUMP_INIT_DUMMY,
 314   JUMP_INIT(finish, _IO_new_file_finish),
 315   JUMP_INIT(overflow, _IO_new_file_overflow),
 316   JUMP_INIT(underflow, _IO_new_file_underflow),
 317   JUMP_INIT(uflow, INTUSE(_IO_default_uflow)),
 318   JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)),
 319   JUMP_INIT(xsputn, _IO_new_file_xsputn),
 320   JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)),
 321   JUMP_INIT(seekoff, _IO_new_file_seekoff),
 322   JUMP_INIT(seekpos, _IO_default_seekpos),
 323   JUMP_INIT(setbuf, _IO_new_file_setbuf),
 324   JUMP_INIT(sync, _IO_new_file_sync),
 325   JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)),
 326   JUMP_INIT(read, INTUSE(_IO_file_read)),
 327   JUMP_INIT(write, _IO_new_file_write),
 328   JUMP_INIT(seek, INTUSE(_IO_file_seek)),
 329   JUMP_INIT(close, _IO_new_proc_close),
 330   JUMP_INIT(stat, INTUSE(_IO_file_stat)),
 331   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 332   JUMP_INIT(imbue, _IO_default_imbue)
 333 };
 334
 335 strong_alias (_IO_new_popen, __new_popen)
 336 versioned_symbol (libc, _IO_new_popen, _IO_popen, GLIBC_2_1);
 337 versioned_symbol (libc, __new_popen, popen, GLIBC_2_1);
 338 versioned_symbol (libc, _IO_new_proc_open, _IO_proc_open, GLIBC_2_1);
 339 versioned_symbol (libc, _IO_new_proc_close, _IO_proc_close, GLIBC_2_1);