Line data Source code
1 : /*
2 : * Copyright (c) 1998 - 2001, 2004 Kungliga Tekniska Högskolan
3 : * (Royal Institute of Technology, Stockholm, Sweden).
4 : * All rights reserved.
5 : *
6 : * Redistribution and use in source and binary forms, with or without
7 : * modification, are permitted provided that the following conditions
8 : * are met:
9 : *
10 : * 1. Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer.
12 : *
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * 3. Neither the name of the Institute nor the names of its contributors
18 : * may be used to endorse or promote products derived from this software
19 : * without specific prior written permission.
20 : *
21 : * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 : * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 : * SUCH DAMAGE.
32 : */
33 :
34 : #include <config.h>
35 :
36 : #include <stdarg.h>
37 : #include <stdlib.h>
38 : #ifdef HAVE_SYS_TYPES_H
39 : #include <sys/types.h>
40 : #endif
41 : #ifdef HAVE_SYS_WAIT_H
42 : #include <sys/wait.h>
43 : #endif
44 : #ifdef HAVE_UNISTD_H
45 : #include <unistd.h>
46 : #endif
47 : #include <errno.h>
48 :
49 : #include "roken.h"
50 :
51 : #define EX_NOEXEC 126
52 : #define EX_NOTFOUND 127
53 :
54 : /* return values:
55 : SE_E_UNSPECIFIED on `unspecified' system errors
56 : SE_E_FORKFAILED on fork failures
57 : SE_E_WAITPIDFAILED on waitpid errors
58 : SE_E_EXECTIMEOUT exec timeout
59 : 0- is return value from subprocess
60 : SE_E_NOEXEC if the program couldn't be executed
61 : SE_E_NOTFOUND if the program couldn't be found
62 : 128- is 128 + signal that killed subprocess
63 :
64 : possible values `func' can return:
65 : ((time_t)-2) exit loop w/o killing child and return
66 : `exec timeout'/-4 from simple_exec
67 : ((time_t)-1) kill child with SIGTERM and wait for child to exit
68 : 0 don't timeout again
69 : n seconds to next timeout
70 : */
71 :
72 : static int sig_alarm;
73 :
74 : static RETSIGTYPE
75 0 : sigtimeout(int sig)
76 : {
77 0 : sig_alarm = 1;
78 0 : SIGRETURN(0);
79 : }
80 :
81 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
82 0 : wait_for_process_timed(pid_t pid, time_t (*func)(void *),
83 : void *ptr, time_t timeout)
84 : {
85 0 : RETSIGTYPE (*old_func)(int sig) = NULL;
86 0 : unsigned int oldtime = 0;
87 0 : int ret;
88 :
89 0 : sig_alarm = 0;
90 :
91 0 : if (func) {
92 0 : old_func = signal(SIGALRM, sigtimeout);
93 0 : oldtime = alarm(timeout);
94 : }
95 :
96 0 : while(1) {
97 : int status;
98 :
99 0 : while(waitpid(pid, &status, 0) < 0) {
100 0 : if (errno != EINTR) {
101 0 : ret = SE_E_WAITPIDFAILED;
102 0 : goto out;
103 : }
104 0 : if (func == NULL)
105 0 : continue;
106 0 : if (sig_alarm == 0)
107 0 : continue;
108 0 : timeout = (*func)(ptr);
109 0 : if (timeout == (time_t)-1) {
110 0 : kill(pid, SIGTERM);
111 0 : continue;
112 0 : } else if (timeout == (time_t)-2) {
113 0 : ret = SE_E_EXECTIMEOUT;
114 0 : goto out;
115 : }
116 0 : alarm(timeout);
117 : }
118 0 : if(WIFSTOPPED(status))
119 0 : continue;
120 0 : if(WIFEXITED(status)) {
121 0 : ret = WEXITSTATUS(status);
122 0 : break;
123 : }
124 0 : if(WIFSIGNALED(status)) {
125 0 : ret = WTERMSIG(status) + 128;
126 0 : break;
127 : }
128 : }
129 0 : out:
130 0 : if (func) {
131 0 : signal(SIGALRM, old_func);
132 0 : alarm(oldtime);
133 : }
134 0 : return ret;
135 : }
136 :
137 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
138 0 : wait_for_process(pid_t pid)
139 : {
140 0 : return wait_for_process_timed(pid, NULL, NULL, 0);
141 : }
142 :
143 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
144 0 : pipe_execv(FILE **stdin_fd, FILE **stdout_fd, FILE **stderr_fd,
145 : const char *file, ...)
146 : {
147 0 : int in_fd[2] = {-1, -1};
148 0 : int out_fd[2] = {-1, -1};
149 0 : int err_fd[2] = {-1, -1};
150 0 : pid_t pid;
151 0 : va_list ap;
152 0 : char **argv;
153 0 : int ret = 0;
154 :
155 0 : if(stdin_fd != NULL)
156 0 : ret = pipe(in_fd);
157 0 : if(ret != -1 && stdout_fd != NULL)
158 0 : ret = pipe(out_fd);
159 0 : if(ret != -1 && stderr_fd != NULL)
160 0 : ret = pipe(err_fd);
161 :
162 0 : if (ret == -1) {
163 0 : close(in_fd[0]);
164 0 : close(in_fd[1]);
165 0 : close(out_fd[0]);
166 0 : close(out_fd[1]);
167 0 : close(err_fd[0]);
168 0 : close(err_fd[1]);
169 0 : return SE_E_UNSPECIFIED;
170 : }
171 :
172 0 : pid = fork();
173 0 : switch(pid) {
174 0 : case 0:
175 0 : va_start(ap, file);
176 0 : argv = vstrcollect(&ap);
177 0 : va_end(ap);
178 0 : if(argv == NULL)
179 0 : exit(-1);
180 :
181 : /* close pipes we're not interested in */
182 0 : if(stdin_fd != NULL)
183 0 : close(in_fd[1]);
184 0 : if(stdout_fd != NULL)
185 0 : close(out_fd[0]);
186 0 : if(stderr_fd != NULL)
187 0 : close(err_fd[0]);
188 :
189 : /* pipe everything caller doesn't care about to /dev/null */
190 0 : if(stdin_fd == NULL)
191 0 : in_fd[0] = open(_PATH_DEVNULL, O_RDONLY);
192 0 : if(stdout_fd == NULL)
193 0 : out_fd[1] = open(_PATH_DEVNULL, O_WRONLY);
194 0 : if(stderr_fd == NULL)
195 0 : err_fd[1] = open(_PATH_DEVNULL, O_WRONLY);
196 :
197 : /* move to proper descriptors */
198 0 : if(in_fd[0] != STDIN_FILENO) {
199 0 : dup2(in_fd[0], STDIN_FILENO);
200 0 : close(in_fd[0]);
201 : }
202 0 : if(out_fd[1] != STDOUT_FILENO) {
203 0 : dup2(out_fd[1], STDOUT_FILENO);
204 0 : close(out_fd[1]);
205 : }
206 0 : if(err_fd[1] != STDERR_FILENO) {
207 0 : dup2(err_fd[1], STDERR_FILENO);
208 0 : close(err_fd[1]);
209 : }
210 :
211 0 : closefrom(3);
212 :
213 0 : execv(file, argv);
214 0 : exit((errno == ENOENT) ? EX_NOTFOUND : EX_NOEXEC);
215 0 : case -1:
216 0 : if(stdin_fd != NULL) {
217 0 : close(in_fd[0]);
218 0 : close(in_fd[1]);
219 : }
220 0 : if(stdout_fd != NULL) {
221 0 : close(out_fd[0]);
222 0 : close(out_fd[1]);
223 : }
224 0 : if(stderr_fd != NULL) {
225 0 : close(err_fd[0]);
226 0 : close(err_fd[1]);
227 : }
228 0 : return SE_E_FORKFAILED;
229 0 : default:
230 0 : if(stdin_fd != NULL) {
231 0 : close(in_fd[0]);
232 0 : *stdin_fd = fdopen(in_fd[1], "w");
233 : }
234 0 : if(stdout_fd != NULL) {
235 0 : close(out_fd[1]);
236 0 : *stdout_fd = fdopen(out_fd[0], "r");
237 : }
238 0 : if(stderr_fd != NULL) {
239 0 : close(err_fd[1]);
240 0 : *stderr_fd = fdopen(err_fd[0], "r");
241 : }
242 : }
243 0 : return pid;
244 : }
245 :
246 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
247 0 : simple_execvp_timed(const char *file, char *const args[],
248 : time_t (*func)(void *), void *ptr, time_t timeout)
249 : {
250 0 : pid_t pid = fork();
251 0 : switch(pid){
252 0 : case -1:
253 0 : return SE_E_FORKFAILED;
254 0 : case 0:
255 0 : execvp(file, args);
256 0 : exit((errno == ENOENT) ? EX_NOTFOUND : EX_NOEXEC);
257 0 : default:
258 0 : return wait_for_process_timed(pid, func, ptr, timeout);
259 : }
260 : }
261 :
262 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
263 0 : simple_execvp(const char *file, char *const args[])
264 : {
265 0 : return simple_execvp_timed(file, args, NULL, NULL, 0);
266 : }
267 :
268 : /* gee, I'd like a execvpe */
269 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
270 0 : simple_execve_timed(const char *file, char *const args[], char *const envp[],
271 : time_t (*func)(void *), void *ptr, time_t timeout)
272 : {
273 0 : pid_t pid = fork();
274 0 : switch(pid){
275 0 : case -1:
276 0 : return SE_E_FORKFAILED;
277 0 : case 0:
278 0 : execve(file, args, envp);
279 0 : exit((errno == ENOENT) ? EX_NOTFOUND : EX_NOEXEC);
280 0 : default:
281 0 : return wait_for_process_timed(pid, func, ptr, timeout);
282 : }
283 : }
284 :
285 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
286 0 : simple_execve(const char *file, char *const args[], char *const envp[])
287 : {
288 0 : return simple_execve_timed(file, args, envp, NULL, NULL, 0);
289 : }
290 :
291 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
292 0 : simple_execlp(const char *file, ...)
293 : {
294 0 : va_list ap;
295 0 : char **argv;
296 0 : int ret;
297 :
298 0 : va_start(ap, file);
299 0 : argv = vstrcollect(&ap);
300 0 : va_end(ap);
301 0 : if(argv == NULL)
302 0 : return SE_E_UNSPECIFIED;
303 0 : ret = simple_execvp(file, argv);
304 0 : free(argv);
305 0 : return ret;
306 : }
307 :
308 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
309 0 : simple_execle(const char *file, ... /* ,char *const envp[] */)
310 : {
311 0 : va_list ap;
312 0 : char **argv;
313 0 : char *const* envp;
314 0 : int ret;
315 :
316 0 : va_start(ap, file);
317 0 : argv = vstrcollect(&ap);
318 0 : envp = va_arg(ap, char **);
319 0 : va_end(ap);
320 0 : if(argv == NULL)
321 0 : return SE_E_UNSPECIFIED;
322 0 : ret = simple_execve(file, argv, envp);
323 0 : free(argv);
324 0 : return ret;
325 : }
|
