1: /* Copyright (C) 1993, 1997-2002, 2003, 2004, 2007
    2:    Free Software Foundation, Inc.
    3:    This file is part of the GNU C Library.
    4:    Written by Per Bothner <bothner@cygnus.com>.
    5: 
    6:    The GNU C Library is free software; you can redistribute it and/or
    7:    modify it under the terms of the GNU Lesser General Public
    8:    License as published by the Free Software Foundation; either
    9:    version 2.1 of the License, or (at your option) any later version.
   10: 
   11:    The GNU C Library is distributed in the hope that it will be useful,
   12:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   13:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   14:    Lesser General Public License for more details.
   15: 
   16:    You should have received a copy of the GNU Lesser General Public
   17:    License along with the GNU C Library; if not, write to the Free
   18:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   19:    02111-1307 USA.
   20: 
   21:    As a special exception, if you link the code in this file with
   22:    files compiled with a GNU compiler to produce an executable,
   23:    that does not cause the resulting executable to be covered by
   24:    the GNU Lesser General Public License.  This exception does not
   25:    however invalidate any other reasons why the executable file
   26:    might be covered by the GNU Lesser General Public License.
   27:    This exception applies to code released by its copyright holders
   28:    in files containing the exception.  */
   29: 
   30: #ifndef _POSIX_SOURCE
   31: # define _POSIX_SOURCE
   32: #endif
   33: #include "libioP.h"
   34: #if _IO_HAVE_SYS_WAIT
   35: #include <signal.h>
   36: #include <unistd.h>
   37: #ifdef __STDC__
   38: #include <stdlib.h>
   39: #endif
   40: #ifdef _LIBC
   41: # include <unistd.h>
   42: # include <shlib-compat.h>
   43: # include <not-cancel.h>
   44: #endif
   45: #include <sys/types.h>
   46: #include <sys/wait.h>
   47: 
   48: #ifndef _IO_fork
   49: #ifdef _LIBC
   50: #define _IO_fork __fork
   51: #else
   52: #define _IO_fork fork /* defined in libiberty, if needed */
   53: #endif
   54: extern _IO_pid_t _IO_fork (void) __THROW;
   55: #endif
   56: 
   57: #endif /* _IO_HAVE_SYS_WAIT */
   58: 
   59: #ifndef _IO_pipe
   60: #ifdef _LIBC
   61: #define _IO_pipe __pipe
   62: #else
   63: #define _IO_pipe pipe
   64: #endif
   65: extern int _IO_pipe (int des[2]) __THROW;
   66: #endif
   67: 
   68: #ifndef _IO_dup2
   69: #ifdef _LIBC
   70: #define _IO_dup2 __dup2
   71: #else
   72: #define _IO_dup2 dup2
   73: #endif
   74: extern int _IO_dup2 (int fd, int fd2) __THROW;
   75: #endif
   76: 
   77: #ifndef _IO_waitpid
   78: #ifdef _LIBC
   79: #define _IO_waitpid waitpid_not_cancel
   80: #else
   81: #define _IO_waitpid waitpid
   82: #endif
   83: #endif
   84: 
   85: #ifndef _IO_execl
   86: #define _IO_execl execl
   87: #endif
   88: #ifndef _IO__exit
   89: #define _IO__exit _exit
   90: #endif
   91: 
   92: #ifndef _IO_close
   93: #ifdef _LIBC
   94: #define _IO_close close_not_cancel
   95: #else
   96: #define _IO_close close
   97: #endif
   98: #endif
   99: 
  100: struct _IO_proc_file
  101: {
  102:   struct _IO_FILE_plus file;
  103:   /* Following fields must match those in class procbuf (procbuf.h) */
  104:   _IO_pid_t pid;
  105:   struct _IO_proc_file *next;
  106: };
  107: typedef struct _IO_proc_file _IO_proc_file;
  108: 
  109: static const struct _IO_jump_t _IO_proc_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:         {
  174:           int fd = _IO_fileno ((_IO_FILE *) p);
  175: 
  176:           /* If any stream from previous popen() calls has fileno
  177:              child_std_end, it has been already closed by the dup2 syscall
  178:              above.  */
  179:           if (fd != child_std_end)
  180:             _IO_close (fd);
  181:         }
  182: 
  183:       _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0);
  184:       _IO__exit (127);
  185:     }
  186:   _IO_close (child_end);
  187:   if (child_pid < 0)
  188:     {
  189:       _IO_close (parent_end);
  190:       return NULL;
  191:     }
  192:   _IO_fileno (fp) = parent_end;
  193: 
  194:   /* Link into proc_file_chain. */
  195: #ifdef _IO_MTSAFE_IO
  196:   _IO_cleanup_region_start_noarg (unlock);
  197:   _IO_lock_lock (proc_file_chain_lock);
  198: #endif
  199:   ((_IO_proc_file *) fp)->next = proc_file_chain;
  200:   proc_file_chain = (_IO_proc_file *) fp;
  201: #ifdef _IO_MTSAFE_IO
  202:   _IO_lock_unlock (proc_file_chain_lock);
  203:   _IO_cleanup_region_end (0);
  204: #endif
  205: 
  206:   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
  207:   return fp;
  208: #else /* !_IO_HAVE_SYS_WAIT */
  209:   return NULL;
  210: #endif
  211: }
  212: 
  213: _IO_FILE *
  214: _IO_new_popen (command, mode)
  215:      const char *command;
  216:      const char *mode;
  217: {
  218:   struct locked_FILE
  219:   {
  220:     struct _IO_proc_file fpx;
  221: #ifdef _IO_MTSAFE_IO
  222:     _IO_lock_t lock;
  223: #endif
  224:   } *new_f;
  225:   _IO_FILE *fp;
  226: 
  227:   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
  228:   if (new_f == NULL)
  229:     return NULL;
  230: #ifdef _IO_MTSAFE_IO
  231:   new_f->fpx.file.file._lock = &new_f->lock;
  232: #endif
  233:   fp = &new_f->fpx.file.file;
  234:   INTUSE(_IO_init) (fp, 0);
  235:   _IO_JUMPS (&new_f->fpx.file) = &_IO_proc_jumps;
  236:   _IO_new_file_init (&new_f->fpx.file);
  237: #if  !_IO_UNIFIED_JUMPTABLES
  238:   new_f->fpx.file.vtable = NULL;
  239: #endif
  240:   if (_IO_new_proc_open (fp, command, mode) != NULL)
  241:     return (_IO_FILE *) &new_f->fpx.file;
  242:   INTUSE(_IO_un_link) (&new_f->fpx.file);
  243:   free (new_f);
  244:   return NULL;
  245: }
  246: 
  247: int
  248: _IO_new_proc_close (fp)
  249:      _IO_FILE *fp;
  250: {
  251:   /* This is not name-space clean. FIXME! */
  252: #if _IO_HAVE_SYS_WAIT
  253:   int wstatus;
  254:   _IO_proc_file **ptr = &proc_file_chain;
  255:   _IO_pid_t wait_pid;
  256:   int status = -1;
  257: 
  258:   /* Unlink from proc_file_chain. */
  259: #ifdef _IO_MTSAFE_IO
  260:   _IO_cleanup_region_start_noarg (unlock);
  261:   _IO_lock_lock (proc_file_chain_lock);
  262: #endif
  263:   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
  264:     {
  265:       if (*ptr == (_IO_proc_file *) fp)
  266:         {
  267:           *ptr = (*ptr)->next;
  268:           status = 0;
  269:           break;
  270:         }
  271:     }
  272: #ifdef _IO_MTSAFE_IO
  273:   _IO_lock_unlock (proc_file_chain_lock);
  274:   _IO_cleanup_region_end (0);
  275: #endif
  276: 
  277:   if (status < 0 || _IO_close (_IO_fileno(fp)) < 0)
  278:     return -1;
  279:   /* POSIX.2 Rationale:  "Some historical implementations either block
  280:      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
  281:      for the child process to terminate.  Since this behavior is not
  282:      described in POSIX.2, such implementations are not conforming." */
  283:   do
  284:     {
  285:       wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
  286:     }
  287:   while (wait_pid == -1 && errno == EINTR);
  288:   if (wait_pid == -1)
  289:     return -1;
  290:   return wstatus;
  291: #else /* !_IO_HAVE_SYS_WAIT */
  292:   return -1;
  293: #endif
  294: }
  295: 
  296: static const struct _IO_jump_t _IO_proc_jumps = {
  297:   JUMP_INIT_DUMMY,
  298:   JUMP_INIT(finish, _IO_new_file_finish),
  299:   JUMP_INIT(overflow, _IO_new_file_overflow),
  300:   JUMP_INIT(underflow, _IO_new_file_underflow),
  301:   JUMP_INIT(uflow, INTUSE(_IO_default_uflow)),
  302:   JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)),
  303:   JUMP_INIT(xsputn, _IO_new_file_xsputn),
  304:   JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)),
  305:   JUMP_INIT(seekoff, _IO_new_file_seekoff),
  306:   JUMP_INIT(seekpos, _IO_default_seekpos),
  307:   JUMP_INIT(setbuf, _IO_new_file_setbuf),
  308:   JUMP_INIT(sync, _IO_new_file_sync),
  309:   JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)),
  310:   JUMP_INIT(read, INTUSE(_IO_file_read)),
  311:   JUMP_INIT(write, _IO_new_file_write),
  312:   JUMP_INIT(seek, INTUSE(_IO_file_seek)),
  313:   JUMP_INIT(close, _IO_new_proc_close),
  314:   JUMP_INIT(stat, INTUSE(_IO_file_stat)),
  315:   JUMP_INIT(showmanyc, _IO_default_showmanyc),
  316:   JUMP_INIT(imbue, _IO_default_imbue)
  317: };
  318: 
  319: strong_alias (_IO_new_popen, __new_popen)
  320: versioned_symbol (libc, _IO_new_popen, _IO_popen, GLIBC_2_1);
  321: versioned_symbol (libc, __new_popen, popen, GLIBC_2_1);
  322: versioned_symbol (libc, _IO_new_proc_open, _IO_proc_open, GLIBC_2_1);
  323: versioned_symbol (libc, _IO_new_proc_close, _IO_proc_close, GLIBC_2_1);