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