/usr/src/bin/ksh/jobs.c

Bug Summary

File:	src/bin/ksh/jobs.c
Warning:	line 416, column 19 Access to field 'next' results in a dereference of a null pointer (loaded from variable 'last_proc')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name jobs.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/bin/ksh/obj -resource-dir /usr/local/llvm16/lib/clang/16 -D EMACS -D VI -I . -I /usr/src/bin/ksh -I /usr/src/bin/ksh/../../lib/libc/gen -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/bin/ksh/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/bin/ksh/jobs.c
1/*	$OpenBSD: jobs.c,v 1.62 2020/07/07 10:33:58 jca Exp $	*/

3/*
* Process and job control
*/

7/*
* Reworked/Rewritten version of Eric Gisin's/Ron Natalie's code by
* Larry Bouzane (larry@cs.mun.ca) and hacked again by
* Michael Rendell (michael@cs.mun.ca)
*
* The interface to the rest of the shell should probably be changed
* to allow use of vfork() when available but that would be way too much
* work :)
*
*/

18#include <sys/resource.h>
19#include <sys/stat.h>
20#include <sys/time.h>
21#include <sys/wait.h>

23#include <ctype.h>
24#include <errno(*__errno()).h>
25#include <fcntl.h>
26#include <limits.h>
27#include <stdlib.h>
28#include <string.h>
29#include <unistd.h>

31#include "sh.h"
32#include "tty.h"

34/* Order important! */
35#define PRUNNING0	0
36#define PEXITED1		1
37#define PSIGNALLED2	2
38#define PSTOPPED3	3

40typedef struct proc	Proc;
41struct proc {
Proc	*next;		/* next process in pipeline (if any) */
int	state;
int	status;		/* wait status */
pid_t	pid;		/* process id */
char	command[48];	/* process command string */
47};

49/* Notify/print flag - j_print() argument */
50#define JP_NONE0		0	/* don't print anything */
51#define JP_SHORT1	1	/* print signals processes were killed by */
52#define JP_MEDIUM2	2	/* print [job-num] -/+ command */
53#define JP_LONG3		3	/* print [job-num] -/+ pid command */
54#define JP_PGRP4		4	/* print pgrp */

56/* put_job() flags */
57#define PJ_ON_FRONT0	0	/* at very front */
58#define PJ_PAST_STOPPED1	1	/* just past any stopped jobs */

60/* Job.flags values */
61#define JF_STARTED0x001	0x001	/* set when all processes in job are started */
62#define JF_WAITING0x002	0x002	/* set if j_waitj() is waiting on job */
63#define JF_W_ASYNCNOTIFY0x004 0x004	/* set if waiting and async notification ok */
64#define JF_XXCOM0x008	0x008	/* set for `command` jobs */
65#define JF_FG0x010		0x010	/* running in foreground (also has tty pgrp) */
66#define JF_SAVEDTTY0x020	0x020	/* j->ttystate is valid */
67#define JF_CHANGED0x040	0x040	/* process has changed state */
68#define JF_KNOWN0x080	0x080	/* $! referenced */
69#define JF_ZOMBIE0x100	0x100	/* known, unwaited process */
70#define JF_REMOVE0x200	0x200	/* flagged for removal (j_jobs()/j_notify()) */
71#define JF_USETTYMODE0x400	0x400	/* tty mode saved if process exits normally */
72#define JF_SAVEDTTYPGRP0x800	0x800	/* j->saved_ttypgrp is valid */
73#define JF_PIPEFAIL0x1000	0x1000	/* pipefail on when job was started */

75typedef struct job Job;
76struct job {
Job	*next;		/* next job in list */
int	job;		/* job number: %n */
int	flags;		/* see JF_* */
int	state;		/* job state */
int	status;		/* exit status of last process */
pid_t	pgrp;		/* process group of job */
pid_t	ppid;		/* pid of process that forked job */
int	age;		/* number of jobs started */
struct timeval systime;	/* system time used by job */
struct timeval usrtime;	/* user time used by job */
Proc	*proc_list;	/* process list */
Proc	*last_proc;	/* last process in list */
Coproc_id coproc_id;	/* 0 or id of coprocess output pipe */
struct termios ttystate;/* saved tty state for stopped jobs */
pid_t	saved_ttypgrp;	/* saved tty process group for stopped jobs */
92};

94/* Flags for j_waitj() */
95#define JW_NONE0x00		0x00
96#define JW_INTERRUPT0x01	0x01	/* ^C will stop the wait */
97#define JW_ASYNCNOTIFY0x02	0x02	/* asynchronous notification during wait ok */
98#define JW_STOPPEDWAIT0x04	0x04	/* wait even if job stopped */

100/* Error codes for j_lookup() */
101#define JL_OK0		0
102#define JL_NOSUCH1	1	/* no such job */
103#define JL_AMBIG2	2	/* %foo or %?foo is ambiguous */
104#define JL_INVALID3	3	/* non-pid, non-% job id */

106static const char	*const lookup_msgs[] = {
null,
"no such job",
"ambiguous",
"argument must be %job or process id",
NULL((void *)0)
112};

114struct timeval	j_systime, j_usrtime;	/* user and system time of last j_waitjed job */

116static Job		*job_list;	/* job list */
117static Job		*last_job;
118static Job		*async_job;
119static pid_t		async_pid;

121static int		nzombie;	/* # of zombies owned by this process */
122int			njobs;		/* # of jobs started */
123static int		child_max;	/* CHILD_MAX */


126/* held_sigchld is set if sigchld occurs before a job is completely started */
127static volatile sig_atomic_t held_sigchld;

129static struct shf	*shl_j;
130static int		ttypgrp_ok;	/* set if can use tty pgrps */
131static pid_t		restore_ttypgrp = -1;
132static pid_t		our_pgrp;
133static int const	tt_sigs[] = { SIGTSTP18, SIGTTIN21, SIGTTOU22 };

135static void		j_set_async(Job *);
136static void		j_startjob(Job *);
137static int		j_waitj(Job *, int, const char *);
138static void		j_sigchld(int);
139static void		j_print(Job *, int, struct shf *);
140static Job		*j_lookup(const char *, int *);
141static Job		*new_job(void);
142static Proc		*new_proc(void);
143static void		check_job(Job *);
144static void		put_job(Job *, int);
145static void		remove_job(Job *, const char *);
146static int		kill_job(Job *, int);

148/* initialize job control */
149void
150j_init(int mflagset)
151{
child_max = CHILD_MAX80; /* so syscon() isn't always being called */

sigemptyset(&sm_default);
sigprocmask(SIG_SETMASK3, &sm_default, NULL((void *)0));

sigemptyset(&sm_sigchld);
sigaddset(&sm_sigchld, SIGCHLD20);

setsig(&sigtraps[SIGCHLD20], j_sigchld,
   SS_RESTORE_ORIG1|SS_FORCE(1<<(3))|SS_SHTRAP(1<<(5)));

if (!mflagset && Flag(FTALKING)(shell_flags[(int) (FTALKING)]))
Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) = 1;

/* shl_j is used to do asynchronous notification (used in
* an interrupt handler, so need a distinct shf)
*/
shl_j = shf_fdopen(2, SHF_WR0x0002, NULL((void *)0));

if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) || Flag(FTALKING)(shell_flags[(int) (FTALKING)])) {
int i;

/* the TF_SHELL_USES test is a kludge that lets us know if
 * if the signals have been changed by the shell.
 */
for (i = NELEM(tt_sigs)(sizeof(tt_sigs) / sizeof((tt_sigs)[0])); --i >= 0; ) {
	sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES(1<<(0));
	/* j_change() sets this to SS_RESTORE_DFL if FMONITOR */
	setsig(&sigtraps[tt_sigs[i]], SIG_IGN(void (*)(int))1,
	    SS_RESTORE_IGN3|SS_FORCE(1<<(3)));
}
}

/* j_change() calls tty_init() */
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]))
j_change();
else if (Flag(FTALKING)(shell_flags[(int) (FTALKING)]))
tty_init(true1);
190}

192/* suspend the shell */
193void
194j_suspend(void)
195{
struct sigaction sa, osa;

/* Restore tty and pgrp. */
if (ttypgrp_ok) {
tcsetattr(tty_fd, TCSADRAIN1, &tty_state);
if (restore_ttypgrp >= 0) {
	if (tcsetpgrp(tty_fd, restore_ttypgrp) == -1) {
		warningf(false0, "%s: tcsetpgrp() failed: %s",
		    __func__, strerror(errno(*__errno())));
	} else {
		if (setpgid(0, restore_ttypgrp) == -1) {
			warningf(false0,
			    "%s: setpgid() failed: %s",
			    __func__, strerror(errno(*__errno())));
		}
	}
}
}

/* Suspend the shell. */
memset(&sa, 0, sizeof(sa));
sigemptyset(&sa.sa_mask);
sa.sa_handler__sigaction_u.__sa_handler = SIG_DFL(void (*)(int))0;
sigaction(SIGTSTP18, &sa, &osa);
kill(0, SIGTSTP18);

/* Back from suspend, reset signals, pgrp and tty. */
sigaction(SIGTSTP18, &osa, NULL((void *)0));
if (ttypgrp_ok) {
if (restore_ttypgrp >= 0) {
	if (setpgid(0, kshpid) == -1) {
		warningf(false0, "%s: setpgid() failed: %s",
		    __func__, strerror(errno(*__errno())));
		ttypgrp_ok = 0;
	} else {
		if (tcsetpgrp(tty_fd, kshpid) == -1) {
			warningf(false0,
			    "%s: tcsetpgrp() failed: %s",
			    __func__, strerror(errno(*__errno())));
			ttypgrp_ok = 0;
		}
	}
}
tty_init(true1);
}
241}

243/* job cleanup before shell exit */
244void
245j_exit(void)
246{
/* kill stopped, and possibly running, jobs */
Job	*j;
int	killed = 0;

for (j = job_list; j != NULL((void *)0); j = j->next) {
if (j->ppid == procpid &&
    (j->state == PSTOPPED3 ||
    (j->state == PRUNNING0 &&
    ((j->flags & JF_FG0x010) ||
    (Flag(FLOGIN)(shell_flags[(int) (FLOGIN)]) && !Flag(FNOHUP)(shell_flags[(int) (FNOHUP)]) && procpid == kshpid))))) {
	killed = 1;
	if (j->pgrp == 0)
		kill_job(j, SIGHUP1);
	else
		killpg(j->pgrp, SIGHUP1);
	if (j->state == PSTOPPED3) {
		if (j->pgrp == 0)
			kill_job(j, SIGCONT19);
		else
			killpg(j->pgrp, SIGCONT19);
	}
}
}
if (killed)
sleep(1);
j_notify();

if (kshpid == procpid && restore_ttypgrp >= 0) {
/* Need to restore the tty pgrp to what it was when the
 * shell started up, so that the process that started us
 * will be able to access the tty when we are done.
 * Also need to restore our process group in case we are
 * about to do an exec so that both our parent and the
 * process we are to become will be able to access the tty.
 */
tcsetpgrp(tty_fd, restore_ttypgrp);
setpgid(0, restore_ttypgrp);
}
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)])) {
Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) = 0;
j_change();
}
289}

291/* turn job control on or off according to Flag(FMONITOR) */
292void
293j_change(void)
294{
int i;

if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)])) {
int use_tty;

if (Flag(FTALKING)(shell_flags[(int) (FTALKING)])) {
	/* Don't call tcgetattr() 'til we own the tty process group */
	use_tty = 1;
	tty_init(false0);
} else
	use_tty = 0;

/* no controlling tty, no SIGT* */
ttypgrp_ok = use_tty && tty_fd >= 0 && tty_devtty;

if (ttypgrp_ok && (our_pgrp = getpgrp()) < 0) {
	warningf(false0, "%s: getpgrp() failed: %s",
	    __func__, strerror(errno(*__errno())));
	ttypgrp_ok = 0;
}
if (ttypgrp_ok) {
	setsig(&sigtraps[SIGTTIN21], SIG_DFL(void (*)(int))0,
	    SS_RESTORE_ORIG1|SS_FORCE(1<<(3)));
	/* wait to be given tty (POSIX.1, B.2, job control) */
	while (1) {
		pid_t ttypgrp;

		if ((ttypgrp = tcgetpgrp(tty_fd)) == -1) {
			warningf(false0,
			    "%s: tcgetpgrp() failed: %s",
			    __func__, strerror(errno(*__errno())));
			ttypgrp_ok = 0;
			break;
		}
		if (ttypgrp == our_pgrp)
			break;
		kill(0, SIGTTIN21);
	}
}
for (i = NELEM(tt_sigs)(sizeof(tt_sigs) / sizeof((tt_sigs)[0])); --i >= 0; )
	setsig(&sigtraps[tt_sigs[i]], SIG_IGN(void (*)(int))1,
	    SS_RESTORE_DFL2|SS_FORCE(1<<(3)));
if (ttypgrp_ok && our_pgrp != kshpid) {
	if (setpgid(0, kshpid) == -1) {
		warningf(false0, "%s: setpgid() failed: %s",
		    __func__, strerror(errno(*__errno())));
		ttypgrp_ok = 0;
	} else {
		if (tcsetpgrp(tty_fd, kshpid) == -1) {
			warningf(false0,
			    "%s: tcsetpgrp() failed: %s",
			    __func__, strerror(errno(*__errno())));
			ttypgrp_ok = 0;
		} else
			restore_ttypgrp = our_pgrp;
		our_pgrp = kshpid;
	}
}
if (use_tty) {
	if (!ttypgrp_ok)
		warningf(false0,
		    "warning: won't have full job control");
}
if (tty_fd >= 0)
	tcgetattr(tty_fd, &tty_state);
} else {
ttypgrp_ok = 0;
if (Flag(FTALKING)(shell_flags[(int) (FTALKING)]))
	for (i = NELEM(tt_sigs)(sizeof(tt_sigs) / sizeof((tt_sigs)[0])); --i >= 0; )
		setsig(&sigtraps[tt_sigs[i]], SIG_IGN(void (*)(int))1,
		    SS_RESTORE_IGN3|SS_FORCE(1<<(3)));
else
	for (i = NELEM(tt_sigs)(sizeof(tt_sigs) / sizeof((tt_sigs)[0])); --i >= 0; ) {
		if (sigtraps[tt_sigs[i]].flags &
		    (TF_ORIG_IGN(1<<(2)) | TF_ORIG_DFL(1<<(3))))
			setsig(&sigtraps[tt_sigs[i]],
			    (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN(1<<(2))) ?
			    SIG_IGN(void (*)(int))1 : SIG_DFL(void (*)(int))0,
			    SS_RESTORE_ORIG1|SS_FORCE(1<<(3)));
	}
if (!Flag(FTALKING)(shell_flags[(int) (FTALKING)]))
	tty_close();
}
378}

380/* execute tree in child subprocess */
381int
382exchild(struct op *t, int flags, volatile int *xerrok,
  int close_fd)	/* used if XPCLOSE or XCCLOSE */
384{
static Proc	*last_proc;	/* for pipelines */
1
'last_proc' initialized to a null pointer value→

int		i;
sigset_t	omask;
Proc		*p;
Job		*j;
int		rv = 0;
int		forksleep;
int		ischild;

if (flags & XEXEC(1<<(0)))
2
←
Assuming the condition is false→
3
←
Taking false branch→
/* Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND
 * (also done in another execute() below)
 */
return execute(t, flags & (XEXEC(1<<(0)) | XERROK(1<<(8))), xerrok);

/* no SIGCHLD's while messing with job and process lists */
sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

p = new_proc();
p->next = NULL((void *)0);
p->state = PRUNNING0;
p->status = 0;
p->pid = 0;

/* link process into jobs list */
if (flags&XPIPEI(1<<(3))) {	/* continuing with a pipe */
4
←
Assuming the condition is true→
5
←
Taking true branch→
if (!last_job)
6
←
Assuming 'last_job' is non-null→
7
←
Taking false branch→
	internal_errorf("%s: XPIPEI and no last_job - pid %d",
	    __func__, (int) procpid);
j = last_job;
last_proc->next = p;
8
←
Access to field 'next' results in a dereference of a null pointer (loaded from variable 'last_proc')
last_proc = p;
} else {
j = new_job(); /* fills in j->job */
/* we don't consider XXCOM's foreground since they don't get
 * tty process group and we don't save or restore tty modes.
 */
j->flags = (flags & XXCOM(1<<(5))) ? JF_XXCOM0x008 :
    ((flags & XBGND(1<<(2))) ? 0 : (JF_FG0x010|JF_USETTYMODE0x400));
if (Flag(FPIPEFAIL)(shell_flags[(int) (FPIPEFAIL)]))
	j->flags |= JF_PIPEFAIL0x1000;
timerclear(&j->usrtime)(&j->usrtime)->tv_sec = (&j->usrtime)->tv_usec
 = 0;
timerclear(&j->systime)(&j->systime)->tv_sec = (&j->systime)->tv_usec
 = 0;
j->state = PRUNNING0;
j->pgrp = 0;
j->ppid = procpid;
j->age = ++njobs;
j->proc_list = p;
j->coproc_id = 0;
last_job = j;
last_proc = p;
put_job(j, PJ_PAST_STOPPED1);
}

snptreef(p->command, sizeof(p->command), "%T", t);

/* create child process */
forksleep = 1;
while ((i = fork()) == -1 && errno(*__errno()) == EAGAIN35 && forksleep < 32) {
if (intrsig)	 /* allow user to ^C out... */
	break;
sleep(forksleep);
forksleep <<= 1;
}
if (i == -1) {
kill_job(j, SIGKILL9);
remove_job(j, "fork failed");
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
errorf("cannot fork - try again");
}
ischild = i == 0;
if (ischild)
p->pid = procpid = getpid();
else
p->pid = i;

/* job control set up */
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) && !(flags&XXCOM(1<<(5)))) {
int	dotty = 0;
if (j->pgrp == 0) {	/* First process */
	j->pgrp = p->pid;
	dotty = 1;
}

/* set pgrp in both parent and child to deal with race
 * condition
 */
setpgid(p->pid, j->pgrp);
/* YYY: should this be
   if (ttypgrp_ok && ischild && !(flags&XBGND))
	tcsetpgrp(tty_fd, j->pgrp);
   instead? (see also YYY below)
 */
if (ttypgrp_ok && dotty && !(flags & XBGND(1<<(2))))
	tcsetpgrp(tty_fd, j->pgrp);
}

/* used to close pipe input fd */
if (close_fd >= 0 && (((flags & XPCLOSE(1<<(6))) && !ischild) ||
   ((flags & XCCLOSE(1<<(7))) && ischild)))
close(close_fd);
if (ischild) {		/* child */
/* Do this before restoring signal */
if (flags & XCOPROC(1<<(9)))
	coproc_cleanup(false0);
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
cleanup_parents_env();
/* If FMONITOR or FTALKING is set, these signals are ignored,
 * if neither FMONITOR nor FTALKING are set, the signals have
 * their inherited values.
 */
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) && !(flags & XXCOM(1<<(5)))) {
	for (i = NELEM(tt_sigs)(sizeof(tt_sigs) / sizeof((tt_sigs)[0])); --i >= 0; )
		setsig(&sigtraps[tt_sigs[i]], SIG_DFL(void (*)(int))0,
		    SS_RESTORE_DFL2|SS_FORCE(1<<(3)));
}
if (Flag(FBGNICE)(shell_flags[(int) (FBGNICE)]) && (flags & XBGND(1<<(2))))
	nice(4);
if ((flags & XBGND(1<<(2))) && !Flag(FMONITOR)(shell_flags[(int) (FMONITOR)])) {
	setsig(&sigtraps[SIGINT2], SIG_IGN(void (*)(int))1,
	    SS_RESTORE_IGN3|SS_FORCE(1<<(3)));
	setsig(&sigtraps[SIGQUIT3], SIG_IGN(void (*)(int))1,
	    SS_RESTORE_IGN3|SS_FORCE(1<<(3)));
	if (!(flags & (XPIPEI(1<<(3)) | XCOPROC(1<<(9))))) {
		int fd = open("/dev/null", O_RDONLY0x0000);
		if (fd != 0) {
			(void) ksh_dup2(fd, 0, true1);
			close(fd);
		}
	}
}
remove_job(j, "child");	/* in case of `jobs` command */
nzombie = 0;
ttypgrp_ok = 0;
Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) = 0;
Flag(FTALKING)(shell_flags[(int) (FTALKING)]) = 0;
tty_close();
cleartraps();
execute(t, (flags & XERROK(1<<(8))) | XEXEC(1<<(0)), NULL((void *)0)); /* no return */
internal_warningf("%s: execute() returned", __func__);
unwind(LLEAVE4);
/* NOTREACHED */
}

/* shell (parent) stuff */
/* Ensure next child gets a (slightly) different $RANDOM sequence */
change_random();
if (!(flags & XPIPEO(1<<(4)))) {	/* last process in a job */
/* YYY: Is this needed? (see also YYY above)
   if (Flag(FMONITOR) && !(flags&(XXCOM|XBGND)))
	tcsetpgrp(tty_fd, j->pgrp);
*/
j_startjob(j);
if (flags & XCOPROC(1<<(9))) {
	j->coproc_id = coproc.id;
	coproc.njobs++; /* n jobs using co-process output */
	coproc.job = (void *) j; /* j using co-process input */
}
if (flags & XBGND(1<<(2))) {
	j_set_async(j);
	if (Flag(FTALKING)(shell_flags[(int) (FTALKING)])) {
		shf_fprintf(shl_out(&shf_iob[2]), "[%d]", j->job);
		for (p = j->proc_list; p; p = p->next)
			shf_fprintf(shl_out(&shf_iob[2]), " %d", p->pid);
		shf_putchar('\n', shl_out(&shf_iob[2]));
		shf_flush(shl_out(&shf_iob[2]));
	}
} else
	rv = j_waitj(j, JW_NONE0x00, "jw:last proc");
}

sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));

return rv;
560}

562/* start the last job: only used for `command` jobs */
563void
564startlast(void)
565{
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

if (last_job) { /* no need to report error - waitlast() will do it */
/* ensure it isn't removed by check_job() */
last_job->flags |= JF_WAITING0x002;
j_startjob(last_job);
}
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
576}

578/* wait for last job: only used for `command` jobs */
579int
580waitlast(void)
581{
int	rv;
Job	*j;
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

j = last_job;
if (!j || !(j->flags & JF_STARTED0x001)) {
if (!j)
	warningf(true1, "%s: no last job", __func__);
else
	internal_warningf("%s: not started", __func__);
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
return 125; /* not so arbitrary, non-zero value */
}

rv = j_waitj(j, JW_NONE0x00, "jw:waitlast");

sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));

return rv;
603}

605/* wait for child, interruptable. */
606int
607waitfor(const char *cp, int *sigp)
608{
int	rv;
Job	*j;
int	ecode;
int	flags = JW_INTERRUPT0x01|JW_ASYNCNOTIFY0x02;
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

*sigp = 0;

if (cp == NULL((void *)0)) {
/* wait for an unspecified job - always returns 0, so
 * don't have to worry about exited/signaled jobs
 */
for (j = job_list; j; j = j->next)
	/* at&t ksh will wait for stopped jobs - we don't */
	if (j->ppid == procpid && j->state == PRUNNING0)
		break;
if (!j) {
	sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
	return -1;
}
} else if ((j = j_lookup(cp, &ecode))) {
/* don't report normal job completion */
flags &= ~JW_ASYNCNOTIFY0x02;
if (j->ppid != procpid) {
	sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
	return -1;
}
} else {
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
if (ecode != JL_NOSUCH1)
	bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
return -1;
}

/* at&t ksh will wait for stopped jobs - we don't */
rv = j_waitj(j, flags, "jw:waitfor");

sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));

if (rv < 0) /* we were interrupted */
*sigp = 128 + -rv;

return rv;
654}

656/* kill (built-in) a job */
657int
658j_kill(const char *cp, int sig)
659{
Job	*j;
int	rv = 0;
int	ecode;
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

if ((j = j_lookup(cp, &ecode)) == NULL((void *)0)) {
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
return 1;
}

if (j->pgrp == 0) {	/* started when !Flag(FMONITOR) */
if (kill_job(j, sig) < 0) {
	bi_errorf("%s: %s", cp, strerror(errno(*__errno())));
	rv = 1;
}
} else {
if (j->state == PSTOPPED3 && (sig == SIGTERM15 || sig == SIGHUP1))
	(void) killpg(j->pgrp, SIGCONT19);
if (killpg(j->pgrp, sig) == -1) {
	bi_errorf("%s: %s", cp, strerror(errno(*__errno())));
	rv = 1;
}
}

sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));

return rv;
690}

692/* fg and bg built-ins: called only if Flag(FMONITOR) set */
693int
694j_resume(const char *cp, int bg)
695{
Job	*j;
Proc	*p;
int	ecode;
int	running;
int	rv = 0;
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

if ((j = j_lookup(cp, &ecode)) == NULL((void *)0)) {
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
return 1;
}

if (j->pgrp == 0) {
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
bi_errorf("job not job-controlled");
return 1;
}

if (bg)
shprintf("[%d] ", j->job);

running = 0;
for (p = j->proc_list; p != NULL((void *)0); p = p->next) {
if (p->state == PSTOPPED3) {
	p->state = PRUNNING0;
	p->status = 0;
	running = 1;
}
shprintf("%s%s", p->command, p->next ? "| " : "");
}
shprintf("\n");
shf_flush(shl_stdout(&shf_iob[1]));
if (running)
j->state = PRUNNING0;

put_job(j, PJ_PAST_STOPPED1);
if (bg)
j_set_async(j);
else {
/* attach tty to job */
if (j->state == PRUNNING0) {
	if (ttypgrp_ok && (j->flags & JF_SAVEDTTY0x020))
		tcsetattr(tty_fd, TCSADRAIN1, &j->ttystate);
	/* See comment in j_waitj regarding saved_ttypgrp. */
	if (ttypgrp_ok &&
	    tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP0x800) ?
	    j->saved_ttypgrp : j->pgrp) == -1) {
		if (j->flags & JF_SAVEDTTY0x020)
			tcsetattr(tty_fd, TCSADRAIN1, &tty_state);
		sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
		bi_errorf("1st tcsetpgrp(%d, %d) failed: %s",
		    tty_fd,
		    (int) ((j->flags & JF_SAVEDTTYPGRP0x800) ?
		    j->saved_ttypgrp : j->pgrp),
		    strerror(errno(*__errno())));
		return 1;
	}
}
j->flags |= JF_FG0x010;
j->flags &= ~JF_KNOWN0x080;
if (j == async_job)
	async_job = NULL((void *)0);
}

if (j->state == PRUNNING0 && killpg(j->pgrp, SIGCONT19) == -1) {
int	err = errno(*__errno());

if (!bg) {
	j->flags &= ~JF_FG0x010;
	if (ttypgrp_ok && (j->flags & JF_SAVEDTTY0x020))
		tcsetattr(tty_fd, TCSADRAIN1, &tty_state);
	if (ttypgrp_ok && tcsetpgrp(tty_fd, our_pgrp) == -1) {
		warningf(true1,
		    "fg: 2nd tcsetpgrp(%d, %d) failed: %s",
		    tty_fd, (int) our_pgrp,
		    strerror(errno(*__errno())));
	}
}
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
bi_errorf("cannot continue job %s: %s",
    cp, strerror(err));
return 1;
}
if (!bg) {
if (ttypgrp_ok) {
	j->flags &= ~(JF_SAVEDTTY0x020 | JF_SAVEDTTYPGRP0x800);
}
rv = j_waitj(j, JW_NONE0x00, "jw:resume");
}
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
return rv;
790}

792/* are there any running or stopped jobs ? */
793int
794j_stopped_running(void)
795{
Job	*j;
int	which = 0;

for (j = job_list; j != NULL((void *)0); j = j->next) {
if (j->ppid == procpid && j->state == PSTOPPED3)
	which |= 1;
if (Flag(FLOGIN)(shell_flags[(int) (FLOGIN)]) && !Flag(FNOHUP)(shell_flags[(int) (FNOHUP)]) && procpid == kshpid &&
    j->ppid == procpid && j->state == PRUNNING0)
	which |= 2;
}
if (which) {
shellf("You have %s%s%s jobs\n",
    which & 1 ? "stopped" : "",
    which == 3 ? " and " : "",
    which & 2 ? "running" : "");
return 1;
}

return 0;
815}

817int
818j_njobs(void)
819{
Job *j;
int nj = 0;
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);
for (j = job_list; j; j = j->next)
nj++;

sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
return nj;
830}


833/* list jobs for jobs built-in */
834int
835j_jobs(const char *cp, int slp,
  int nflag)		/* 0: short, 1: long, 2: pgrp */
837{
Job	*j, *tmp;
int	how;
int	zflag = 0;
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

if (nflag < 0) { /* kludge: print zombies */
nflag = 0;
zflag = 1;
}
if (cp) {
int	ecode;

if ((j = j_lookup(cp, &ecode)) == NULL((void *)0)) {
	sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
	bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
	return 1;
}
} else
j = job_list;
how = slp == 0 ? JP_MEDIUM2 : (slp == 1 ? JP_LONG3 : JP_PGRP4);
for (; j; j = j->next) {
if ((!(j->flags & JF_ZOMBIE0x100) || zflag) &&
    (!nflag || (j->flags & JF_CHANGED0x040))) {
	j_print(j, how, shl_stdout(&shf_iob[1]));
	if (j->state == PEXITED1 || j->state == PSIGNALLED2)
		j->flags |= JF_REMOVE0x200;
}
if (cp)
	break;
}
/* Remove jobs after printing so there won't be multiple + or - jobs */
for (j = job_list; j; j = tmp) {
tmp = j->next;
if (j->flags & JF_REMOVE0x200)
	remove_job(j, "jobs");
}
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
return 0;
878}

880/* list jobs for top-level notification */
881void
882j_notify(void)
883{
Job	*j, *tmp;
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);
for (j = job_list; j; j = j->next) {
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) && (j->flags & JF_CHANGED0x040))
	j_print(j, JP_MEDIUM2, shl_out(&shf_iob[2]));
/* Remove job after doing reports so there aren't
 * multiple +/- jobs.
 */
if (j->state == PEXITED1 || j->state == PSIGNALLED2)
	j->flags |= JF_REMOVE0x200;
}
for (j = job_list; j; j = tmp) {
tmp = j->next;
if (j->flags & JF_REMOVE0x200)
	remove_job(j, "notify");
}
shf_flush(shl_out(&shf_iob[2]));
sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));
904}

906/* Return pid of last process in last asynchronous job */
907pid_t
908j_async(void)
909{
sigset_t omask;

sigprocmask(SIG_BLOCK1, &sm_sigchld, &omask);

if (async_job)
async_job->flags |= JF_KNOWN0x080;

sigprocmask(SIG_SETMASK3, &omask, NULL((void *)0));

return async_pid;
920}

922/* Make j the last async process
*
* Expects sigchld to be blocked.
*/
926static void
927j_set_async(Job *j)
928{
Job	*jl, *oldest;

if (async_job && (async_job->flags & (JF_KNOWN0x080|JF_ZOMBIE0x100)) == JF_ZOMBIE0x100)
remove_job(async_job, "async");
if (!(j->flags & JF_STARTED0x001)) {
internal_warningf("%s: job not started", __func__);
return;
}
async_job = j;
async_pid = j->last_proc->pid;
while (nzombie > child_max) {
oldest = NULL((void *)0);
for (jl = job_list; jl; jl = jl->next)
	if (jl != async_job && (jl->flags & JF_ZOMBIE0x100) &&
	    (!oldest || jl->age < oldest->age))
		oldest = jl;
if (!oldest) {
	/* XXX debugging */
	if (!(async_job->flags & JF_ZOMBIE0x100) || nzombie != 1) {
		internal_warningf("%s: bad nzombie (%d)",
		    __func__, nzombie);
		nzombie = 0;
	}
	break;
}
remove_job(oldest, "zombie");
}
956}

958/* Start a job: set STARTED, check for held signals and set j->last_proc
*
* Expects sigchld to be blocked.
*/
962static void
963j_startjob(Job *j)
964{
Proc	*p;

j->flags |= JF_STARTED0x001;
for (p = j->proc_list; p->next; p = p->next)
;
j->last_proc = p;

if (held_sigchld) {
held_sigchld = 0;
/* Don't call j_sigchld() as it may remove job... */
kill(procpid, SIGCHLD20);
}
977}

979/*
* wait for job to complete or change state
*
* Expects sigchld to be blocked.
*/
984static int
985j_waitj(Job *j,
  int flags,			/* see JW_* */
  const char *where)
988{
int	rv;

/*
* No auto-notify on the job we are waiting on.
*/
j->flags |= JF_WAITING0x002;
if (flags & JW_ASYNCNOTIFY0x02)
j->flags |= JF_W_ASYNCNOTIFY0x004;

if (!Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]))
flags |= JW_STOPPEDWAIT0x04;

while ((volatile int) j->state == PRUNNING0 ||
   ((flags & JW_STOPPEDWAIT0x04) && (volatile int) j->state == PSTOPPED3)) {
sigsuspend(&sm_default);
if (fatal_trap) {
	int oldf = j->flags & (JF_WAITING0x002|JF_W_ASYNCNOTIFY0x004);
	j->flags &= ~(JF_WAITING0x002|JF_W_ASYNCNOTIFY0x004);
	runtraps(TF_FATAL(1<<(9)));
	j->flags |= oldf; /* not reached... */
}
if ((flags & JW_INTERRUPT0x01) && (rv = trap_pending())) {
	j->flags &= ~(JF_WAITING0x002|JF_W_ASYNCNOTIFY0x004);
	return -rv;
}
}
j->flags &= ~(JF_WAITING0x002|JF_W_ASYNCNOTIFY0x004);

if (j->flags & JF_FG0x010) {
int	status;

j->flags &= ~JF_FG0x010;
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) && ttypgrp_ok && j->pgrp) {
	/*
	 * Save the tty's current pgrp so it can be restored
	 * when the job is foregrounded.  This is to
	 * deal with things like the GNU su which does
	 * a fork/exec instead of an exec (the fork means
	 * the execed shell gets a different pid from its
	 * pgrp, so naturally it sets its pgrp and gets hosed
	 * when it gets foregrounded by the parent shell, which
	 * has restored the tty's pgrp to that of the su
	 * process).
	 */
	if (j->state == PSTOPPED3 &&
	    (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0)
		j->flags |= JF_SAVEDTTYPGRP0x800;
	if (tcsetpgrp(tty_fd, our_pgrp) == -1) {
		warningf(true1,
		    "%s: tcsetpgrp(%d, %d) failed: %s",
		    __func__, tty_fd, (int)our_pgrp,
			strerror(errno(*__errno())));
	}
	if (j->state == PSTOPPED3) {
		j->flags |= JF_SAVEDTTY0x020;
		tcgetattr(tty_fd, &j->ttystate);
	}
}
if (tty_fd >= 0) {
	/* Only restore tty settings if job was originally
	 * started in the foreground.  Problems can be
	 * caused by things like `more foobar &' which will
	 * typically get and save the shell's vi/emacs tty
	 * settings before setting up the tty for itself;
	 * when more exits, it restores the `original'
	 * settings, and things go down hill from there...
	 */
	if (j->state == PEXITED1 && j->status == 0 &&
	    (j->flags & JF_USETTYMODE0x400)) {
		tcgetattr(tty_fd, &tty_state);
	} else {
		tcsetattr(tty_fd, TCSADRAIN1, &tty_state);
		/* Don't use tty mode if job is stopped and
		 * later restarted and exits.  Consider
		 * the sequence:
		 *	vi foo (stopped)
		 *	...
		 *	stty something
		 *	...
		 *	fg (vi; ZZ)
		 * mode should be that of the stty, not what
		 * was before the vi started.
		 */
		if (j->state == PSTOPPED3)
			j->flags &= ~JF_USETTYMODE0x400;
	}
}
/* If it looks like user hit ^C to kill a job, pretend we got
 * one too to break out of for loops, etc.  (at&t ksh does this
 * even when not monitoring, but this doesn't make sense since
 * a tty generated ^C goes to the whole process group)
 */
status = j->last_proc->status;
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) && j->state == PSIGNALLED2 &&
    WIFSIGNALED(status)(((status) & 0177) != 0177 && ((status) & 0177
) != 0) &&
    (sigtraps[WTERMSIG(status)(((status) & 0177))].flags & TF_TTY_INTR(1<<(7))))
	trapsig(WTERMSIG(status)(((status) & 0177)));
}

j_usrtime = j->usrtime;
j_systime = j->systime;

if (j->flags & JF_PIPEFAIL0x1000) {
Proc *p;
int status;

rv = 0;
for (p = j->proc_list; p != NULL((void *)0); p = p->next) {
	switch (p->state) {
	case PEXITED1:
		status = WEXITSTATUS(p->status)(int)(((unsigned)(p->status) >> 8) & 0xff);
		break;
	case PSIGNALLED2:
		status = 128 + WTERMSIG(p->status)(((p->status) & 0177));
		break;
	default:
		status = 0;
		break;
	}
	if (status)
		rv = status;
}
} else
rv = j->status;


if (!(flags & JW_ASYNCNOTIFY0x02) &&
   (!Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) || j->state != PSTOPPED3)) {
j_print(j, JP_SHORT1, shl_out(&shf_iob[2]));
shf_flush(shl_out(&shf_iob[2]));
}
if (j->state != PSTOPPED3 &&
   (!Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) || !(flags & JW_ASYNCNOTIFY0x02)))
remove_job(j, where);

return rv;
1125}

1127/* SIGCHLD handler to reap children and update job states
*
* Expects sigchld to be blocked.
*/
1131static void
1132j_sigchld(int sig)
1133{
int		errno_ = errno(*__errno());
Job		*j;
Proc		*p = NULL((void *)0);
int		pid;
int		status;
struct rusage	ru0, ru1;

/* Don't wait for any processes if a job is partially started.
* This is so we don't do away with the process group leader
* before all the processes in a pipe line are started (so the
* setpgid() won't fail)
*/
for (j = job_list; j; j = j->next)
if (j->ppid == procpid && !(j->flags & JF_STARTED0x001)) {
	held_sigchld = 1;
	goto finished;
}

getrusage(RUSAGE_CHILDREN(-1), &ru0);
do {
pid = waitpid(-1, &status, (WNOHANG0x01|WUNTRACED0x02));

if (pid <= 0)	/* return if would block (0) ... */
	break;	/* ... or no children or interrupted (-1) */

getrusage(RUSAGE_CHILDREN(-1), &ru1);

/* find job and process structures for this pid */
for (j = job_list; j != NULL((void *)0); j = j->next)
	for (p = j->proc_list; p != NULL((void *)0); p = p->next)
		if (p->pid == pid)
			goto found;
1166found:
if (j == NULL((void *)0)) {
	/* Can occur if process has kids, then execs shell
	warningf(true, "bad process waited for (pid = %d)",
		pid);
	 */
	ru0 = ru1;
	continue;
}

timeradd(&j->usrtime, &ru1.ru_utime, &j->usrtime)do { (&j->usrtime)->tv_sec = (&j->usrtime)->
tv_sec + (&ru1.ru_utime)->tv_sec; (&j->usrtime)
->tv_usec = (&j->usrtime)->tv_usec + (&ru1.ru_utime
)->tv_usec; if ((&j->usrtime)->tv_usec >= 1000000
) { (&j->usrtime)->tv_sec++; (&j->usrtime)->
tv_usec -= 1000000; } } while (0);
timersub(&j->usrtime, &ru0.ru_utime, &j->usrtime)do { (&j->usrtime)->tv_sec = (&j->usrtime)->
tv_sec - (&ru0.ru_utime)->tv_sec; (&j->usrtime)
->tv_usec = (&j->usrtime)->tv_usec - (&ru0.ru_utime
)->tv_usec; if ((&j->usrtime)->tv_usec < 0) {
 (&j->usrtime)->tv_sec--; (&j->usrtime)->
tv_usec += 1000000; } } while (0);
timeradd(&j->systime, &ru1.ru_stime, &j->systime)do { (&j->systime)->tv_sec = (&j->systime)->
tv_sec + (&ru1.ru_stime)->tv_sec; (&j->systime)
->tv_usec = (&j->systime)->tv_usec + (&ru1.ru_stime
)->tv_usec; if ((&j->systime)->tv_usec >= 1000000
) { (&j->systime)->tv_sec++; (&j->systime)->
tv_usec -= 1000000; } } while (0);
timersub(&j->systime, &ru0.ru_stime, &j->systime)do { (&j->systime)->tv_sec = (&j->systime)->
tv_sec - (&ru0.ru_stime)->tv_sec; (&j->systime)
->tv_usec = (&j->systime)->tv_usec - (&ru0.ru_stime
)->tv_usec; if ((&j->systime)->tv_usec < 0) {
 (&j->systime)->tv_sec--; (&j->systime)->
tv_usec += 1000000; } } while (0);
ru0 = ru1;
p->status = status;
if (WIFSTOPPED(status)(((status) & 0xff) == 0177))
	p->state = PSTOPPED3;
else if (WIFSIGNALED(status)(((status) & 0177) != 0177 && ((status) & 0177
) != 0))
	p->state = PSIGNALLED2;
else
	p->state = PEXITED1;

check_job(j);	/* check to see if entire job is done */
} while (1);

1192finished:
errno(*__errno()) = errno_;
1194}

1196/*
* Called only when a process in j has exited/stopped (ie, called only
* from j_sigchld()).  If no processes are running, the job status
* and state are updated, asynchronous job notification is done and,
* if unneeded, the job is removed.
*
* Expects sigchld to be blocked.
*/
1204static void
1205check_job(Job *j)
1206{
int	jstate;
Proc	*p;

/* XXX debugging (nasty - interrupt routine using shl_out) */
if (!(j->flags & JF_STARTED0x001)) {
internal_warningf("%s: job started (flags 0x%x)",
    __func__, j->flags);
return;
}

jstate = PRUNNING0;
for (p=j->proc_list; p != NULL((void *)0); p = p->next) {
if (p->state == PRUNNING0)
	return;	/* some processes still running */
if (p->state > jstate)
	jstate = p->state;
}
j->state = jstate;

switch (j->last_proc->state) {
case PEXITED1:
j->status = WEXITSTATUS(j->last_proc->status)(int)(((unsigned)(j->last_proc->status) >> 8) &
 0xff);
break;
case PSIGNALLED2:
j->status = 128 + WTERMSIG(j->last_proc->status)(((j->last_proc->status) & 0177));
break;
default:
j->status = 0;
break;
}

/* Note when co-process dies: can't be done in j_wait() nor
* remove_job() since neither may be called for non-interactive
* shells.
*/
if (j->state == PEXITED1 || j->state == PSIGNALLED2) {
/* No need to keep co-process input any more
 * (at least, this is what ksh93d thinks)
 */
if (coproc.job == j) {
	coproc.job = NULL((void *)0);
	/* XXX would be nice to get the closes out of here
	 * so they aren't done in the signal handler.
	 * Would mean a check in coproc_getfd() to
	 * do "if job == 0 && write >= 0, close write".
	 */
	coproc_write_close(coproc.write);
}
/* Do we need to keep the output? */
if (j->coproc_id && j->coproc_id == coproc.id &&
    --coproc.njobs == 0)
	coproc_readw_close(coproc.read);
}

j->flags |= JF_CHANGED0x040;
if (Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) && !(j->flags & JF_XXCOM0x008)) {
/* Only put stopped jobs at the front to avoid confusing
 * the user (don't want finished jobs effecting %+ or %-)
 */
if (j->state == PSTOPPED3)
	put_job(j, PJ_ON_FRONT0);
if (Flag(FNOTIFY)(shell_flags[(int) (FNOTIFY)]) &&
    (j->flags & (JF_WAITING0x002|JF_W_ASYNCNOTIFY0x004)) != JF_WAITING0x002) {
	/* Look for the real file descriptor 2 */
	{
		struct env *ep;
		int fd = 2;

		for (ep = genv; ep; ep = ep->oenv)
			if (ep->savefd && ep->savefd[2])
				fd = ep->savefd[2];
		shf_reopen(fd, SHF_WR0x0002, shl_j);
	}
	/* Can't call j_notify() as it removes jobs.  The job
	 * must stay in the job list as j_waitj() may be
	 * running with this job.
	 */
	j_print(j, JP_MEDIUM2, shl_j);
	shf_flush(shl_j);
	if (!(j->flags & JF_WAITING0x002) && j->state != PSTOPPED3)
		remove_job(j, "notify");
}
}
if (!Flag(FMONITOR)(shell_flags[(int) (FMONITOR)]) && !(j->flags & (JF_WAITING0x002|JF_FG0x010)) &&
   j->state != PSTOPPED3) {
if (j == async_job || (j->flags & JF_KNOWN0x080)) {
	j->flags |= JF_ZOMBIE0x100;
	j->job = -1;
	nzombie++;
} else
	remove_job(j, "checkjob");
}
1299}

1301/*
* Print job status in either short, medium or long format.
*
* Expects sigchld to be blocked.
*/
1306static void
1307j_print(Job *j, int how, struct shf *shf)
1308{
Proc	*p;
int	state;
int	status;
int	coredumped;
char	jobchar = ' ';
char	buf[64];
const char *filler;
int	output = 0;

if (how == JP_PGRP4) {
/* POSIX doesn't say what to do if there is no process
 * group leader (ie, !FMONITOR).  We arbitrarily return
 * last pid (which is what $! returns).
 */
shf_fprintf(shf, "%d\n", j->pgrp ? j->pgrp :
    (j->last_proc ? j->last_proc->pid : 0));
return;
}
j->flags &= ~JF_CHANGED0x040;
filler = j->job > 10 ?  "\n       " : "\n      ";
if (j == job_list)
jobchar = '+';
else if (j == job_list->next)
jobchar = '-';

for (p = j->proc_list; p != NULL((void *)0);) {
coredumped = 0;
switch (p->state) {
case PRUNNING0:
	strlcpy(buf, "Running", sizeof buf);
	break;
case PSTOPPED3:
	strlcpy(buf, sigtraps[WSTOPSIG(p->status)(int)(((unsigned)(p->status) >> 8) & 0xff)].mess,
	    sizeof buf);
	break;
case PEXITED1:
	if (how == JP_SHORT1)
		buf[0] = '\0';
	else if (WEXITSTATUS(p->status)(int)(((unsigned)(p->status) >> 8) & 0xff) == 0)
		strlcpy(buf, "Done", sizeof buf);
	else
		shf_snprintf(buf, sizeof(buf), "Done (%d)",
		    WEXITSTATUS(p->status)(int)(((unsigned)(p->status) >> 8) & 0xff));
	break;
case PSIGNALLED2:
	if (WCOREDUMP(p->status)((p->status) & 0200))
		coredumped = 1;
	/* kludge for not reporting `normal termination signals'
	 * (ie, SIGINT, SIGPIPE)
	 */
	if (how == JP_SHORT1 && !coredumped &&
	    (WTERMSIG(p->status)(((p->status) & 0177)) == SIGINT2 ||
	    WTERMSIG(p->status)(((p->status) & 0177)) == SIGPIPE13)) {
		buf[0] = '\0';
	} else
		strlcpy(buf, sigtraps[WTERMSIG(p->status)(((p->status) & 0177))].mess,
		    sizeof buf);
	break;
}

if (how != JP_SHORT1) {
	if (p == j->proc_list)
		shf_fprintf(shf, "[%d] %c ", j->job, jobchar);
	else
		shf_fprintf(shf, "%s", filler);
}

if (how == JP_LONG3)
	shf_fprintf(shf, "%5d ", p->pid);

if (how == JP_SHORT1) {
	if (buf[0]) {
		output = 1;
		shf_fprintf(shf, "%s%s ",
		    buf, coredumped ? " (core dumped)" : "");
	}
} else {
	output = 1;
	shf_fprintf(shf, "%-20s %s%s%s", buf, p->command,
	    p->next ? "|" : "",
	    coredumped ? " (core dumped)" : "");
}

state = p->state;
status = p->status;
p = p->next;
while (p && p->state == state && p->status == status) {
	if (how == JP_LONG3)
		shf_fprintf(shf, "%s%5d %-20s %s%s", filler, p->pid,
		    " ", p->command, p->next ? "|" : "");
	else if (how == JP_MEDIUM2)
		shf_fprintf(shf, " %s%s", p->command,
		    p->next ? "|" : "");
	p = p->next;
}
}
if (output)
shf_fprintf(shf, "\n");
1407}

1409/* Convert % sequence to job
*
* Expects sigchld to be blocked.
*/
1413static Job *
1414j_lookup(const char *cp, int *ecodep)
1415{
Job		*j, *last_match;
const char	*errstr;
Proc		*p;
int		len, job = 0;

if (digit(*cp)isdigit((unsigned char)(*cp))) {
job = strtonum(cp, 1, INT_MAX0x7fffffff, &errstr);
if (errstr) {
	if (ecodep)
		*ecodep = JL_NOSUCH1;
	return NULL((void *)0);
}
/* Look for last_proc->pid (what $! returns) first... */
for (j = job_list; j != NULL((void *)0); j = j->next)
	if (j->last_proc && j->last_proc->pid == job)
		return j;
/* ...then look for process group (this is non-POSIX),
 * but should not break anything (so FPOSIX isn't used).
 */
for (j = job_list; j != NULL((void *)0); j = j->next)
	if (j->pgrp && j->pgrp == job)
		return j;
if (ecodep)
	*ecodep = JL_NOSUCH1;
return NULL((void *)0);
}
if (*cp != '%') {
if (ecodep)
	*ecodep = JL_INVALID3;
return NULL((void *)0);
}
switch (*++cp) {
case '\0': /* non-standard */
case '+':
case '%':
if (job_list != NULL((void *)0))
	return job_list;
break;

case '-':
if (job_list != NULL((void *)0) && job_list->next)
	return job_list->next;
break;

case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
job = strtonum(cp, 1, INT_MAX0x7fffffff, &errstr);
if (errstr)
	break;
for (j = job_list; j != NULL((void *)0); j = j->next)
	if (j->job == job)
		return j;
break;

case '?':		/* %?string */
last_match = NULL((void *)0);
for (j = job_list; j != NULL((void *)0); j = j->next)
	for (p = j->proc_list; p != NULL((void *)0); p = p->next)
		if (strstr(p->command, cp+1) != NULL((void *)0)) {
			if (last_match) {
				if (ecodep)
					*ecodep = JL_AMBIG2;
				return NULL((void *)0);
			}
			last_match = j;
		}
if (last_match)
	return last_match;
break;

default:		/* %string */
len = strlen(cp);
last_match = NULL((void *)0);
for (j = job_list; j != NULL((void *)0); j = j->next)
	if (strncmp(cp, j->proc_list->command, len) == 0) {
		if (last_match) {
			if (ecodep)
				*ecodep = JL_AMBIG2;
			return NULL((void *)0);
		}
		last_match = j;
	}
if (last_match)
	return last_match;
break;
}
if (ecodep)
*ecodep = JL_NOSUCH1;
return NULL((void *)0);
1505}

1507static Job	*free_jobs;
1508static Proc	*free_procs;

1510/* allocate a new job and fill in the job number.
*
* Expects sigchld to be blocked.
*/
1514static Job *
1515new_job(void)
1516{
int	i;
Job	*newj, *j;

if (free_jobs != NULL((void *)0)) {
newj = free_jobs;
free_jobs = free_jobs->next;
} else
newj = alloc(sizeof(Job), APERM&aperm);

/* brute force method */
for (i = 1; ; i++) {
for (j = job_list; j && j->job != i; j = j->next)
	;
if (j == NULL((void *)0))
	break;
}
newj->job = i;

return newj;
1536}

1538/* Allocate new process struct
*
* Expects sigchld to be blocked.
*/
1542static Proc *
1543new_proc(void)
1544{
Proc	*p;

if (free_procs != NULL((void *)0)) {
p = free_procs;
free_procs = free_procs->next;
} else
p = alloc(sizeof(Proc), APERM&aperm);

return p;
1554}

1556/* Take job out of job_list and put old structures into free list.
* Keeps nzombies, last_job and async_job up to date.
*
* Expects sigchld to be blocked.
*/
1561static void
1562remove_job(Job *j, const char *where)
1563{
Proc	*p, *tmp;
Job	**prev, *curr;

prev = &job_list;
curr = *prev;
for (; curr != NULL((void *)0) && curr != j; prev = &curr->next, curr = *prev)
;
if (curr != j) {
internal_warningf("%s: job not found (%s)", __func__, where);
return;
}
*prev = curr->next;

/* free up proc structures */
for (p = j->proc_list; p != NULL((void *)0); ) {
tmp = p;
p = p->next;
tmp->next = free_procs;
free_procs = tmp;
}

if ((j->flags & JF_ZOMBIE0x100) && j->ppid == procpid)
--nzombie;
j->next = free_jobs;
free_jobs = j;

if (j == last_job)
last_job = NULL((void *)0);
if (j == async_job)
async_job = NULL((void *)0);
1594}

1596/* Put j in a particular location (taking it out of job_list if it is
* there already)
*
* Expects sigchld to be blocked.
*/
1601static void
1602put_job(Job *j, int where)
1603{
Job	**prev, *curr;

/* Remove job from list (if there) */
prev = &job_list;
curr = job_list;
for (; curr && curr != j; prev = &curr->next, curr = *prev)
;
if (curr == j)
*prev = curr->next;

switch (where) {
case PJ_ON_FRONT0:
j->next = job_list;
job_list = j;
break;

case PJ_PAST_STOPPED1:
prev = &job_list;
curr = job_list;
for (; curr && curr->state == PSTOPPED3; prev = &curr->next,
    curr = *prev)
	;
j->next = curr;
*prev = j;
break;
}
1630}

1632/* nuke a job (called when unable to start full job).
*
* Expects sigchld to be blocked.
*/
1636static int
1637kill_job(Job *j, int sig)
1638{
Proc	*p;
int	rval = 0;

for (p = j->proc_list; p != NULL((void *)0); p = p->next)
if (p->pid != 0)
	if (kill(p->pid, sig) == -1)
		rval = -1;
return rval;
1647}