1/* Copyright (C) 1998-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>.
17
18 As a special exception, if you link the code in this file with
19 files compiled with a GNU compiler to produce an executable,
20 that does not cause the resulting executable to be covered by
21 the GNU Lesser General Public License. This exception does not
22 however invalidate any other reasons why the executable file
23 might be covered by the GNU Lesser General Public License.
24 This exception applies to code released by its copyright holders
25 in files containing the exception. */
26
27#define _IO_USE_OLD_IO_FILE
28#include "libioP.h"
29#include <signal.h>
30#include <unistd.h>
31#include <stdlib.h>
32#include <unistd.h>
33#include <sys/types.h>
34#include <sys/wait.h>
35
36#include <shlib-compat.h>
37#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
38
39struct _IO_proc_file
40{
41 struct _IO_FILE_complete_plus file;
42 /* Following fields must match those in class procbuf (procbuf.h) */
43 pid_t pid;
44 struct _IO_proc_file *next;
45};
46typedef struct _IO_proc_file _IO_proc_file;
47
48static struct _IO_proc_file *old_proc_file_chain;
49
50#ifdef _IO_MTSAFE_IO
51static _IO_lock_t proc_file_chain_lock = _IO_lock_initializer;
52
53static void
54unlock (void *not_used)
55{
56 _IO_lock_unlock (proc_file_chain_lock);
57}
58#endif
59
60FILE *
61attribute_compat_text_section
62_IO_old_proc_open (FILE *fp, const char *command, const char *mode)
63{
64 volatile int read_or_write;
65 volatile int parent_end, child_end;
66 int pipe_fds[2];
67 pid_t child_pid;
68 if (_IO_file_is_open (fp))
69 return NULL;
70 if (__pipe (pipe_fds) < 0)
71 return NULL;
72 if (mode[0] == 'r' && mode[1] == '\0')
73 {
74 parent_end = pipe_fds[0];
75 child_end = pipe_fds[1];
76 read_or_write = _IO_NO_WRITES;
77 }
78 else if (mode[0] == 'w' && mode[1] == '\0')
79 {
80 parent_end = pipe_fds[1];
81 child_end = pipe_fds[0];
82 read_or_write = _IO_NO_READS;
83 }
84 else
85 {
86 __close (pipe_fds[0]);
87 __close (pipe_fds[1]);
88 __set_errno (EINVAL);
89 return NULL;
90 }
91 ((_IO_proc_file *) fp)->pid = child_pid = __fork ();
92 if (child_pid == 0)
93 {
94 int child_std_end = mode[0] == 'r' ? 1 : 0;
95 struct _IO_proc_file *p;
96
97 __close (parent_end);
98 if (child_end != child_std_end)
99 {
100 __dup2 (child_end, child_std_end);
101 __close (child_end);
102 }
103 /* POSIX.2: "popen() shall ensure that any streams from previous
104 popen() calls that remain open in the parent process are closed
105 in the new child process." */
106 for (p = old_proc_file_chain; p; p = p->next)
107 __close (_IO_fileno ((FILE *) p));
108
109 execl ("/bin/sh", "sh", "-c", command, (char *) 0);
110 _exit (127);
111 }
112 __close (child_end);
113 if (child_pid < 0)
114 {
115 __close (parent_end);
116 return NULL;
117 }
118 _IO_fileno (fp) = parent_end;
119
120 /* Link into old_proc_file_chain. */
121#ifdef _IO_MTSAFE_IO
122 _IO_cleanup_region_start_noarg (unlock);
123 _IO_lock_lock (proc_file_chain_lock);
124#endif
125 ((_IO_proc_file *) fp)->next = old_proc_file_chain;
126 old_proc_file_chain = (_IO_proc_file *) fp;
127#ifdef _IO_MTSAFE_IO
128 _IO_lock_unlock (proc_file_chain_lock);
129 _IO_cleanup_region_end (0);
130#endif
131
132 _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
133 return fp;
134}
135
136FILE *
137attribute_compat_text_section
138_IO_old_popen (const char *command, const char *mode)
139{
140 struct locked_FILE
141 {
142 struct _IO_proc_file fpx;
143#ifdef _IO_MTSAFE_IO
144 _IO_lock_t lock;
145#endif
146 } *new_f;
147 FILE *fp;
148
149 new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
150 if (new_f == NULL)
151 return NULL;
152#ifdef _IO_MTSAFE_IO
153 new_f->fpx.file.file._file._lock = &new_f->lock;
154#endif
155 fp = &new_f->fpx.file.file._file;
156 _IO_old_init (fp, 0);
157 _IO_JUMPS_FILE_plus (&new_f->fpx.file) = &_IO_old_proc_jumps;
158 _IO_old_file_init_internal ((struct _IO_FILE_plus *) &new_f->fpx.file);
159 if (_IO_old_proc_open (fp, command, mode) != NULL)
160 return fp;
161 _IO_un_link ((struct _IO_FILE_plus *) &new_f->fpx.file);
162 free (new_f);
163 return NULL;
164}
165
166int
167attribute_compat_text_section
168_IO_old_proc_close (FILE *fp)
169{
170 /* This is not name-space clean. FIXME! */
171 int wstatus;
172 _IO_proc_file **ptr = &old_proc_file_chain;
173 pid_t wait_pid;
174 int status = -1;
175
176 /* Unlink from old_proc_file_chain. */
177#ifdef _IO_MTSAFE_IO
178 _IO_cleanup_region_start_noarg (unlock);
179 _IO_lock_lock (proc_file_chain_lock);
180#endif
181 for ( ; *ptr != NULL; ptr = &(*ptr)->next)
182 {
183 if (*ptr == (_IO_proc_file *) fp)
184 {
185 *ptr = (*ptr)->next;
186 status = 0;
187 break;
188 }
189 }
190#ifdef _IO_MTSAFE_IO
191 _IO_lock_unlock (proc_file_chain_lock);
192 _IO_cleanup_region_end (0);
193#endif
194
195 if (status < 0 || __close (_IO_fileno(fp)) < 0)
196 return -1;
197 /* POSIX.2 Rationale: "Some historical implementations either block
198 or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
199 for the child process to terminate. Since this behavior is not
200 described in POSIX.2, such implementations are not conforming." */
201 do
202 {
203 wait_pid = __waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
204 }
205 while (wait_pid == -1 && errno == EINTR);
206 if (wait_pid == -1)
207 return -1;
208 return wstatus;
209}
210
211strong_alias (_IO_old_popen, __old_popen)
212compat_symbol (libc, _IO_old_popen, _IO_popen, GLIBC_2_0);
213compat_symbol (libc, __old_popen, popen, GLIBC_2_0);
214compat_symbol (libc, _IO_old_proc_open, _IO_proc_open, GLIBC_2_0);
215compat_symbol (libc, _IO_old_proc_close, _IO_proc_close, GLIBC_2_0);
216
217#endif
218