1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/* Copyright (C) 2004 Manuel Novoa III <mjn3@codepoet.org>
*
* GNU Library General Public License (LGPL) version 2 or later.
*
* Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details.
*/
/* Jan 1, 2004
*
* Rewrite popen for SUSv3 compliance.
* Added a list of popen()'d to store pids and use waitpid() in pclose().
* Loop on waitpid() failure due to EINTR as required.
* Close parent's popen()'d FILEs in the {v}fork()'d child.
* Fix failure exit code for failed execve().
*/
#define waitpid __waitpid
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/wait.h>
/* uClinux-2.0 has vfork, but Linux 2.0 doesn't */
#include <sys/syscall.h>
#if ! defined __NR_vfork
# define vfork fork
# define VFORK_LOCK ((void) 0)
# define VFORK_UNLOCK ((void) 0)
#endif
#ifdef __UCLIBC_HAS_THREADS__
#include <pthread.h>
static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
# define LOCK __pthread_mutex_lock(&mylock)
# define UNLOCK __pthread_mutex_unlock(&mylock);
#else
# define LOCK ((void) 0)
# define UNLOCK ((void) 0)
#endif
#ifndef VFORK_LOCK
# define VFORK_LOCK LOCK
# define VFORK_UNLOCK UNLOCK
#endif
struct popen_list_item {
struct popen_list_item *next;
FILE *f;
pid_t pid;
};
static struct popen_list_item *popen_list /* = NULL (bss initialized) */;
FILE *popen(const char *command, const char *modes)
{
FILE *fp;
struct popen_list_item *pi;
struct popen_list_item *po;
int pipe_fd[2];
int parent_fd;
int child_fd;
int child_writing; /* Doubles as the desired child fildes. */
pid_t pid;
child_writing = 0; /* Assume child is writing. */
if (modes[0] != 'w') { /* Parent not writing... */
++child_writing; /* so child must be writing. */
if (modes[0] != 'r') { /* Oops! Parent not reading either! */
__set_errno(EINVAL);
goto RET_NULL;
}
}
if (!(pi = malloc(sizeof(struct popen_list_item)))) {
goto RET_NULL;
}
if (pipe(pipe_fd)) {
goto FREE_PI;
}
child_fd = pipe_fd[child_writing];
parent_fd = pipe_fd[1-child_writing];
if (!(fp = fdopen(parent_fd, modes))) {
__close(parent_fd);
__close(child_fd);
goto FREE_PI;
}
VFORK_LOCK;
if ((pid = vfork()) == 0) { /* Child of vfork... */
__close(parent_fd);
if (child_fd != child_writing) {
dup2(child_fd, child_writing);
__close(child_fd);
}
/* SUSv3 requires that any previously popen()'d streams in the
* parent shall be closed in the child. */
for (po = popen_list ; po ; po = po->next) {
__close(po->f->__filedes);
}
execl("/bin/sh", "sh", "-c", command, (char *)0);
/* SUSv3 mandates an exit code of 127 for the child if the
* command interpreter can not be invoked. */
_exit(127);
}
VFORK_UNLOCK;
/* We need to close the child filedes whether vfork failed or
* it succeeded and we're in the parent. */
__close(child_fd);
if (pid > 0) { /* Parent of vfork... */
pi->pid = pid;
pi->f = fp;
LOCK;
pi->next = popen_list;
popen_list = pi;
UNLOCK;
return fp;
}
/* If we get here, vfork failed. */
fclose(fp); /* Will close parent_fd. */
FREE_PI:
free(pi);
RET_NULL:
return NULL;
}
int pclose(FILE *stream)
{
struct popen_list_item *p;
int stat;
pid_t pid;
/* First, find the list entry corresponding to stream and remove it
* from the list. Set p to the list item (NULL if not found). */
LOCK;
if ((p = popen_list) != NULL) {
if (p->f == stream) {
popen_list = p->next;
} else {
struct popen_list_item *t;
do {
t = p;
if (!(p = t->next)) {
__set_errno(EINVAL); /* Not required by SUSv3. */
break;
}
if (p->f == stream) {
t->next = p->next;
break;
}
} while (1);
}
}
UNLOCK;
if (p) {
pid = p->pid; /* Save the pid we need */
free(p); /* and free the list item. */
fclose(stream); /* The SUSv3 example code ignores the return. */
/* SUSv3 specificly requires that pclose not return before the child
* terminates, in order to disallow pclose from returning on EINTR. */
do {
if (waitpid(pid, &stat, 0) >= 0) {
return stat;
}
if (errno != EINTR) {
break;
}
} while (1);
}
return -1;
}
|
