xref: /freebsd/bin/sh/jobs.c (revision a0e793cbf1951d07fc47a0d9ea389d7dacba5213)
1 /*-
2  * Copyright (c) 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
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  * 4. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)jobs.c	8.5 (Berkeley) 5/4/95";
36 #endif
37 #endif /* not lint */
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40 
41 #include <sys/ioctl.h>
42 #include <sys/param.h>
43 #include <sys/resource.h>
44 #include <sys/time.h>
45 #include <sys/wait.h>
46 #include <errno.h>
47 #include <fcntl.h>
48 #include <paths.h>
49 #include <signal.h>
50 #include <stddef.h>
51 #include <stdlib.h>
52 #include <unistd.h>
53 
54 #include "shell.h"
55 #if JOBS
56 #include <termios.h>
57 #undef CEOF			/* syntax.h redefines this */
58 #endif
59 #include "redir.h"
60 #include "exec.h"
61 #include "show.h"
62 #include "main.h"
63 #include "parser.h"
64 #include "nodes.h"
65 #include "jobs.h"
66 #include "options.h"
67 #include "trap.h"
68 #include "syntax.h"
69 #include "input.h"
70 #include "output.h"
71 #include "memalloc.h"
72 #include "error.h"
73 #include "mystring.h"
74 #include "var.h"
75 #include "builtins.h"
76 
77 
78 static struct job *jobtab;	/* array of jobs */
79 static int njobs;		/* size of array */
80 static pid_t backgndpid = -1;	/* pid of last background process */
81 static struct job *bgjob = NULL; /* last background process */
82 #if JOBS
83 static struct job *jobmru;	/* most recently used job list */
84 static pid_t initialpgrp;	/* pgrp of shell on invocation */
85 #endif
86 static int ttyfd = -1;
87 
88 /* mode flags for dowait */
89 #define DOWAIT_BLOCK	0x1 /* wait until a child exits */
90 #define DOWAIT_SIG	0x2 /* if DOWAIT_BLOCK, abort on SIGINT/SIGQUIT */
91 #define DOWAIT_SIG_ANY	0x4 /* if DOWAIT_SIG, abort on any signal */
92 
93 #if JOBS
94 static void restartjob(struct job *);
95 #endif
96 static void freejob(struct job *);
97 static int waitcmdloop(struct job *);
98 static struct job *getjob_nonotfound(const char *);
99 static struct job *getjob(const char *);
100 pid_t killjob(const char *, int);
101 static pid_t dowait(int, struct job *);
102 static void checkzombies(void);
103 static void cmdtxt(union node *);
104 static void cmdputs(const char *);
105 #if JOBS
106 static void setcurjob(struct job *);
107 static void deljob(struct job *);
108 static struct job *getcurjob(struct job *);
109 #endif
110 static void printjobcmd(struct job *);
111 static void showjob(struct job *, int);
112 
113 
114 /*
115  * Turn job control on and off.
116  */
117 
118 static int jobctl;
119 
120 #if JOBS
121 void
122 setjobctl(int on)
123 {
124 	int i;
125 
126 	if (on == jobctl || rootshell == 0)
127 		return;
128 	if (on) {
129 		if (ttyfd != -1)
130 			close(ttyfd);
131 		if ((ttyfd = open(_PATH_TTY, O_RDWR | O_CLOEXEC)) < 0) {
132 			i = 0;
133 			while (i <= 2 && !isatty(i))
134 				i++;
135 			if (i > 2 ||
136 			    (ttyfd = fcntl(i, F_DUPFD_CLOEXEC, 10)) < 0)
137 				goto out;
138 		}
139 		if (ttyfd < 10) {
140 			/*
141 			 * Keep our TTY file descriptor out of the way of
142 			 * the user's redirections.
143 			 */
144 			if ((i = fcntl(ttyfd, F_DUPFD_CLOEXEC, 10)) < 0) {
145 				close(ttyfd);
146 				ttyfd = -1;
147 				goto out;
148 			}
149 			close(ttyfd);
150 			ttyfd = i;
151 		}
152 		do { /* while we are in the background */
153 			initialpgrp = tcgetpgrp(ttyfd);
154 			if (initialpgrp < 0) {
155 out:				out2fmt_flush("sh: can't access tty; job control turned off\n");
156 				mflag = 0;
157 				return;
158 			}
159 			if (initialpgrp != getpgrp()) {
160 				kill(0, SIGTTIN);
161 				continue;
162 			}
163 		} while (0);
164 		setsignal(SIGTSTP);
165 		setsignal(SIGTTOU);
166 		setsignal(SIGTTIN);
167 		setpgid(0, rootpid);
168 		tcsetpgrp(ttyfd, rootpid);
169 	} else { /* turning job control off */
170 		setpgid(0, initialpgrp);
171 		tcsetpgrp(ttyfd, initialpgrp);
172 		close(ttyfd);
173 		ttyfd = -1;
174 		setsignal(SIGTSTP);
175 		setsignal(SIGTTOU);
176 		setsignal(SIGTTIN);
177 	}
178 	jobctl = on;
179 }
180 #endif
181 
182 
183 #if JOBS
184 int
185 fgcmd(int argc __unused, char **argv __unused)
186 {
187 	struct job *jp;
188 	pid_t pgrp;
189 	int status;
190 
191 	nextopt("");
192 	jp = getjob(*argptr);
193 	if (jp->jobctl == 0)
194 		error("job not created under job control");
195 	printjobcmd(jp);
196 	flushout(&output);
197 	pgrp = jp->ps[0].pid;
198 	tcsetpgrp(ttyfd, pgrp);
199 	restartjob(jp);
200 	jp->foreground = 1;
201 	INTOFF;
202 	status = waitforjob(jp, (int *)NULL);
203 	INTON;
204 	return status;
205 }
206 
207 
208 int
209 bgcmd(int argc, char **argv)
210 {
211 	struct job *jp;
212 
213 	nextopt("");
214 	do {
215 		jp = getjob(*argptr);
216 		if (jp->jobctl == 0)
217 			error("job not created under job control");
218 		if (jp->state == JOBDONE)
219 			continue;
220 		restartjob(jp);
221 		jp->foreground = 0;
222 		out1fmt("[%td] ", jp - jobtab + 1);
223 		printjobcmd(jp);
224 	} while (*argptr != NULL && *++argptr != NULL);
225 	return 0;
226 }
227 
228 
229 static void
230 restartjob(struct job *jp)
231 {
232 	struct procstat *ps;
233 	int i;
234 
235 	if (jp->state == JOBDONE)
236 		return;
237 	setcurjob(jp);
238 	INTOFF;
239 	kill(-jp->ps[0].pid, SIGCONT);
240 	for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
241 		if (WIFSTOPPED(ps->status)) {
242 			ps->status = -1;
243 			jp->state = 0;
244 		}
245 	}
246 	INTON;
247 }
248 #endif
249 
250 
251 int
252 jobscmd(int argc __unused, char *argv[] __unused)
253 {
254 	char *id;
255 	int ch, mode;
256 
257 	mode = SHOWJOBS_DEFAULT;
258 	while ((ch = nextopt("lps")) != '\0') {
259 		switch (ch) {
260 		case 'l':
261 			mode = SHOWJOBS_VERBOSE;
262 			break;
263 		case 'p':
264 			mode = SHOWJOBS_PGIDS;
265 			break;
266 		case 's':
267 			mode = SHOWJOBS_PIDS;
268 			break;
269 		}
270 	}
271 
272 	if (*argptr == NULL)
273 		showjobs(0, mode);
274 	else
275 		while ((id = *argptr++) != NULL)
276 			showjob(getjob(id), mode);
277 
278 	return (0);
279 }
280 
281 static void
282 printjobcmd(struct job *jp)
283 {
284 	struct procstat *ps;
285 	int i;
286 
287 	for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
288 		out1str(ps->cmd);
289 		if (i > 0)
290 			out1str(" | ");
291 	}
292 	out1c('\n');
293 }
294 
295 static void
296 showjob(struct job *jp, int mode)
297 {
298 	char s[64];
299 	char statestr[64];
300 	const char *sigstr;
301 	struct procstat *ps;
302 	struct job *j;
303 	int col, curr, i, jobno, prev, procno;
304 	char c;
305 
306 	procno = (mode == SHOWJOBS_PGIDS) ? 1 : jp->nprocs;
307 	jobno = jp - jobtab + 1;
308 	curr = prev = 0;
309 #if JOBS
310 	if ((j = getcurjob(NULL)) != NULL) {
311 		curr = j - jobtab + 1;
312 		if ((j = getcurjob(j)) != NULL)
313 			prev = j - jobtab + 1;
314 	}
315 #endif
316 	ps = jp->ps + jp->nprocs - 1;
317 	if (jp->state == 0) {
318 		strcpy(statestr, "Running");
319 #if JOBS
320 	} else if (jp->state == JOBSTOPPED) {
321 		while (!WIFSTOPPED(ps->status) && ps > jp->ps)
322 			ps--;
323 		if (WIFSTOPPED(ps->status))
324 			i = WSTOPSIG(ps->status);
325 		else
326 			i = -1;
327 		sigstr = strsignal(i);
328 		if (sigstr != NULL)
329 			strcpy(statestr, sigstr);
330 		else
331 			strcpy(statestr, "Suspended");
332 #endif
333 	} else if (WIFEXITED(ps->status)) {
334 		if (WEXITSTATUS(ps->status) == 0)
335 			strcpy(statestr, "Done");
336 		else
337 			fmtstr(statestr, 64, "Done(%d)",
338 			    WEXITSTATUS(ps->status));
339 	} else {
340 		i = WTERMSIG(ps->status);
341 		sigstr = strsignal(i);
342 		if (sigstr != NULL)
343 			strcpy(statestr, sigstr);
344 		else
345 			strcpy(statestr, "Unknown signal");
346 		if (WCOREDUMP(ps->status))
347 			strcat(statestr, " (core dumped)");
348 	}
349 
350 	for (ps = jp->ps ; ; ps++) {	/* for each process */
351 		if (mode == SHOWJOBS_PIDS || mode == SHOWJOBS_PGIDS) {
352 			out1fmt("%d\n", (int)ps->pid);
353 			goto skip;
354 		}
355 		if (mode != SHOWJOBS_VERBOSE && ps != jp->ps)
356 			goto skip;
357 		if (jobno == curr && ps == jp->ps)
358 			c = '+';
359 		else if (jobno == prev && ps == jp->ps)
360 			c = '-';
361 		else
362 			c = ' ';
363 		if (ps == jp->ps)
364 			fmtstr(s, 64, "[%d] %c ", jobno, c);
365 		else
366 			fmtstr(s, 64, "    %c ", c);
367 		out1str(s);
368 		col = strlen(s);
369 		if (mode == SHOWJOBS_VERBOSE) {
370 			fmtstr(s, 64, "%d ", (int)ps->pid);
371 			out1str(s);
372 			col += strlen(s);
373 		}
374 		if (ps == jp->ps) {
375 			out1str(statestr);
376 			col += strlen(statestr);
377 		}
378 		do {
379 			out1c(' ');
380 			col++;
381 		} while (col < 30);
382 		if (mode == SHOWJOBS_VERBOSE) {
383 			out1str(ps->cmd);
384 			out1c('\n');
385 		} else
386 			printjobcmd(jp);
387 skip:		if (--procno <= 0)
388 			break;
389 	}
390 }
391 
392 /*
393  * Print a list of jobs.  If "change" is nonzero, only print jobs whose
394  * statuses have changed since the last call to showjobs.
395  *
396  * If the shell is interrupted in the process of creating a job, the
397  * result may be a job structure containing zero processes.  Such structures
398  * will be freed here.
399  */
400 
401 void
402 showjobs(int change, int mode)
403 {
404 	int jobno;
405 	struct job *jp;
406 
407 	TRACE(("showjobs(%d) called\n", change));
408 	checkzombies();
409 	for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
410 		if (! jp->used)
411 			continue;
412 		if (jp->nprocs == 0) {
413 			freejob(jp);
414 			continue;
415 		}
416 		if (change && ! jp->changed)
417 			continue;
418 		showjob(jp, mode);
419 		if (mode == SHOWJOBS_DEFAULT || mode == SHOWJOBS_VERBOSE) {
420 			jp->changed = 0;
421 			/* Hack: discard jobs for which $! has not been
422 			 * referenced in interactive mode when they terminate.
423 			 */
424 			if (jp->state == JOBDONE && !jp->remembered &&
425 					(iflag || jp != bgjob)) {
426 				freejob(jp);
427 			}
428 		}
429 	}
430 }
431 
432 
433 /*
434  * Mark a job structure as unused.
435  */
436 
437 static void
438 freejob(struct job *jp)
439 {
440 	struct procstat *ps;
441 	int i;
442 
443 	INTOFF;
444 	if (bgjob == jp)
445 		bgjob = NULL;
446 	for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) {
447 		if (ps->cmd != nullstr)
448 			ckfree(ps->cmd);
449 	}
450 	if (jp->ps != &jp->ps0)
451 		ckfree(jp->ps);
452 	jp->used = 0;
453 #if JOBS
454 	deljob(jp);
455 #endif
456 	INTON;
457 }
458 
459 
460 
461 int
462 waitcmd(int argc __unused, char **argv __unused)
463 {
464 	struct job *job;
465 	int retval;
466 
467 	nextopt("");
468 	if (*argptr == NULL)
469 		return (waitcmdloop(NULL));
470 
471 	do {
472 		job = getjob_nonotfound(*argptr);
473 		if (job == NULL)
474 			retval = 127;
475 		else
476 			retval = waitcmdloop(job);
477 		argptr++;
478 	} while (*argptr != NULL);
479 
480 	return (retval);
481 }
482 
483 static int
484 waitcmdloop(struct job *job)
485 {
486 	int status, retval, sig;
487 	struct job *jp;
488 
489 	/*
490 	 * Loop until a process is terminated or stopped, or a SIGINT is
491 	 * received.
492 	 */
493 
494 	do {
495 		if (job != NULL) {
496 			if (job->state == JOBDONE) {
497 				status = job->ps[job->nprocs - 1].status;
498 				if (WIFEXITED(status))
499 					retval = WEXITSTATUS(status);
500 				else
501 					retval = WTERMSIG(status) + 128;
502 				if (! iflag || ! job->changed)
503 					freejob(job);
504 				else {
505 					job->remembered = 0;
506 					if (job == bgjob)
507 						bgjob = NULL;
508 				}
509 				return retval;
510 			}
511 		} else {
512 			for (jp = jobtab ; jp < jobtab + njobs; jp++)
513 				if (jp->used && jp->state == JOBDONE) {
514 					if (! iflag || ! jp->changed)
515 						freejob(jp);
516 					else {
517 						jp->remembered = 0;
518 						if (jp == bgjob)
519 							bgjob = NULL;
520 					}
521 				}
522 			for (jp = jobtab ; ; jp++) {
523 				if (jp >= jobtab + njobs) {	/* no running procs */
524 					return 0;
525 				}
526 				if (jp->used && jp->state == 0)
527 					break;
528 			}
529 		}
530 	} while (dowait(DOWAIT_BLOCK | DOWAIT_SIG, (struct job *)NULL) != -1);
531 
532 	sig = pendingsig_waitcmd;
533 	pendingsig_waitcmd = 0;
534 	return sig + 128;
535 }
536 
537 
538 
539 int
540 jobidcmd(int argc __unused, char **argv __unused)
541 {
542 	struct job *jp;
543 	int i;
544 
545 	nextopt("");
546 	jp = getjob(*argptr);
547 	for (i = 0 ; i < jp->nprocs ; ) {
548 		out1fmt("%d", (int)jp->ps[i].pid);
549 		out1c(++i < jp->nprocs? ' ' : '\n');
550 	}
551 	return 0;
552 }
553 
554 
555 
556 /*
557  * Convert a job name to a job structure.
558  */
559 
560 static struct job *
561 getjob_nonotfound(const char *name)
562 {
563 	int jobno;
564 	struct job *found, *jp;
565 	size_t namelen;
566 	pid_t pid;
567 	int i;
568 
569 	if (name == NULL) {
570 #if JOBS
571 currentjob:	if ((jp = getcurjob(NULL)) == NULL)
572 			error("No current job");
573 		return (jp);
574 #else
575 		error("No current job");
576 #endif
577 	} else if (name[0] == '%') {
578 		if (is_digit(name[1])) {
579 			jobno = number(name + 1);
580 			if (jobno > 0 && jobno <= njobs
581 			 && jobtab[jobno - 1].used != 0)
582 				return &jobtab[jobno - 1];
583 #if JOBS
584 		} else if (name[1] == '%' && name[2] == '\0') {
585 			goto currentjob;
586 		} else if (name[1] == '+' && name[2] == '\0') {
587 			goto currentjob;
588 		} else if (name[1] == '-' && name[2] == '\0') {
589 			if ((jp = getcurjob(NULL)) == NULL ||
590 			    (jp = getcurjob(jp)) == NULL)
591 				error("No previous job");
592 			return (jp);
593 #endif
594 		} else if (name[1] == '?') {
595 			found = NULL;
596 			for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
597 				if (jp->used && jp->nprocs > 0
598 				 && strstr(jp->ps[0].cmd, name + 2) != NULL) {
599 					if (found)
600 						error("%s: ambiguous", name);
601 					found = jp;
602 				}
603 			}
604 			if (found != NULL)
605 				return (found);
606 		} else {
607 			namelen = strlen(name);
608 			found = NULL;
609 			for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
610 				if (jp->used && jp->nprocs > 0
611 				 && strncmp(jp->ps[0].cmd, name + 1,
612 				 namelen - 1) == 0) {
613 					if (found)
614 						error("%s: ambiguous", name);
615 					found = jp;
616 				}
617 			}
618 			if (found)
619 				return found;
620 		}
621 	} else if (is_number(name)) {
622 		pid = (pid_t)number(name);
623 		for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
624 			if (jp->used && jp->nprocs > 0
625 			 && jp->ps[jp->nprocs - 1].pid == pid)
626 				return jp;
627 		}
628 	}
629 	return NULL;
630 }
631 
632 
633 static struct job *
634 getjob(const char *name)
635 {
636 	struct job *jp;
637 
638 	jp = getjob_nonotfound(name);
639 	if (jp == NULL)
640 		error("No such job: %s", name);
641 	return (jp);
642 }
643 
644 
645 int
646 killjob(const char *name, int sig)
647 {
648 	struct job *jp;
649 	int i, ret;
650 
651 	jp = getjob(name);
652 	if (jp->state == JOBDONE)
653 		return 0;
654 	if (jp->jobctl)
655 		return kill(-jp->ps[0].pid, sig);
656 	ret = -1;
657 	errno = ESRCH;
658 	for (i = 0; i < jp->nprocs; i++)
659 		if (jp->ps[i].status == -1 || WIFSTOPPED(jp->ps[i].status)) {
660 			if (kill(jp->ps[i].pid, sig) == 0)
661 				ret = 0;
662 		} else
663 			ret = 0;
664 	return ret;
665 }
666 
667 /*
668  * Return a new job structure,
669  */
670 
671 struct job *
672 makejob(union node *node __unused, int nprocs)
673 {
674 	int i;
675 	struct job *jp;
676 
677 	for (i = njobs, jp = jobtab ; ; jp++) {
678 		if (--i < 0) {
679 			INTOFF;
680 			if (njobs == 0) {
681 				jobtab = ckmalloc(4 * sizeof jobtab[0]);
682 #if JOBS
683 				jobmru = NULL;
684 #endif
685 			} else {
686 				jp = ckmalloc((njobs + 4) * sizeof jobtab[0]);
687 				memcpy(jp, jobtab, njobs * sizeof jp[0]);
688 #if JOBS
689 				/* Relocate `next' pointers and list head */
690 				if (jobmru != NULL)
691 					jobmru = &jp[jobmru - jobtab];
692 				for (i = 0; i < njobs; i++)
693 					if (jp[i].next != NULL)
694 						jp[i].next = &jp[jp[i].next -
695 						    jobtab];
696 #endif
697 				if (bgjob != NULL)
698 					bgjob = &jp[bgjob - jobtab];
699 				/* Relocate `ps' pointers */
700 				for (i = 0; i < njobs; i++)
701 					if (jp[i].ps == &jobtab[i].ps0)
702 						jp[i].ps = &jp[i].ps0;
703 				ckfree(jobtab);
704 				jobtab = jp;
705 			}
706 			jp = jobtab + njobs;
707 			for (i = 4 ; --i >= 0 ; jobtab[njobs++].used = 0)
708 				;
709 			INTON;
710 			break;
711 		}
712 		if (jp->used == 0)
713 			break;
714 	}
715 	INTOFF;
716 	jp->state = 0;
717 	jp->used = 1;
718 	jp->changed = 0;
719 	jp->nprocs = 0;
720 	jp->foreground = 0;
721 	jp->remembered = 0;
722 #if JOBS
723 	jp->jobctl = jobctl;
724 	jp->next = NULL;
725 #endif
726 	if (nprocs > 1) {
727 		jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
728 	} else {
729 		jp->ps = &jp->ps0;
730 	}
731 	INTON;
732 	TRACE(("makejob(%p, %d) returns %%%td\n", (void *)node, nprocs,
733 	    jp - jobtab + 1));
734 	return jp;
735 }
736 
737 #if JOBS
738 static void
739 setcurjob(struct job *cj)
740 {
741 	struct job *jp, *prev;
742 
743 	for (prev = NULL, jp = jobmru; jp != NULL; prev = jp, jp = jp->next) {
744 		if (jp == cj) {
745 			if (prev != NULL)
746 				prev->next = jp->next;
747 			else
748 				jobmru = jp->next;
749 			jp->next = jobmru;
750 			jobmru = cj;
751 			return;
752 		}
753 	}
754 	cj->next = jobmru;
755 	jobmru = cj;
756 }
757 
758 static void
759 deljob(struct job *j)
760 {
761 	struct job *jp, *prev;
762 
763 	for (prev = NULL, jp = jobmru; jp != NULL; prev = jp, jp = jp->next) {
764 		if (jp == j) {
765 			if (prev != NULL)
766 				prev->next = jp->next;
767 			else
768 				jobmru = jp->next;
769 			return;
770 		}
771 	}
772 }
773 
774 /*
775  * Return the most recently used job that isn't `nj', and preferably one
776  * that is stopped.
777  */
778 static struct job *
779 getcurjob(struct job *nj)
780 {
781 	struct job *jp;
782 
783 	/* Try to find a stopped one.. */
784 	for (jp = jobmru; jp != NULL; jp = jp->next)
785 		if (jp->used && jp != nj && jp->state == JOBSTOPPED)
786 			return (jp);
787 	/* Otherwise the most recently used job that isn't `nj' */
788 	for (jp = jobmru; jp != NULL; jp = jp->next)
789 		if (jp->used && jp != nj)
790 			return (jp);
791 
792 	return (NULL);
793 }
794 
795 #endif
796 
797 /*
798  * Fork of a subshell.  If we are doing job control, give the subshell its
799  * own process group.  Jp is a job structure that the job is to be added to.
800  * N is the command that will be evaluated by the child.  Both jp and n may
801  * be NULL.  The mode parameter can be one of the following:
802  *	FORK_FG - Fork off a foreground process.
803  *	FORK_BG - Fork off a background process.
804  *	FORK_NOJOB - Like FORK_FG, but don't give the process its own
805  *		     process group even if job control is on.
806  *
807  * When job control is turned off, background processes have their standard
808  * input redirected to /dev/null (except for the second and later processes
809  * in a pipeline).
810  */
811 
812 pid_t
813 forkshell(struct job *jp, union node *n, int mode)
814 {
815 	pid_t pid;
816 	pid_t pgrp;
817 
818 	TRACE(("forkshell(%%%td, %p, %d) called\n", jp - jobtab, (void *)n,
819 	    mode));
820 	INTOFF;
821 	if (mode == FORK_BG && (jp == NULL || jp->nprocs == 0))
822 		checkzombies();
823 	flushall();
824 	pid = fork();
825 	if (pid == -1) {
826 		TRACE(("Fork failed, errno=%d\n", errno));
827 		INTON;
828 		error("Cannot fork: %s", strerror(errno));
829 	}
830 	if (pid == 0) {
831 		struct job *p;
832 		int wasroot;
833 		int i;
834 
835 		TRACE(("Child shell %d\n", (int)getpid()));
836 		wasroot = rootshell;
837 		rootshell = 0;
838 		handler = &main_handler;
839 		closescript();
840 		INTON;
841 		forcelocal = 0;
842 		clear_traps();
843 #if JOBS
844 		jobctl = 0;		/* do job control only in root shell */
845 		if (wasroot && mode != FORK_NOJOB && mflag) {
846 			if (jp == NULL || jp->nprocs == 0)
847 				pgrp = getpid();
848 			else
849 				pgrp = jp->ps[0].pid;
850 			if (setpgid(0, pgrp) == 0 && mode == FORK_FG) {
851 				/*** this causes superfluous TIOCSPGRPS ***/
852 				if (tcsetpgrp(ttyfd, pgrp) < 0)
853 					error("tcsetpgrp failed, errno=%d", errno);
854 			}
855 			setsignal(SIGTSTP);
856 			setsignal(SIGTTOU);
857 		} else if (mode == FORK_BG) {
858 			ignoresig(SIGINT);
859 			ignoresig(SIGQUIT);
860 			if ((jp == NULL || jp->nprocs == 0) &&
861 			    ! fd0_redirected_p ()) {
862 				close(0);
863 				if (open(_PATH_DEVNULL, O_RDONLY) != 0)
864 					error("cannot open %s: %s",
865 					    _PATH_DEVNULL, strerror(errno));
866 			}
867 		}
868 #else
869 		if (mode == FORK_BG) {
870 			ignoresig(SIGINT);
871 			ignoresig(SIGQUIT);
872 			if ((jp == NULL || jp->nprocs == 0) &&
873 			    ! fd0_redirected_p ()) {
874 				close(0);
875 				if (open(_PATH_DEVNULL, O_RDONLY) != 0)
876 					error("cannot open %s: %s",
877 					    _PATH_DEVNULL, strerror(errno));
878 			}
879 		}
880 #endif
881 		INTOFF;
882 		for (i = njobs, p = jobtab ; --i >= 0 ; p++)
883 			if (p->used)
884 				freejob(p);
885 		INTON;
886 		if (wasroot && iflag) {
887 			setsignal(SIGINT);
888 			setsignal(SIGQUIT);
889 			setsignal(SIGTERM);
890 		}
891 		return pid;
892 	}
893 	if (rootshell && mode != FORK_NOJOB && mflag) {
894 		if (jp == NULL || jp->nprocs == 0)
895 			pgrp = pid;
896 		else
897 			pgrp = jp->ps[0].pid;
898 		setpgid(pid, pgrp);
899 	}
900 	if (mode == FORK_BG) {
901 		if (bgjob != NULL && bgjob->state == JOBDONE &&
902 		    !bgjob->remembered && !iflag)
903 			freejob(bgjob);
904 		backgndpid = pid;		/* set $! */
905 		bgjob = jp;
906 	}
907 	if (jp) {
908 		struct procstat *ps = &jp->ps[jp->nprocs++];
909 		ps->pid = pid;
910 		ps->status = -1;
911 		ps->cmd = nullstr;
912 		if (iflag && rootshell && n)
913 			ps->cmd = commandtext(n);
914 		jp->foreground = mode == FORK_FG;
915 #if JOBS
916 		setcurjob(jp);
917 #endif
918 	}
919 	INTON;
920 	TRACE(("In parent shell:  child = %d\n", (int)pid));
921 	return pid;
922 }
923 
924 
925 pid_t
926 vforkexecshell(struct job *jp, char **argv, char **envp, const char *path, int idx, int pip[2])
927 {
928 	pid_t pid;
929 	struct jmploc jmploc;
930 	struct jmploc *savehandler;
931 
932 	TRACE(("vforkexecshell(%%%td, %s, %p) called\n", jp - jobtab, argv[0],
933 	    (void *)pip));
934 	INTOFF;
935 	flushall();
936 	savehandler = handler;
937 	pid = vfork();
938 	if (pid == -1) {
939 		TRACE(("Vfork failed, errno=%d\n", errno));
940 		INTON;
941 		error("Cannot fork: %s", strerror(errno));
942 	}
943 	if (pid == 0) {
944 		TRACE(("Child shell %d\n", (int)getpid()));
945 		if (setjmp(jmploc.loc))
946 			_exit(exception == EXEXEC ? exerrno : 2);
947 		if (pip != NULL) {
948 			close(pip[0]);
949 			if (pip[1] != 1) {
950 				dup2(pip[1], 1);
951 				close(pip[1]);
952 			}
953 		}
954 		handler = &jmploc;
955 		shellexec(argv, envp, path, idx);
956 	}
957 	handler = savehandler;
958 	if (jp) {
959 		struct procstat *ps = &jp->ps[jp->nprocs++];
960 		ps->pid = pid;
961 		ps->status = -1;
962 		ps->cmd = nullstr;
963 		jp->foreground = 1;
964 #if JOBS
965 		setcurjob(jp);
966 #endif
967 	}
968 	INTON;
969 	TRACE(("In parent shell:  child = %d\n", (int)pid));
970 	return pid;
971 }
972 
973 
974 /*
975  * Wait for job to finish.
976  *
977  * Under job control we have the problem that while a child process is
978  * running interrupts generated by the user are sent to the child but not
979  * to the shell.  This means that an infinite loop started by an inter-
980  * active user may be hard to kill.  With job control turned off, an
981  * interactive user may place an interactive program inside a loop.  If
982  * the interactive program catches interrupts, the user doesn't want
983  * these interrupts to also abort the loop.  The approach we take here
984  * is to have the shell ignore interrupt signals while waiting for a
985  * foreground process to terminate, and then send itself an interrupt
986  * signal if the child process was terminated by an interrupt signal.
987  * Unfortunately, some programs want to do a bit of cleanup and then
988  * exit on interrupt; unless these processes terminate themselves by
989  * sending a signal to themselves (instead of calling exit) they will
990  * confuse this approach.
991  */
992 
993 int
994 waitforjob(struct job *jp, int *origstatus)
995 {
996 #if JOBS
997 	int propagate_int = jp->jobctl && jp->foreground;
998 #endif
999 	int status;
1000 	int st;
1001 
1002 	INTOFF;
1003 	TRACE(("waitforjob(%%%td) called\n", jp - jobtab + 1));
1004 	while (jp->state == 0)
1005 		if (dowait(DOWAIT_BLOCK | (Tflag ? DOWAIT_SIG |
1006 		    DOWAIT_SIG_ANY : 0), jp) == -1)
1007 			dotrap();
1008 #if JOBS
1009 	if (jp->jobctl) {
1010 		if (tcsetpgrp(ttyfd, rootpid) < 0)
1011 			error("tcsetpgrp failed, errno=%d\n", errno);
1012 	}
1013 	if (jp->state == JOBSTOPPED)
1014 		setcurjob(jp);
1015 #endif
1016 	status = jp->ps[jp->nprocs - 1].status;
1017 	if (origstatus != NULL)
1018 		*origstatus = status;
1019 	/* convert to 8 bits */
1020 	if (WIFEXITED(status))
1021 		st = WEXITSTATUS(status);
1022 #if JOBS
1023 	else if (WIFSTOPPED(status))
1024 		st = WSTOPSIG(status) + 128;
1025 #endif
1026 	else
1027 		st = WTERMSIG(status) + 128;
1028 	if (! JOBS || jp->state == JOBDONE)
1029 		freejob(jp);
1030 	if (int_pending()) {
1031 		if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGINT)
1032 			CLEAR_PENDING_INT;
1033 	}
1034 #if JOBS
1035 	else if (rootshell && iflag && propagate_int &&
1036 			WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
1037 		kill(getpid(), SIGINT);
1038 #endif
1039 	INTON;
1040 	return st;
1041 }
1042 
1043 
1044 static void
1045 dummy_handler(int sig __unused)
1046 {
1047 }
1048 
1049 /*
1050  * Wait for a process to terminate.
1051  */
1052 
1053 static pid_t
1054 dowait(int mode, struct job *job)
1055 {
1056 	struct sigaction sa, osa;
1057 	sigset_t mask, omask;
1058 	pid_t pid;
1059 	int status;
1060 	struct procstat *sp;
1061 	struct job *jp;
1062 	struct job *thisjob;
1063 	const char *sigstr;
1064 	int done;
1065 	int stopped;
1066 	int sig;
1067 	int coredump;
1068 	int wflags;
1069 	int restore_sigchld;
1070 
1071 	TRACE(("dowait(%d, %p) called\n", mode, job));
1072 	restore_sigchld = 0;
1073 	if ((mode & DOWAIT_SIG) != 0) {
1074 		sigfillset(&mask);
1075 		sigprocmask(SIG_BLOCK, &mask, &omask);
1076 		INTOFF;
1077 		if (!issigchldtrapped()) {
1078 			restore_sigchld = 1;
1079 			sa.sa_handler = dummy_handler;
1080 			sa.sa_flags = 0;
1081 			sigemptyset(&sa.sa_mask);
1082 			sigaction(SIGCHLD, &sa, &osa);
1083 		}
1084 	}
1085 	do {
1086 #if JOBS
1087 		if (iflag)
1088 			wflags = WUNTRACED | WCONTINUED;
1089 		else
1090 #endif
1091 			wflags = 0;
1092 		if ((mode & (DOWAIT_BLOCK | DOWAIT_SIG)) != DOWAIT_BLOCK)
1093 			wflags |= WNOHANG;
1094 		pid = wait3(&status, wflags, (struct rusage *)NULL);
1095 		TRACE(("wait returns %d, status=%d\n", (int)pid, status));
1096 		if (pid == 0 && (mode & DOWAIT_SIG) != 0) {
1097 			pid = -1;
1098 			if (((mode & DOWAIT_SIG_ANY) != 0 ?
1099 			    pendingsig : pendingsig_waitcmd) != 0) {
1100 				errno = EINTR;
1101 				break;
1102 			}
1103 			sigsuspend(&omask);
1104 			if (int_pending())
1105 				break;
1106 		}
1107 	} while (pid == -1 && errno == EINTR);
1108 	if (pid == -1 && errno == ECHILD && job != NULL)
1109 		job->state = JOBDONE;
1110 	if ((mode & DOWAIT_SIG) != 0) {
1111 		if (restore_sigchld)
1112 			sigaction(SIGCHLD, &osa, NULL);
1113 		sigprocmask(SIG_SETMASK, &omask, NULL);
1114 		INTON;
1115 	}
1116 	if (pid <= 0)
1117 		return pid;
1118 	INTOFF;
1119 	thisjob = NULL;
1120 	for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
1121 		if (jp->used && jp->nprocs > 0) {
1122 			done = 1;
1123 			stopped = 1;
1124 			for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
1125 				if (sp->pid == -1)
1126 					continue;
1127 				if (sp->pid == pid && (sp->status == -1 ||
1128 				    WIFSTOPPED(sp->status))) {
1129 					TRACE(("Changing status of proc %d from 0x%x to 0x%x\n",
1130 						   (int)pid, sp->status,
1131 						   status));
1132 					if (WIFCONTINUED(status)) {
1133 						sp->status = -1;
1134 						jp->state = 0;
1135 					} else
1136 						sp->status = status;
1137 					thisjob = jp;
1138 				}
1139 				if (sp->status == -1)
1140 					stopped = 0;
1141 				else if (WIFSTOPPED(sp->status))
1142 					done = 0;
1143 			}
1144 			if (stopped) {		/* stopped or done */
1145 				int state = done? JOBDONE : JOBSTOPPED;
1146 				if (jp->state != state) {
1147 					TRACE(("Job %td: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
1148 					jp->state = state;
1149 					if (jp != job) {
1150 						if (done && !jp->remembered &&
1151 						    !iflag && jp != bgjob)
1152 							freejob(jp);
1153 #if JOBS
1154 						else if (done)
1155 							deljob(jp);
1156 #endif
1157 					}
1158 				}
1159 			}
1160 		}
1161 	}
1162 	INTON;
1163 	if (!thisjob || thisjob->state == 0)
1164 		;
1165 	else if ((!rootshell || !iflag || thisjob == job) &&
1166 	    thisjob->foreground && thisjob->state != JOBSTOPPED) {
1167 		sig = 0;
1168 		coredump = 0;
1169 		for (sp = thisjob->ps; sp < thisjob->ps + thisjob->nprocs; sp++)
1170 			if (WIFSIGNALED(sp->status)) {
1171 				sig = WTERMSIG(sp->status);
1172 				coredump = WCOREDUMP(sp->status);
1173 			}
1174 		if (sig > 0 && sig != SIGINT && sig != SIGPIPE) {
1175 			sigstr = strsignal(sig);
1176 			if (sigstr != NULL)
1177 				out2str(sigstr);
1178 			else
1179 				out2str("Unknown signal");
1180 			if (coredump)
1181 				out2str(" (core dumped)");
1182 			out2c('\n');
1183 			flushout(out2);
1184 		}
1185 	} else {
1186 		TRACE(("Not printing status, rootshell=%d, job=%p\n", rootshell, job));
1187 		thisjob->changed = 1;
1188 	}
1189 	return pid;
1190 }
1191 
1192 
1193 
1194 /*
1195  * return 1 if there are stopped jobs, otherwise 0
1196  */
1197 int job_warning = 0;
1198 int
1199 stoppedjobs(void)
1200 {
1201 	int jobno;
1202 	struct job *jp;
1203 
1204 	if (job_warning)
1205 		return (0);
1206 	for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
1207 		if (jp->used == 0)
1208 			continue;
1209 		if (jp->state == JOBSTOPPED) {
1210 			out2fmt_flush("You have stopped jobs.\n");
1211 			job_warning = 2;
1212 			return (1);
1213 		}
1214 	}
1215 
1216 	return (0);
1217 }
1218 
1219 
1220 static void
1221 checkzombies(void)
1222 {
1223 	while (njobs > 0 && dowait(0, NULL) > 0)
1224 		;
1225 }
1226 
1227 
1228 int
1229 backgndpidset(void)
1230 {
1231 	return backgndpid != -1;
1232 }
1233 
1234 
1235 pid_t
1236 backgndpidval(void)
1237 {
1238 	if (bgjob != NULL && !forcelocal)
1239 		bgjob->remembered = 1;
1240 	return backgndpid;
1241 }
1242 
1243 /*
1244  * Return a string identifying a command (to be printed by the
1245  * jobs command.
1246  */
1247 
1248 static char *cmdnextc;
1249 static int cmdnleft;
1250 #define MAXCMDTEXT	200
1251 
1252 char *
1253 commandtext(union node *n)
1254 {
1255 	char *name;
1256 
1257 	cmdnextc = name = ckmalloc(MAXCMDTEXT);
1258 	cmdnleft = MAXCMDTEXT - 4;
1259 	cmdtxt(n);
1260 	*cmdnextc = '\0';
1261 	return name;
1262 }
1263 
1264 
1265 static void
1266 cmdtxt(union node *n)
1267 {
1268 	union node *np;
1269 	struct nodelist *lp;
1270 	const char *p;
1271 	int i;
1272 	char s[2];
1273 
1274 	if (n == NULL)
1275 		return;
1276 	switch (n->type) {
1277 	case NSEMI:
1278 		cmdtxt(n->nbinary.ch1);
1279 		cmdputs("; ");
1280 		cmdtxt(n->nbinary.ch2);
1281 		break;
1282 	case NAND:
1283 		cmdtxt(n->nbinary.ch1);
1284 		cmdputs(" && ");
1285 		cmdtxt(n->nbinary.ch2);
1286 		break;
1287 	case NOR:
1288 		cmdtxt(n->nbinary.ch1);
1289 		cmdputs(" || ");
1290 		cmdtxt(n->nbinary.ch2);
1291 		break;
1292 	case NPIPE:
1293 		for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
1294 			cmdtxt(lp->n);
1295 			if (lp->next)
1296 				cmdputs(" | ");
1297 		}
1298 		break;
1299 	case NSUBSHELL:
1300 		cmdputs("(");
1301 		cmdtxt(n->nredir.n);
1302 		cmdputs(")");
1303 		break;
1304 	case NREDIR:
1305 	case NBACKGND:
1306 		cmdtxt(n->nredir.n);
1307 		break;
1308 	case NIF:
1309 		cmdputs("if ");
1310 		cmdtxt(n->nif.test);
1311 		cmdputs("; then ");
1312 		cmdtxt(n->nif.ifpart);
1313 		cmdputs("...");
1314 		break;
1315 	case NWHILE:
1316 		cmdputs("while ");
1317 		goto until;
1318 	case NUNTIL:
1319 		cmdputs("until ");
1320 until:
1321 		cmdtxt(n->nbinary.ch1);
1322 		cmdputs("; do ");
1323 		cmdtxt(n->nbinary.ch2);
1324 		cmdputs("; done");
1325 		break;
1326 	case NFOR:
1327 		cmdputs("for ");
1328 		cmdputs(n->nfor.var);
1329 		cmdputs(" in ...");
1330 		break;
1331 	case NCASE:
1332 		cmdputs("case ");
1333 		cmdputs(n->ncase.expr->narg.text);
1334 		cmdputs(" in ...");
1335 		break;
1336 	case NDEFUN:
1337 		cmdputs(n->narg.text);
1338 		cmdputs("() ...");
1339 		break;
1340 	case NNOT:
1341 		cmdputs("! ");
1342 		cmdtxt(n->nnot.com);
1343 		break;
1344 	case NCMD:
1345 		for (np = n->ncmd.args ; np ; np = np->narg.next) {
1346 			cmdtxt(np);
1347 			if (np->narg.next)
1348 				cmdputs(" ");
1349 		}
1350 		for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
1351 			cmdputs(" ");
1352 			cmdtxt(np);
1353 		}
1354 		break;
1355 	case NARG:
1356 		cmdputs(n->narg.text);
1357 		break;
1358 	case NTO:
1359 		p = ">";  i = 1;  goto redir;
1360 	case NAPPEND:
1361 		p = ">>";  i = 1;  goto redir;
1362 	case NTOFD:
1363 		p = ">&";  i = 1;  goto redir;
1364 	case NCLOBBER:
1365 		p = ">|"; i = 1; goto redir;
1366 	case NFROM:
1367 		p = "<";  i = 0;  goto redir;
1368 	case NFROMTO:
1369 		p = "<>";  i = 0;  goto redir;
1370 	case NFROMFD:
1371 		p = "<&";  i = 0;  goto redir;
1372 redir:
1373 		if (n->nfile.fd != i) {
1374 			s[0] = n->nfile.fd + '0';
1375 			s[1] = '\0';
1376 			cmdputs(s);
1377 		}
1378 		cmdputs(p);
1379 		if (n->type == NTOFD || n->type == NFROMFD) {
1380 			if (n->ndup.dupfd >= 0)
1381 				s[0] = n->ndup.dupfd + '0';
1382 			else
1383 				s[0] = '-';
1384 			s[1] = '\0';
1385 			cmdputs(s);
1386 		} else {
1387 			cmdtxt(n->nfile.fname);
1388 		}
1389 		break;
1390 	case NHERE:
1391 	case NXHERE:
1392 		cmdputs("<<...");
1393 		break;
1394 	default:
1395 		cmdputs("???");
1396 		break;
1397 	}
1398 }
1399 
1400 
1401 
1402 static void
1403 cmdputs(const char *s)
1404 {
1405 	const char *p;
1406 	char *q;
1407 	char c;
1408 	int subtype = 0;
1409 
1410 	if (cmdnleft <= 0)
1411 		return;
1412 	p = s;
1413 	q = cmdnextc;
1414 	while ((c = *p++) != '\0') {
1415 		if (c == CTLESC)
1416 			*q++ = *p++;
1417 		else if (c == CTLVAR) {
1418 			*q++ = '$';
1419 			if (--cmdnleft > 0)
1420 				*q++ = '{';
1421 			subtype = *p++;
1422 			if ((subtype & VSTYPE) == VSLENGTH && --cmdnleft > 0)
1423 				*q++ = '#';
1424 		} else if (c == '=' && subtype != 0) {
1425 			*q = "}-+?=##%%\0X"[(subtype & VSTYPE) - VSNORMAL];
1426 			if (*q)
1427 				q++;
1428 			else
1429 				cmdnleft++;
1430 			if (((subtype & VSTYPE) == VSTRIMLEFTMAX ||
1431 			    (subtype & VSTYPE) == VSTRIMRIGHTMAX) &&
1432 			    --cmdnleft > 0)
1433 				*q = q[-1], q++;
1434 			subtype = 0;
1435 		} else if (c == CTLENDVAR) {
1436 			*q++ = '}';
1437 		} else if (c == CTLBACKQ || c == CTLBACKQ+CTLQUOTE) {
1438 			cmdnleft -= 5;
1439 			if (cmdnleft > 0) {
1440 				*q++ = '$';
1441 				*q++ = '(';
1442 				*q++ = '.';
1443 				*q++ = '.';
1444 				*q++ = '.';
1445 				*q++ = ')';
1446 			}
1447 		} else if (c == CTLARI) {
1448 			cmdnleft -= 2;
1449 			if (cmdnleft > 0) {
1450 				*q++ = '$';
1451 				*q++ = '(';
1452 				*q++ = '(';
1453 			}
1454 			p++;
1455 		} else if (c == CTLENDARI) {
1456 			if (--cmdnleft > 0) {
1457 				*q++ = ')';
1458 				*q++ = ')';
1459 			}
1460 		} else if (c == CTLQUOTEMARK || c == CTLQUOTEEND)
1461 			cmdnleft++; /* ignore */
1462 		else
1463 			*q++ = c;
1464 		if (--cmdnleft <= 0) {
1465 			*q++ = '.';
1466 			*q++ = '.';
1467 			*q++ = '.';
1468 			break;
1469 		}
1470 	}
1471 	cmdnextc = q;
1472 }
1473