]>
Commit | Line | Data |
---|---|---|
1 | /* Copyright (C) 1998-2015 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, see | |
17 | <http://www.gnu.org/licenses/>. | |
18 | ||
19 | As a special exception, if you link the code in this file with | |
20 | files compiled with a GNU compiler to produce an executable, | |
21 | that does not cause the resulting executable to be covered by | |
22 | the GNU Lesser General Public License. This exception does not | |
23 | however invalidate any other reasons why the executable file | |
24 | might be covered by the GNU Lesser General Public License. | |
25 | This exception applies to code released by its copyright holders | |
26 | in files containing the exception. */ | |
27 | ||
28 | #define _IO_USE_OLD_IO_FILE | |
29 | #ifndef _POSIX_SOURCE | |
30 | # define _POSIX_SOURCE | |
31 | #endif | |
32 | #include "libioP.h" | |
33 | #include <signal.h> | |
34 | #include <unistd.h> | |
35 | #include <stdlib.h> | |
36 | #ifdef _LIBC | |
37 | # include <unistd.h> | |
38 | #endif | |
39 | #include <sys/types.h> | |
40 | #include <sys/wait.h> | |
41 | ||
42 | #ifndef _IO_fork | |
43 | #ifdef _LIBC | |
44 | #define _IO_fork __fork | |
45 | #else | |
46 | #define _IO_fork fork /* defined in libiberty, if needed */ | |
47 | #endif | |
48 | extern _IO_pid_t _IO_fork (void) __THROW; | |
49 | #endif | |
50 | ||
51 | #include <shlib-compat.h> | |
52 | #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1) | |
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 (int des[2]) __THROW; | |
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 (int fd, int fd2) __THROW; | |
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_complete_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_proc_file *old_proc_file_chain; | |
105 | ||
106 | #ifdef _IO_MTSAFE_IO | |
107 | static _IO_lock_t proc_file_chain_lock = _IO_lock_initializer; | |
108 | ||
109 | static void | |
110 | unlock (void *not_used) | |
111 | { | |
112 | _IO_lock_unlock (proc_file_chain_lock); | |
113 | } | |
114 | #endif | |
115 | ||
116 | _IO_FILE * | |
117 | attribute_compat_text_section | |
118 | _IO_old_proc_open (fp, command, mode) | |
119 | _IO_FILE *fp; | |
120 | const char *command; | |
121 | const char *mode; | |
122 | { | |
123 | volatile int read_or_write; | |
124 | volatile int parent_end, child_end; | |
125 | int pipe_fds[2]; | |
126 | _IO_pid_t child_pid; | |
127 | if (_IO_file_is_open (fp)) | |
128 | return NULL; | |
129 | if (_IO_pipe (pipe_fds) < 0) | |
130 | return NULL; | |
131 | if (mode[0] == 'r' && mode[1] == '\0') | |
132 | { | |
133 | parent_end = pipe_fds[0]; | |
134 | child_end = pipe_fds[1]; | |
135 | read_or_write = _IO_NO_WRITES; | |
136 | } | |
137 | else if (mode[0] == 'w' && mode[1] == '\0') | |
138 | { | |
139 | parent_end = pipe_fds[1]; | |
140 | child_end = pipe_fds[0]; | |
141 | read_or_write = _IO_NO_READS; | |
142 | } | |
143 | else | |
144 | { | |
145 | _IO_close (pipe_fds[0]); | |
146 | _IO_close (pipe_fds[1]); | |
147 | __set_errno (EINVAL); | |
148 | return NULL; | |
149 | } | |
150 | ((_IO_proc_file *) fp)->pid = child_pid = _IO_fork (); | |
151 | if (child_pid == 0) | |
152 | { | |
153 | int child_std_end = mode[0] == 'r' ? 1 : 0; | |
154 | struct _IO_proc_file *p; | |
155 | ||
156 | _IO_close (parent_end); | |
157 | if (child_end != child_std_end) | |
158 | { | |
159 | _IO_dup2 (child_end, child_std_end); | |
160 | _IO_close (child_end); | |
161 | } | |
162 | /* POSIX.2: "popen() shall ensure that any streams from previous | |
163 | popen() calls that remain open in the parent process are closed | |
164 | in the new child process." */ | |
165 | for (p = old_proc_file_chain; p; p = p->next) | |
166 | _IO_close (_IO_fileno ((_IO_FILE *) p)); | |
167 | ||
168 | _IO_execl ("/bin/sh", "sh", "-c", command, (char *) 0); | |
169 | _IO__exit (127); | |
170 | } | |
171 | _IO_close (child_end); | |
172 | if (child_pid < 0) | |
173 | { | |
174 | _IO_close (parent_end); | |
175 | return NULL; | |
176 | } | |
177 | _IO_fileno (fp) = parent_end; | |
178 | ||
179 | /* Link into old_proc_file_chain. */ | |
180 | #ifdef _IO_MTSAFE_IO | |
181 | _IO_cleanup_region_start_noarg (unlock); | |
182 | _IO_lock_lock (proc_file_chain_lock); | |
183 | #endif | |
184 | ((_IO_proc_file *) fp)->next = old_proc_file_chain; | |
185 | old_proc_file_chain = (_IO_proc_file *) fp; | |
186 | #ifdef _IO_MTSAFE_IO | |
187 | _IO_lock_unlock (proc_file_chain_lock); | |
188 | _IO_cleanup_region_end (0); | |
189 | #endif | |
190 | ||
191 | _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES); | |
192 | return fp; | |
193 | } | |
194 | ||
195 | _IO_FILE * | |
196 | attribute_compat_text_section | |
197 | _IO_old_popen (command, mode) | |
198 | const char *command; | |
199 | const char *mode; | |
200 | { | |
201 | struct locked_FILE | |
202 | { | |
203 | struct _IO_proc_file fpx; | |
204 | #ifdef _IO_MTSAFE_IO | |
205 | _IO_lock_t lock; | |
206 | #endif | |
207 | } *new_f; | |
208 | _IO_FILE *fp; | |
209 | ||
210 | new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE)); | |
211 | if (new_f == NULL) | |
212 | return NULL; | |
213 | #ifdef _IO_MTSAFE_IO | |
214 | new_f->fpx.file.file._file._lock = &new_f->lock; | |
215 | #endif | |
216 | fp = &new_f->fpx.file.file._file; | |
217 | _IO_old_init (fp, 0); | |
218 | _IO_JUMPS ((struct _IO_FILE_plus *) &new_f->fpx.file) = &_IO_old_proc_jumps; | |
219 | _IO_old_file_init ((struct _IO_FILE_plus *) &new_f->fpx.file); | |
220 | #if !_IO_UNIFIED_JUMPTABLES | |
221 | new_f->fpx.file.vtable = NULL; | |
222 | #endif | |
223 | if (_IO_old_proc_open (fp, command, mode) != NULL) | |
224 | return fp; | |
225 | _IO_un_link ((struct _IO_FILE_plus *) &new_f->fpx.file); | |
226 | free (new_f); | |
227 | return NULL; | |
228 | } | |
229 | ||
230 | int | |
231 | attribute_compat_text_section | |
232 | _IO_old_proc_close (fp) | |
233 | _IO_FILE *fp; | |
234 | { | |
235 | /* This is not name-space clean. FIXME! */ | |
236 | int wstatus; | |
237 | _IO_proc_file **ptr = &old_proc_file_chain; | |
238 | _IO_pid_t wait_pid; | |
239 | int status = -1; | |
240 | ||
241 | /* Unlink from old_proc_file_chain. */ | |
242 | #ifdef _IO_MTSAFE_IO | |
243 | _IO_cleanup_region_start_noarg (unlock); | |
244 | _IO_lock_lock (proc_file_chain_lock); | |
245 | #endif | |
246 | for ( ; *ptr != NULL; ptr = &(*ptr)->next) | |
247 | { | |
248 | if (*ptr == (_IO_proc_file *) fp) | |
249 | { | |
250 | *ptr = (*ptr)->next; | |
251 | status = 0; | |
252 | break; | |
253 | } | |
254 | } | |
255 | #ifdef _IO_MTSAFE_IO | |
256 | _IO_lock_unlock (proc_file_chain_lock); | |
257 | _IO_cleanup_region_end (0); | |
258 | #endif | |
259 | ||
260 | if (status < 0 || _IO_close (_IO_fileno(fp)) < 0) | |
261 | return -1; | |
262 | /* POSIX.2 Rationale: "Some historical implementations either block | |
263 | or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting | |
264 | for the child process to terminate. Since this behavior is not | |
265 | described in POSIX.2, such implementations are not conforming." */ | |
266 | do | |
267 | { | |
268 | wait_pid = _IO_waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0); | |
269 | } | |
270 | while (wait_pid == -1 && errno == EINTR); | |
271 | if (wait_pid == -1) | |
272 | return -1; | |
273 | return wstatus; | |
274 | } | |
275 | ||
276 | const struct _IO_jump_t _IO_old_proc_jumps = { | |
277 | JUMP_INIT_DUMMY, | |
278 | JUMP_INIT(finish, _IO_old_file_finish), | |
279 | JUMP_INIT(overflow, _IO_old_file_overflow), | |
280 | JUMP_INIT(underflow, _IO_old_file_underflow), | |
281 | JUMP_INIT(uflow, _IO_default_uflow), | |
282 | JUMP_INIT(pbackfail, _IO_default_pbackfail), | |
283 | JUMP_INIT(xsputn, _IO_old_file_xsputn), | |
284 | JUMP_INIT(xsgetn, _IO_default_xsgetn), | |
285 | JUMP_INIT(seekoff, _IO_old_file_seekoff), | |
286 | JUMP_INIT(seekpos, _IO_default_seekpos), | |
287 | JUMP_INIT(setbuf, _IO_old_file_setbuf), | |
288 | JUMP_INIT(sync, _IO_old_file_sync), | |
289 | JUMP_INIT(doallocate, _IO_file_doallocate), | |
290 | JUMP_INIT(read, _IO_file_read), | |
291 | JUMP_INIT(write, _IO_old_file_write), | |
292 | JUMP_INIT(seek, _IO_file_seek), | |
293 | JUMP_INIT(close, _IO_old_proc_close), | |
294 | JUMP_INIT(stat, _IO_file_stat), | |
295 | JUMP_INIT(showmanyc, _IO_default_showmanyc), | |
296 | JUMP_INIT(imbue, _IO_default_imbue) | |
297 | }; | |
298 | ||
299 | strong_alias (_IO_old_popen, __old_popen) | |
300 | compat_symbol (libc, _IO_old_popen, _IO_popen, GLIBC_2_0); | |
301 | compat_symbol (libc, __old_popen, popen, GLIBC_2_0); | |
302 | compat_symbol (libc, _IO_old_proc_open, _IO_proc_open, GLIBC_2_0); | |
303 | compat_symbol (libc, _IO_old_proc_close, _IO_proc_close, GLIBC_2_0); | |
304 | ||
305 | #endif |