1 /* Copyright (C) 1993, 1997-2002, 2003 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 33 #include <sys/types.h> 34 #include <sys/wait.h> 35 #include "libioP.h" 36 #if _IO_HAVE_SYS_WAIT 37 #include <signal.h> 38 #include <unistd.h> 39 #ifdef __STDC__ 40 #include <stdlib.h> 41 #endif 42 #ifdef _LIBC 43 # include <unistd.h> 44 # include <shlib-compat.h> 45 #endif 46 47 #endif /* _IO_HAVE_SYS_WAIT */ 48 49 #ifndef _IO_close 50 # define _IO_close close 51 #endif 52 53 struct _IO_proc_file 54 { 55 struct _IO_FILE_plus file; 56 /* Following fields must match those in class procbuf (procbuf.h) */ 57 _IO_pid_t pid; 58 struct _IO_proc_file *next; 59 }; 60 typedef struct _IO_proc_file _IO_proc_file; 61 62 static struct _IO_jump_t _IO_proc_jumps; 63 static struct _IO_jump_t _IO_wproc_jumps; 64 65 static struct _IO_proc_file *proc_file_chain; 66 67 #ifdef _IO_MTSAFE_IO 68 static _IO_lock_t proc_file_chain_lock = _IO_lock_initializer; 69 70 #if 0 71 static void 72 unlock (void *not_used) 73 { 74 _IO_lock_unlock (proc_file_chain_lock); 75 } 76 #endif 77 #endif 78 79 _IO_FILE * 80 _IO_new_proc_open (fp, command, mode) 81 _IO_FILE *fp; 82 const char *command; 83 const char *mode; 84 { 85 #if _IO_HAVE_SYS_WAIT 86 volatile int read_or_write; 87 volatile int parent_end, child_end; 88 int pipe_fds[2]; 89 _IO_pid_t child_pid; 90 if (_IO_file_is_open (fp)) 91 return NULL; 92 if (pipe(pipe_fds) < 0) 93 return NULL; 94 if (mode[0] == 'r' && mode[1] == '\0') 95 { 96 parent_end = pipe_fds[0]; 97 child_end = pipe_fds[1]; 98 read_or_write = _IO_NO_WRITES; 99 } 100 else if (mode[0] == 'w' && mode[1] == '\0') 101 { 102 parent_end = pipe_fds[1]; 103 child_end = pipe_fds[0]; 104 read_or_write = _IO_NO_READS; 105 } 106 else 107 { 108 _IO_close (pipe_fds[0]); 109 _IO_close (pipe_fds[1]); 110 __set_errno (EINVAL); 111 return NULL; 112 } 113 ((_IO_proc_file *) fp)->pid = child_pid = fork(); 114 if (child_pid == 0) 115 { 116 int child_std_end = mode[0] == 'r' ? 1 : 0; 117 struct _IO_proc_file *p; 118 119 _IO_close (parent_end); 120 if (child_end != child_std_end) 121 { 122 dup2(child_end, child_std_end); 123 _IO_close (child_end); 124 } 125 /* POSIX.2: "popen() shall ensure that any streams from previous 126 popen() calls that remain open in the parent process are closed 127 in the new child process." */ 128 for (p = proc_file_chain; p; p = p->next) 129 _IO_close (_IO_fileno ((_IO_FILE *) p)); 130 131 execl("/bin/sh", "sh", "-c", command, (char *)0); 132 _exit(127); 133 } 134 _IO_close (child_end); 135 if (child_pid < 0) 136 { 137 _IO_close (parent_end); 138 return NULL; 139 } 140 _IO_fileno (fp) = parent_end; 141 142 /* Link into proc_file_chain. */ 143 #ifdef _IO_MTSAFE_IO 144 _IO_cleanup_region_start_noarg (unlock); 145 _IO_lock_lock (proc_file_chain_lock); 146 #endif 147 ((_IO_proc_file *) fp)->next = proc_file_chain; 148 proc_file_chain = (_IO_proc_file *) fp; 149 #ifdef _IO_MTSAFE_IO 150 _IO_lock_unlock (proc_file_chain_lock); 151 _IO_cleanup_region_end (0); 152 #endif 153 154 _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES); 155 return fp; 156 #else /* !_IO_HAVE_SYS_WAIT */ 157 return NULL; 158 #endif 159 } 160 161 _IO_FILE * 162 _IO_new_popen (command, mode) 163 const char *command; 164 const char *mode; 165 { 166 struct locked_FILE 167 { 168 struct _IO_proc_file fpx; 169 #ifdef _IO_MTSAFE_IO 170 _IO_lock_t lock; 171 #endif 172 struct _IO_wide_data wd; 173 } *new_f; 174 _IO_FILE *fp; 175 176 new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE)); 177 if (new_f == NULL) 178 return NULL; 179 #ifdef _IO_MTSAFE_IO 180 new_f->fpx.file.file._lock = &new_f->lock; 181 #endif 182 fp = &new_f->fpx.file.file; 183 _IO_no_init (fp, 0, 0, &new_f->wd, &_IO_wproc_jumps); 184 _IO_JUMPS (&new_f->fpx.file) = &_IO_proc_jumps; 185 _IO_new_file_init (&new_f->fpx.file); 186 #if !_IO_UNIFIED_JUMPTABLES 187 new_f->fpx.file.vtable = NULL; 188 #endif 189 if (_IO_new_proc_open (fp, command, mode) != NULL) 190 return (_IO_FILE *) &new_f->fpx.file; 191 INTUSE(_IO_un_link) (&new_f->fpx.file); 192 free (new_f); 193 return NULL; 194 } 195 196 int 197 _IO_new_proc_close (fp) 198 _IO_FILE *fp; 199 { 200 /* This is not name-space clean. FIXME! */ 201 #if _IO_HAVE_SYS_WAIT 202 int wstatus; 203 _IO_proc_file **ptr = &proc_file_chain; 204 _IO_pid_t wait_pid; 205 int status = -1; 206 207 /* Unlink from proc_file_chain. */ 208 #ifdef _IO_MTSAFE_IO 209 _IO_cleanup_region_start_noarg (unlock); 210 _IO_lock_lock (proc_file_chain_lock); 211 #endif 212 for ( ; *ptr != NULL; ptr = &(*ptr)->next) 213 { 214 if (*ptr == (_IO_proc_file *) fp) 215 { 216 *ptr = (*ptr)->next; 217 status = 0; 218 break; 219 } 220 } 221 #ifdef _IO_MTSAFE_IO 222 _IO_lock_unlock (proc_file_chain_lock); 223 _IO_cleanup_region_end (0); 224 #endif 225 226 if (status < 0 || _IO_close (_IO_fileno(fp)) < 0) 227 return -1; 228 /* POSIX.2 Rationale: "Some historical implementations either block 229 or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting 230 for the child process to terminate. Since this behavior is not 231 described in POSIX.2, such implementations are not conforming." */ 232 do 233 { 234 wait_pid = waitpid(((_IO_proc_file *) fp)->pid, &wstatus, 0); 235 } 236 while (wait_pid == -1 && errno == EINTR); 237 if (wait_pid == -1) 238 return -1; 239 return wstatus; 240 #else /* !_IO_HAVE_SYS_WAIT */ 241 return -1; 242 #endif 243 } 244 245 static struct _IO_jump_t _IO_proc_jumps = { 246 JUMP_INIT_DUMMY, 247 JUMP_INIT(finish, _IO_new_file_finish), 248 JUMP_INIT(overflow, _IO_new_file_overflow), 249 JUMP_INIT(underflow, _IO_new_file_underflow), 250 JUMP_INIT(uflow, INTUSE(_IO_default_uflow)), 251 JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)), 252 JUMP_INIT(xsputn, _IO_new_file_xsputn), 253 JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)), 254 JUMP_INIT(seekoff, _IO_new_file_seekoff), 255 JUMP_INIT(seekpos, _IO_default_seekpos), 256 JUMP_INIT(setbuf, _IO_new_file_setbuf), 257 JUMP_INIT(sync, _IO_new_file_sync), 258 JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)), 259 JUMP_INIT(read, INTUSE(_IO_file_read)), 260 JUMP_INIT(write, _IO_new_file_write), 261 JUMP_INIT(seek, INTUSE(_IO_file_seek)), 262 JUMP_INIT(close, _IO_new_proc_close), 263 JUMP_INIT(stat, INTUSE(_IO_file_stat)), 264 JUMP_INIT(showmanyc, _IO_default_showmanyc), 265 JUMP_INIT(imbue, _IO_default_imbue) 266 }; 267 268 static struct _IO_jump_t _IO_wproc_jumps = { 269 JUMP_INIT_DUMMY, 270 JUMP_INIT(finish, _IO_new_file_finish), 271 JUMP_INIT(overflow, _IO_new_file_overflow), 272 JUMP_INIT(underflow, _IO_new_file_underflow), 273 JUMP_INIT(uflow, INTUSE(_IO_default_uflow)), 274 JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)), 275 JUMP_INIT(xsputn, _IO_new_file_xsputn), 276 JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)), 277 JUMP_INIT(seekoff, _IO_new_file_seekoff), 278 JUMP_INIT(seekpos, _IO_default_seekpos), 279 JUMP_INIT(setbuf, _IO_new_file_setbuf), 280 JUMP_INIT(sync, _IO_new_file_sync), 281 JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)), 282 JUMP_INIT(read, INTUSE(_IO_file_read)), 283 JUMP_INIT(write, _IO_new_file_write), 284 JUMP_INIT(seek, INTUSE(_IO_file_seek)), 285 JUMP_INIT(close, _IO_new_proc_close), 286 JUMP_INIT(stat, INTUSE(_IO_file_stat)), 287 JUMP_INIT(showmanyc, _IO_default_showmanyc), 288 JUMP_INIT(imbue, _IO_default_imbue) 289 }; 290 291 strong_alias (_IO_new_popen, __new_popen) 292 versioned_symbol (libc, _IO_new_popen, _IO_popen, GLIBC_2_1); 293 versioned_symbol (libc, __new_popen, popen, GLIBC_2_1); 294 versioned_symbol (libc, _IO_new_proc_open, _IO_proc_open, GLIBC_2_1); 295 versioned_symbol (libc, _IO_new_proc_close, _IO_proc_close, GLIBC_2_1); 296