libio/iopopen.c

   1 /* Copyright (C) 1993, 1997, 1998, 1999 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3    Written by Per Bothner <bothner@cygnus.com>.
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2, or (at
   8    your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this library; see the file COPYING.  If not, write to
  17    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  18    MA 02111-1307, USA.
  19
  20    As a special exception, if you link this library with files
  21    compiled with a GNU compiler to produce an executable, this does
  22    not cause the resulting executable to be covered by the GNU General
  23    Public License.  This exception does not however invalidate any
  24    other reasons why the executable file might be covered by the GNU
  25    General Public License.  */
  26
  27 #ifndef _POSIX_SOURCE
  28 # define _POSIX_SOURCE
  29 #endif
  30 #include "libioP.h"
  31 #if _IO_HAVE_SYS_WAIT
  32 #include <signal.h>
  33 #include <unistd.h>
  34 #ifdef __STDC__
  35 #include <stdlib.h>
  36 #endif
  37 #ifdef _LIBC
  38 # include <unistd.h>
  39 #endif
  40 #include <sys/types.h>
  41 #include <sys/wait.h>
  42
  43 #ifndef _IO_fork
  44 #ifdef _LIBC
  45 #define _IO_fork __vfork
  46 #else
  47 #define _IO_fork vfork /* defined in libiberty, if needed */
  48 #endif
  49 extern _IO_pid_t _IO_fork __P ((void));
  50 #endif
  51
  52 #endif /* _IO_HAVE_SYS_WAIT */
  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 __P ((int des[2]));
  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 __P ((int fd, int fd2));
  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_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_jump_t _IO_wproc_jumps;
 105
 106 static struct _IO_proc_file *proc_file_chain;
 107
 108 _IO_FILE *
 109 _IO_new_proc_open (fp, command, mode)
 110      _IO_FILE *fp;
 111      const char *command;
 112      const char *mode;
 113 {
 114 #if _IO_HAVE_SYS_WAIT
 115   volatile int read_or_write;
 116   volatile int parent_end, child_end;
 117   int pipe_fds[2];
 118   _IO_pid_t child_pid;
 119   if (_IO_file_is_open (fp))
 120     return NULL;
 121   if (_IO_pipe (pipe_fds) < 0)
 122     return NULL;
 123   if (mode[0] == 'r' && mode[1] == '\0')
 124     {
 125       parent_end = pipe_fds[0];
 126       child_end = pipe_fds[1];
 127       read_or_write = _IO_NO_WRITES;
 128     }
 129   else if (mode[0] == 'w' && mode[1] == '\0')
 130     {
 131       parent_end = pipe_fds[1];
 132       child_end = pipe_fds[0];
 133       read_or_write = _IO_NO_READS;
 134     }
 135   else
 136     {
 137       __set_errno (EINVAL);
 138       return NULL;
 139     }
 140   ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork ();
 141   if (child_pid == 0)
 142     {
 143       int child_std_end = mode[0] == 'r' ? 1 : 0;
 144       struct _IO_proc_file *p;
 145
 146       _IO_close (parent_end);
 147       if (child_end != child_std_end)
 148         {
 149           _IO_dup2 (child_end, child_std_end);
 150           _IO_close (child_end);
 151         }
 152       /* POSIX.2:  "popen() shall ensure that any streams from previous
 153          popen() calls that remain open in the parent process are closed
 154          in the new child process." */
 155       for (p = proc_file_chain; p; p = p->next)
 156         _IO_close (_IO_fileno ((_IO_FILE *) p));
 157
 158       _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0);
 159       _IO__exit (127);
 160     }
 161   _IO_close (child_end);
 162   if (child_pid < 0)
 163     {
 164       _IO_close (parent_end);
 165       return NULL;
 166     }
 167   _IO_fileno (fp) = parent_end;
 168
 169   /* Link into proc_file_chain. */
 170   ((_IO_proc_file *) fp)->next = proc_file_chain;
 171   proc_file_chain = (_IO_proc_file *) fp;
 172
 173   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
 174   return fp;
 175 #else /* !_IO_HAVE_SYS_WAIT */
 176   return NULL;
 177 #endif
 178 }
 179
 180 _IO_FILE *
 181 _IO_new_popen (command, mode)
 182      const char *command;
 183      const char *mode;
 184 {
 185   struct locked_FILE
 186   {
 187     struct _IO_proc_file fpx;
 188 #ifdef _IO_MTSAFE_IO
 189     _IO_lock_t lock;
 190 #endif
 191     struct _IO_wide_data wd;
 192   } *new_f;
 193   _IO_FILE *fp;
 194
 195   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 196   if (new_f == NULL)
 197     return NULL;
 198 #ifdef _IO_MTSAFE_IO
 199   new_f->fpx.file.file._lock = &new_f->lock;
 200 #endif
 201   fp = &new_f->fpx.file.file;
 202   _IO_no_init (fp, 0, 0, &new_f->wd, &_IO_wproc_jumps);
 203   _IO_JUMPS (fp) = &_IO_proc_jumps;
 204   _IO_new_file_init (fp);
 205 #if  !_IO_UNIFIED_JUMPTABLES
 206   new_f->fpx.file.vtable = NULL;
 207 #endif
 208   if (_IO_new_proc_open (fp, command, mode) != NULL)
 209     return fp;
 210   _IO_un_link (fp);
 211   free (new_f);
 212   return NULL;
 213 }
 214
 215 int
 216 _IO_new_proc_close (fp)
 217      _IO_FILE *fp;
 218 {
 219   /* This is not name-space clean. FIXME! */
 220 #if _IO_HAVE_SYS_WAIT
 221   int wstatus;
 222   _IO_proc_file **ptr = &proc_file_chain;
 223   _IO_pid_t wait_pid;
 224   int status = -1;
 225
 226   /* Unlink from proc_file_chain. */
 227   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
 228     {
 229       if (*ptr == (_IO_proc_file *) fp)
 230         {
 231           *ptr = (*ptr)->next;
 232           status = 0;
 233           break;
 234         }
 235     }
 236
 237   if (status < 0 || _IO_close (_IO_fileno(fp)) < 0)
 238     return -1;
 239   /* POSIX.2 Rationale:  "Some historical implementations either block
 240      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
 241      for the child process to terminate.  Since this behavior is not
 242      described in POSIX.2, such implementations are not conforming." */
 243   do
 244     {
 245       wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
 246     }
 247   while (wait_pid == -1 && errno == EINTR);
 248   if (wait_pid == -1)
 249     return -1;
 250   return wstatus;
 251 #else /* !_IO_HAVE_SYS_WAIT */
 252   return -1;
 253 #endif
 254 }
 255
 256 struct _IO_jump_t _IO_proc_jumps = {
 257   JUMP_INIT_DUMMY,
 258   JUMP_INIT(finish, _IO_new_file_finish),
 259   JUMP_INIT(overflow, _IO_new_file_overflow),
 260   JUMP_INIT(underflow, _IO_new_file_underflow),
 261   JUMP_INIT(uflow, _IO_default_uflow),
 262   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 263   JUMP_INIT(xsputn, _IO_new_file_xsputn),
 264   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 265   JUMP_INIT(seekoff, _IO_new_file_seekoff),
 266   JUMP_INIT(seekpos, _IO_default_seekpos),
 267   JUMP_INIT(setbuf, _IO_new_file_setbuf),
 268   JUMP_INIT(sync, _IO_new_file_sync),
 269   JUMP_INIT(doallocate, _IO_file_doallocate),
 270   JUMP_INIT(read, _IO_file_read),
 271   JUMP_INIT(write, _IO_new_file_write),
 272   JUMP_INIT(seek, _IO_file_seek),
 273   JUMP_INIT(close, _IO_new_proc_close),
 274   JUMP_INIT(stat, _IO_file_stat),
 275   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 276   JUMP_INIT(imbue, _IO_default_imbue)
 277 };
 278
 279 static struct _IO_jump_t _IO_wproc_jumps = {
 280   JUMP_INIT_DUMMY,
 281   JUMP_INIT(finish, _IO_new_file_finish),
 282   JUMP_INIT(overflow, _IO_new_file_overflow),
 283   JUMP_INIT(underflow, _IO_new_file_underflow),
 284   JUMP_INIT(uflow, _IO_default_uflow),
 285   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 286   JUMP_INIT(xsputn, _IO_new_file_xsputn),
 287   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 288   JUMP_INIT(seekoff, _IO_new_file_seekoff),
 289   JUMP_INIT(seekpos, _IO_default_seekpos),
 290   JUMP_INIT(setbuf, _IO_new_file_setbuf),
 291   JUMP_INIT(sync, _IO_new_file_sync),
 292   JUMP_INIT(doallocate, _IO_file_doallocate),
 293   JUMP_INIT(read, _IO_file_read),
 294   JUMP_INIT(write, _IO_new_file_write),
 295   JUMP_INIT(seek, _IO_file_seek),
 296   JUMP_INIT(close, _IO_new_proc_close),
 297   JUMP_INIT(stat, _IO_file_stat),
 298   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 299   JUMP_INIT(imbue, _IO_default_imbue)
 300 };
 301
 302 #if defined PIC && DO_VERSIONING
 303 strong_alias (_IO_new_popen, __new_popen)
 304 default_symbol_version (_IO_new_popen, _IO_popen, GLIBC_2.1);
 305 default_symbol_version (__new_popen, popen, GLIBC_2.1);
 306 default_symbol_version (_IO_new_proc_open, _IO_proc_open, GLIBC_2.1);
 307 default_symbol_version (_IO_new_proc_close, _IO_proc_close, GLIBC_2.1);
 308 #else
 309 # ifdef strong_alias
 310 strong_alias (_IO_new_popen, popen)
 311 # endif
 312 # ifdef weak_alias
 313 weak_alias (_IO_new_popen, _IO_popen)
 314 weak_alias (_IO_new_proc_open, _IO_proc_open)
 315 weak_alias (_IO_new_proc_close, _IO_proc_close)
 316 # endif
 317 #endif