xref: /freebsd/usr.bin/mail/popen.c (revision a35f04fba2ebb8f86d4cbdc710c89a094572b08e)
1 /*
2  * Copyright (c) 1980, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #ifndef lint
31 #if 0
32 static char sccsid[] = "@(#)popen.c	8.1 (Berkeley) 6/6/93";
33 #endif
34 #endif /* not lint */
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
37 
38 #include "rcv.h"
39 #include <sys/wait.h>
40 #include <fcntl.h>
41 #include <errno.h>
42 #include <stdarg.h>
43 #include "extern.h"
44 
45 #define READ 0
46 #define WRITE 1
47 
48 struct fp {
49 	FILE	*fp;
50 	int	pipe;
51 	pid_t	pid;
52 	struct	fp *link;
53 };
54 static struct fp *fp_head;
55 
56 struct child {
57 	pid_t	pid;
58 	char	done;
59 	char	free;
60 	int	status;
61 	struct	child *link;
62 };
63 static struct child *child, *child_freelist = NULL;
64 
65 static void delchild(struct child *);
66 static pid_t file_pid(FILE *);
67 static pid_t start_commandv(char *, sigset_t *, int, int, va_list);
68 
69 FILE *
70 Fopen(const char *path, const char *mode)
71 {
72 	FILE *fp;
73 
74 	if ((fp = fopen(path, mode)) != NULL) {
75 		register_file(fp, 0, 0);
76 		(void)fcntl(fileno(fp), F_SETFD, 1);
77 	}
78 	return (fp);
79 }
80 
81 FILE *
82 Fdopen(int fd, const char *mode)
83 {
84 	FILE *fp;
85 
86 	if ((fp = fdopen(fd, mode)) != NULL) {
87 		register_file(fp, 0, 0);
88 		(void)fcntl(fileno(fp), F_SETFD, 1);
89 	}
90 	return (fp);
91 }
92 
93 int
94 Fclose(FILE *fp)
95 {
96 
97 	unregister_file(fp);
98 	return (fclose(fp));
99 }
100 
101 FILE *
102 Popen(char *cmd, const char *mode)
103 {
104 	int p[2];
105 	int myside, hisside, fd0, fd1;
106 	pid_t pid;
107 	sigset_t nset;
108 	FILE *fp;
109 
110 	if (pipe(p) < 0)
111 		return (NULL);
112 	(void)fcntl(p[READ], F_SETFD, 1);
113 	(void)fcntl(p[WRITE], F_SETFD, 1);
114 	if (*mode == 'r') {
115 		myside = p[READ];
116 		hisside = fd0 = fd1 = p[WRITE];
117 	} else {
118 		myside = p[WRITE];
119 		hisside = fd0 = p[READ];
120 		fd1 = -1;
121 	}
122 	(void)sigemptyset(&nset);
123 	pid = start_command(value("SHELL"), &nset, fd0, fd1, "-c", cmd, NULL);
124 	if (pid < 0) {
125 		(void)close(p[READ]);
126 		(void)close(p[WRITE]);
127 		return (NULL);
128 	}
129 	(void)close(hisside);
130 	if ((fp = fdopen(myside, mode)) != NULL)
131 		register_file(fp, 1, pid);
132 	return (fp);
133 }
134 
135 int
136 Pclose(FILE *ptr)
137 {
138 	int i;
139 	sigset_t nset, oset;
140 
141 	i = file_pid(ptr);
142 	unregister_file(ptr);
143 	(void)fclose(ptr);
144 	(void)sigemptyset(&nset);
145 	(void)sigaddset(&nset, SIGINT);
146 	(void)sigaddset(&nset, SIGHUP);
147 	(void)sigprocmask(SIG_BLOCK, &nset, &oset);
148 	i = wait_child(i);
149 	(void)sigprocmask(SIG_SETMASK, &oset, NULL);
150 	return (i);
151 }
152 
153 void
154 close_all_files(void)
155 {
156 
157 	while (fp_head != NULL)
158 		if (fp_head->pipe)
159 			(void)Pclose(fp_head->fp);
160 		else
161 			(void)Fclose(fp_head->fp);
162 }
163 
164 void
165 register_file(FILE *fp, int pipe, pid_t pid)
166 {
167 	struct fp *fpp;
168 
169 	if ((fpp = malloc(sizeof(*fpp))) == NULL)
170 		err(1, "Out of memory");
171 	fpp->fp = fp;
172 	fpp->pipe = pipe;
173 	fpp->pid = pid;
174 	fpp->link = fp_head;
175 	fp_head = fpp;
176 }
177 
178 void
179 unregister_file(FILE *fp)
180 {
181 	struct fp **pp, *p;
182 
183 	for (pp = &fp_head; (p = *pp) != NULL; pp = &p->link)
184 		if (p->fp == fp) {
185 			*pp = p->link;
186 			(void)free(p);
187 			return;
188 		}
189 	errx(1, "Invalid file pointer");
190 	/*NOTREACHED*/
191 }
192 
193 pid_t
194 file_pid(FILE *fp)
195 {
196 	struct fp *p;
197 
198 	for (p = fp_head; p != NULL; p = p->link)
199 		if (p->fp == fp)
200 			return (p->pid);
201 	errx(1, "Invalid file pointer");
202 	/*NOTREACHED*/
203 }
204 
205 /*
206  * Run a command without a shell, with optional arguments and splicing
207  * of stdin (-1 means none) and stdout.  The command name can be a sequence
208  * of words.
209  * Signals must be handled by the caller.
210  * "nset" contains the signals to ignore in the new process.
211  * SIGINT is enabled unless it's in "nset".
212  */
213 static pid_t
214 start_commandv(char *cmd, sigset_t *nset, int infd, int outfd, va_list args)
215 {
216 	pid_t pid;
217 
218 	if ((pid = fork()) < 0) {
219 		warn("fork");
220 		return (-1);
221 	}
222 	if (pid == 0) {
223 		char *argv[100];
224 		int i = getrawlist(cmd, argv, sizeof(argv) / sizeof(*argv));
225 
226 		while ((argv[i++] = va_arg(args, char *)))
227 			;
228 		argv[i] = NULL;
229 		prepare_child(nset, infd, outfd);
230 		execvp(argv[0], argv);
231 		warn("%s", argv[0]);
232 		_exit(1);
233 	}
234 	return (pid);
235 }
236 
237 int
238 run_command(char *cmd, sigset_t *nset, int infd, int outfd, ...)
239 {
240 	pid_t pid;
241 	va_list args;
242 
243 	va_start(args, outfd);
244 	pid = start_commandv(cmd, nset, infd, outfd, args);
245 	va_end(args);
246 	if (pid < 0)
247 		return -1;
248 	return wait_command(pid);
249 }
250 
251 int
252 start_command(char *cmd, sigset_t *nset, int infd, int outfd, ...)
253 {
254 	va_list args;
255 	int r;
256 
257 	va_start(args, outfd);
258 	r = start_commandv(cmd, nset, infd, outfd, args);
259 	va_end(args);
260 	return r;
261 }
262 
263 void
264 prepare_child(sigset_t *nset, int infd, int outfd)
265 {
266 	int i;
267 	sigset_t eset;
268 
269 	/*
270 	 * All file descriptors other than 0, 1, and 2 are supposed to be
271 	 * close-on-exec.
272 	 */
273 	if (infd >= 0)
274 		dup2(infd, 0);
275 	if (outfd >= 0)
276 		dup2(outfd, 1);
277 	for (i = 1; i < NSIG; i++)
278 		if (nset != NULL && sigismember(nset, i))
279 			(void)signal(i, SIG_IGN);
280 	if (nset == NULL || !sigismember(nset, SIGINT))
281 		(void)signal(SIGINT, SIG_DFL);
282 	(void)sigemptyset(&eset);
283 	(void)sigprocmask(SIG_SETMASK, &eset, NULL);
284 }
285 
286 int
287 wait_command(pid_t pid)
288 {
289 
290 	if (wait_child(pid) < 0) {
291 		printf("Fatal error in process.\n");
292 		return (-1);
293 	}
294 	return (0);
295 }
296 
297 static struct child *
298 findchild(pid_t pid, int dont_alloc)
299 {
300 	struct child **cpp;
301 
302 	for (cpp = &child; *cpp != NULL && (*cpp)->pid != pid;
303 	    cpp = &(*cpp)->link)
304 			;
305 	if (*cpp == NULL) {
306 		if (dont_alloc)
307 			return(NULL);
308 		if (child_freelist) {
309 			*cpp = child_freelist;
310 			child_freelist = (*cpp)->link;
311 		} else {
312 			*cpp = malloc(sizeof(struct child));
313 			if (*cpp == NULL)
314 				err(1, "malloc");
315 		}
316 		(*cpp)->pid = pid;
317 		(*cpp)->done = (*cpp)->free = 0;
318 		(*cpp)->link = NULL;
319 	}
320 	return (*cpp);
321 }
322 
323 static void
324 delchild(struct child *cp)
325 {
326 	struct child **cpp;
327 
328 	for (cpp = &child; *cpp != cp; cpp = &(*cpp)->link)
329 		;
330 	*cpp = cp->link;
331 	cp->link = child_freelist;
332 	child_freelist = cp;
333 }
334 
335 /*ARGSUSED*/
336 void
337 sigchild(int signo __unused)
338 {
339 	pid_t pid;
340 	int status;
341 	struct child *cp;
342 	int save_errno;
343 
344 	save_errno = errno;
345 	while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
346 		cp = findchild(pid, 1);
347 		if (cp == NULL)
348 			continue;
349 		if (cp->free)
350 			delchild(cp);
351 		else {
352 			cp->done = 1;
353 			cp->status = status;
354 		}
355 	}
356 	errno = save_errno;
357 }
358 
359 int wait_status;
360 
361 /*
362  * Wait for a specific child to die.
363  */
364 int
365 wait_child(pid_t pid)
366 {
367 	struct child *cp;
368 	sigset_t nset, oset;
369 	pid_t rv = 0;
370 
371 	(void)sigemptyset(&nset);
372 	(void)sigaddset(&nset, SIGCHLD);
373 	(void)sigprocmask(SIG_BLOCK, &nset, &oset);
374 	/*
375 	 * If we have not already waited on the pid (via sigchild)
376 	 * wait on it now.  Otherwise, use the wait status stashed
377 	 * by sigchild.
378 	 */
379 	cp = findchild(pid, 1);
380 	if (cp == NULL || !cp->done)
381 		rv = waitpid(pid, &wait_status, 0);
382 	else
383 		wait_status = cp->status;
384 	if (cp != NULL)
385 		delchild(cp);
386 	(void)sigprocmask(SIG_SETMASK, &oset, NULL);
387 	if (rv == -1 || (WIFEXITED(wait_status) && WEXITSTATUS(wait_status)))
388 		return -1;
389 	else
390 		return 0;
391 }
392 
393 /*
394  * Mark a child as don't care.
395  */
396 void
397 free_child(pid_t pid)
398 {
399 	struct child *cp;
400 	sigset_t nset, oset;
401 
402 	(void)sigemptyset(&nset);
403 	(void)sigaddset(&nset, SIGCHLD);
404 	(void)sigprocmask(SIG_BLOCK, &nset, &oset);
405 	if ((cp = findchild(pid, 0)) != NULL) {
406 		if (cp->done)
407 			delchild(cp);
408 		else
409 			cp->free = 1;
410 	}
411 	(void)sigprocmask(SIG_SETMASK, &oset, NULL);
412 }
413