libio/iopopen.c

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