Home | History | Annotate | Download | only in src
      1 /*	$OpenBSD: jobs.c,v 1.43 2015/09/10 22:48:58 nicm Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011,
      5  *		 2012, 2013, 2014, 2015, 2016
      6  *	mirabilos <m (at) mirbsd.org>
      7  *
      8  * Provided that these terms and disclaimer and all copyright notices
      9  * are retained or reproduced in an accompanying document, permission
     10  * is granted to deal in this work without restriction, including un-
     11  * limited rights to use, publicly perform, distribute, sell, modify,
     12  * merge, give away, or sublicence.
     13  *
     14  * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
     15  * the utmost extent permitted by applicable law, neither express nor
     16  * implied; without malicious intent or gross negligence. In no event
     17  * may a licensor, author or contributor be held liable for indirect,
     18  * direct, other damage, loss, or other issues arising in any way out
     19  * of dealing in the work, even if advised of the possibility of such
     20  * damage or existence of a defect, except proven that it results out
     21  * of said person's immediate fault when using the work as intended.
     22  */
     23 
     24 #include "sh.h"
     25 
     26 __RCSID("$MirOS: src/bin/mksh/jobs.c,v 1.117 2016/01/14 23:18:09 tg Exp $");
     27 
     28 #if HAVE_KILLPG
     29 #define mksh_killpg		killpg
     30 #else
     31 /* cross fingers and hope kill is killpg-endowed */
     32 #define mksh_killpg(p,s)	kill(-(p), (s))
     33 #endif
     34 
     35 /* Order important! */
     36 #define PRUNNING	0
     37 #define PEXITED		1
     38 #define PSIGNALLED	2
     39 #define PSTOPPED	3
     40 
     41 typedef struct proc Proc;
     42 struct proc {
     43 	Proc *next;		/* next process in pipeline (if any) */
     44 	pid_t pid;		/* process id */
     45 	int state;
     46 	int status;		/* wait status */
     47 	/* process command string from vistree */
     48 	char command[256 - (ALLOC_SIZE + sizeof(Proc *) + sizeof(pid_t) +
     49 	    2 * sizeof(int))];
     50 };
     51 
     52 /* Notify/print flag - j_print() argument */
     53 #define JP_SHORT	1	/* print signals processes were killed by */
     54 #define JP_MEDIUM	2	/* print [job-num] -/+ command */
     55 #define JP_LONG		3	/* print [job-num] -/+ pid command */
     56 #define JP_PGRP		4	/* print pgrp */
     57 
     58 /* put_job() flags */
     59 #define PJ_ON_FRONT	0	/* at very front */
     60 #define PJ_PAST_STOPPED	1	/* just past any stopped jobs */
     61 
     62 /* Job.flags values */
     63 #define JF_STARTED	0x001	/* set when all processes in job are started */
     64 #define JF_WAITING	0x002	/* set if j_waitj() is waiting on job */
     65 #define JF_W_ASYNCNOTIFY 0x004	/* set if waiting and async notification ok */
     66 #define JF_XXCOM	0x008	/* set for $(command) jobs */
     67 #define JF_FG		0x010	/* running in foreground (also has tty pgrp) */
     68 #define JF_SAVEDTTY	0x020	/* j->ttystat is valid */
     69 #define JF_CHANGED	0x040	/* process has changed state */
     70 #define JF_KNOWN	0x080	/* $! referenced */
     71 #define JF_ZOMBIE	0x100	/* known, unwaited process */
     72 #define JF_REMOVE	0x200	/* flagged for removal (j_jobs()/j_noityf()) */
     73 #define JF_USETTYMODE	0x400	/* tty mode saved if process exits normally */
     74 #define JF_SAVEDTTYPGRP	0x800	/* j->saved_ttypgrp is valid */
     75 
     76 typedef struct job Job;
     77 struct job {
     78 	Job *next;		/* next job in list */
     79 	Proc *proc_list;	/* process list */
     80 	Proc *last_proc;	/* last process in list */
     81 	struct timeval systime;	/* system time used by job */
     82 	struct timeval usrtime;	/* user time used by job */
     83 	pid_t pgrp;		/* process group of job */
     84 	pid_t ppid;		/* pid of process that forked job */
     85 	int job;		/* job number: %n */
     86 	int flags;		/* see JF_* */
     87 	volatile int state;	/* job state */
     88 	int status;		/* exit status of last process */
     89 	int age;		/* number of jobs started */
     90 	Coproc_id coproc_id;	/* 0 or id of coprocess output pipe */
     91 #ifndef MKSH_UNEMPLOYED
     92 	mksh_ttyst ttystat;	/* saved tty state for stopped jobs */
     93 	pid_t saved_ttypgrp;	/* saved tty process group for stopped jobs */
     94 #endif
     95 };
     96 
     97 /* Flags for j_waitj() */
     98 #define JW_NONE		0x00
     99 #define JW_INTERRUPT	0x01	/* ^C will stop the wait */
    100 #define JW_ASYNCNOTIFY	0x02	/* asynchronous notification during wait ok */
    101 #define JW_STOPPEDWAIT	0x04	/* wait even if job stopped */
    102 #define JW_PIPEST	0x08	/* want PIPESTATUS */
    103 
    104 /* Error codes for j_lookup() */
    105 #define JL_NOSUCH	0	/* no such job */
    106 #define JL_AMBIG	1	/* %foo or %?foo is ambiguous */
    107 #define JL_INVALID	2	/* non-pid, non-% job id */
    108 
    109 static const char * const lookup_msgs[] = {
    110 	"no such job",
    111 	"ambiguous",
    112 	"argument must be %job or process id"
    113 };
    114 
    115 static Job *job_list;		/* job list */
    116 static Job *last_job;
    117 static Job *async_job;
    118 static pid_t async_pid;
    119 
    120 static int nzombie;		/* # of zombies owned by this process */
    121 static int njobs;		/* # of jobs started */
    122 
    123 #ifndef CHILD_MAX
    124 #define CHILD_MAX	25
    125 #endif
    126 
    127 #ifndef MKSH_NOPROSPECTOFWORK
    128 /* held_sigchld is set if sigchld occurs before a job is completely started */
    129 static volatile sig_atomic_t held_sigchld;
    130 #endif
    131 
    132 #ifndef MKSH_UNEMPLOYED
    133 static struct shf	*shl_j;
    134 static bool		ttypgrp_ok;	/* set if can use tty pgrps */
    135 static pid_t		restore_ttypgrp = -1;
    136 static int const	tt_sigs[] = { SIGTSTP, SIGTTIN, SIGTTOU };
    137 #endif
    138 
    139 static void		j_set_async(Job *);
    140 static void		j_startjob(Job *);
    141 static int		j_waitj(Job *, int, const char *);
    142 static void		j_sigchld(int);
    143 static void		j_print(Job *, int, struct shf *);
    144 static Job		*j_lookup(const char *, int *);
    145 static Job		*new_job(void);
    146 static Proc		*new_proc(void);
    147 static void		check_job(Job *);
    148 static void		put_job(Job *, int);
    149 static void		remove_job(Job *, const char *);
    150 static int		kill_job(Job *, int);
    151 
    152 static void tty_init_talking(void);
    153 static void tty_init_state(void);
    154 
    155 /* initialise job control */
    156 void
    157 j_init(void)
    158 {
    159 #ifndef MKSH_UNEMPLOYED
    160 	bool mflagset = Flag(FMONITOR) != 127;
    161 
    162 	Flag(FMONITOR) = 0;
    163 #endif
    164 
    165 #ifndef MKSH_NOPROSPECTOFWORK
    166 	(void)sigemptyset(&sm_default);
    167 	sigprocmask(SIG_SETMASK, &sm_default, NULL);
    168 
    169 	(void)sigemptyset(&sm_sigchld);
    170 	(void)sigaddset(&sm_sigchld, SIGCHLD);
    171 
    172 	setsig(&sigtraps[SIGCHLD], j_sigchld,
    173 	    SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
    174 #else
    175 	/* Make sure SIGCHLD isn't ignored - can do odd things under SYSV */
    176 	setsig(&sigtraps[SIGCHLD], SIG_DFL, SS_RESTORE_ORIG|SS_FORCE);
    177 #endif
    178 
    179 #ifndef MKSH_UNEMPLOYED
    180 	if (!mflagset && Flag(FTALKING))
    181 		Flag(FMONITOR) = 1;
    182 
    183 	/*
    184 	 * shl_j is used to do asynchronous notification (used in
    185 	 * an interrupt handler, so need a distinct shf)
    186 	 */
    187 	shl_j = shf_fdopen(2, SHF_WR, NULL);
    188 
    189 	if (Flag(FMONITOR) || Flag(FTALKING)) {
    190 		int i;
    191 
    192 		/*
    193 		 * the TF_SHELL_USES test is a kludge that lets us know if
    194 		 * if the signals have been changed by the shell.
    195 		 */
    196 		for (i = NELEM(tt_sigs); --i >= 0; ) {
    197 			sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES;
    198 			/* j_change() sets this to SS_RESTORE_DFL if FMONITOR */
    199 			setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
    200 			    SS_RESTORE_IGN|SS_FORCE);
    201 		}
    202 	}
    203 
    204 	/* j_change() calls tty_init_talking() and tty_init_state() */
    205 	if (Flag(FMONITOR))
    206 		j_change();
    207 	else
    208 #endif
    209 	  if (Flag(FTALKING)) {
    210 		tty_init_talking();
    211 		tty_init_state();
    212 	}
    213 }
    214 
    215 static int
    216 proc_errorlevel(Proc *p)
    217 {
    218 	switch (p->state) {
    219 	case PEXITED:
    220 		return ((WEXITSTATUS(p->status)) & 255);
    221 	case PSIGNALLED:
    222 		return (ksh_sigmask(WTERMSIG(p->status)));
    223 	default:
    224 		return (0);
    225 	}
    226 }
    227 
    228 #if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID
    229 /* suspend the shell */
    230 void
    231 j_suspend(void)
    232 {
    233 	struct sigaction sa, osa;
    234 
    235 	/* Restore tty and pgrp. */
    236 	if (ttypgrp_ok) {
    237 		if (tty_hasstate)
    238 			mksh_tcset(tty_fd, &tty_state);
    239 		if (restore_ttypgrp >= 0) {
    240 			if (tcsetpgrp(tty_fd, restore_ttypgrp) < 0) {
    241 				warningf(false, "%s: %s %s: %s", "j_suspend",
    242 				    "tcsetpgrp", "failed", cstrerror(errno));
    243 			} else if (setpgid(0, restore_ttypgrp) < 0) {
    244 				warningf(false, "%s: %s %s: %s", "j_suspend",
    245 				    "setpgid", "failed", cstrerror(errno));
    246 			}
    247 		}
    248 	}
    249 
    250 	/* Suspend the shell. */
    251 	memset(&sa, 0, sizeof(sa));
    252 	sigemptyset(&sa.sa_mask);
    253 	sa.sa_handler = SIG_DFL;
    254 	sigaction(SIGTSTP, &sa, &osa);
    255 	kill(0, SIGTSTP);
    256 
    257 	/* Back from suspend, reset signals, pgrp and tty. */
    258 	sigaction(SIGTSTP, &osa, NULL);
    259 	if (ttypgrp_ok) {
    260 		if (restore_ttypgrp >= 0) {
    261 			if (setpgid(0, kshpid) < 0) {
    262 				warningf(false, "%s: %s %s: %s", "j_suspend",
    263 				    "setpgid", "failed", cstrerror(errno));
    264 				ttypgrp_ok = false;
    265 			} else if (tcsetpgrp(tty_fd, kshpid) < 0) {
    266 				warningf(false, "%s: %s %s: %s", "j_suspend",
    267 				    "tcsetpgrp", "failed", cstrerror(errno));
    268 				ttypgrp_ok = false;
    269 			}
    270 		}
    271 		tty_init_state();
    272 	}
    273 }
    274 #endif
    275 
    276 /* job cleanup before shell exit */
    277 void
    278 j_exit(void)
    279 {
    280 	/* kill stopped, and possibly running, jobs */
    281 	Job *j;
    282 	bool killed = false;
    283 
    284 	for (j = job_list; j != NULL; j = j->next) {
    285 		if (j->ppid == procpid &&
    286 		    (j->state == PSTOPPED ||
    287 		    (j->state == PRUNNING &&
    288 		    ((j->flags & JF_FG) ||
    289 		    (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid))))) {
    290 			killed = true;
    291 			if (j->pgrp == 0)
    292 				kill_job(j, SIGHUP);
    293 			else
    294 				mksh_killpg(j->pgrp, SIGHUP);
    295 #ifndef MKSH_UNEMPLOYED
    296 			if (j->state == PSTOPPED) {
    297 				if (j->pgrp == 0)
    298 					kill_job(j, SIGCONT);
    299 				else
    300 					mksh_killpg(j->pgrp, SIGCONT);
    301 			}
    302 #endif
    303 		}
    304 	}
    305 	if (killed)
    306 		sleep(1);
    307 	j_notify();
    308 
    309 #ifndef MKSH_UNEMPLOYED
    310 	if (kshpid == procpid && restore_ttypgrp >= 0) {
    311 		/*
    312 		 * Need to restore the tty pgrp to what it was when the
    313 		 * shell started up, so that the process that started us
    314 		 * will be able to access the tty when we are done.
    315 		 * Also need to restore our process group in case we are
    316 		 * about to do an exec so that both our parent and the
    317 		 * process we are to become will be able to access the tty.
    318 		 */
    319 		tcsetpgrp(tty_fd, restore_ttypgrp);
    320 		setpgid(0, restore_ttypgrp);
    321 	}
    322 	if (Flag(FMONITOR)) {
    323 		Flag(FMONITOR) = 0;
    324 		j_change();
    325 	}
    326 #endif
    327 }
    328 
    329 #ifndef MKSH_UNEMPLOYED
    330 /* turn job control on or off according to Flag(FMONITOR) */
    331 void
    332 j_change(void)
    333 {
    334 	int i;
    335 
    336 	if (Flag(FMONITOR)) {
    337 		bool use_tty = Flag(FTALKING);
    338 
    339 		/* don't call mksh_tcget until we own the tty process group */
    340 		if (use_tty)
    341 			tty_init_talking();
    342 
    343 		/* no controlling tty, no SIGT* */
    344 		if ((ttypgrp_ok = (use_tty && tty_fd >= 0 && tty_devtty))) {
    345 			setsig(&sigtraps[SIGTTIN], SIG_DFL,
    346 			    SS_RESTORE_ORIG|SS_FORCE);
    347 			/* wait to be given tty (POSIX.1, B.2, job control) */
    348 			while (/* CONSTCOND */ 1) {
    349 				pid_t ttypgrp;
    350 
    351 				if ((ttypgrp = tcgetpgrp(tty_fd)) < 0) {
    352 					warningf(false, "%s: %s %s: %s",
    353 					    "j_init", "tcgetpgrp", "failed",
    354 					    cstrerror(errno));
    355 					ttypgrp_ok = false;
    356 					break;
    357 				}
    358 				if (ttypgrp == kshpgrp)
    359 					break;
    360 				kill(0, SIGTTIN);
    361 			}
    362 		}
    363 		for (i = NELEM(tt_sigs); --i >= 0; )
    364 			setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
    365 			    SS_RESTORE_DFL|SS_FORCE);
    366 		if (ttypgrp_ok && kshpgrp != kshpid) {
    367 			if (setpgid(0, kshpid) < 0) {
    368 				warningf(false, "%s: %s %s: %s", "j_init",
    369 				    "setpgid", "failed", cstrerror(errno));
    370 				ttypgrp_ok = false;
    371 			} else {
    372 				if (tcsetpgrp(tty_fd, kshpid) < 0) {
    373 					warningf(false, "%s: %s %s: %s",
    374 					    "j_init", "tcsetpgrp", "failed",
    375 					    cstrerror(errno));
    376 					ttypgrp_ok = false;
    377 				} else
    378 					restore_ttypgrp = kshpgrp;
    379 				kshpgrp = kshpid;
    380 			}
    381 		}
    382 #ifndef MKSH_DISABLE_TTY_WARNING
    383 		if (use_tty && !ttypgrp_ok)
    384 			warningf(false, "%s: %s", "warning",
    385 			    "won't have full job control");
    386 #endif
    387 	} else {
    388 		ttypgrp_ok = false;
    389 		if (Flag(FTALKING))
    390 			for (i = NELEM(tt_sigs); --i >= 0; )
    391 				setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
    392 				    SS_RESTORE_IGN|SS_FORCE);
    393 		else
    394 			for (i = NELEM(tt_sigs); --i >= 0; ) {
    395 				if (sigtraps[tt_sigs[i]].flags &
    396 				    (TF_ORIG_IGN | TF_ORIG_DFL))
    397 					setsig(&sigtraps[tt_sigs[i]],
    398 					    (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN) ?
    399 					    SIG_IGN : SIG_DFL,
    400 					    SS_RESTORE_ORIG|SS_FORCE);
    401 			}
    402 	}
    403 	tty_init_state();
    404 }
    405 #endif
    406 
    407 #if HAVE_NICE
    408 /* run nice(3) and ignore the result */
    409 static void
    410 ksh_nice(int ness)
    411 {
    412 #if defined(__USE_FORTIFY_LEVEL) && (__USE_FORTIFY_LEVEL > 0)
    413 	int eno;
    414 
    415 	errno = 0;
    416 	/* this is gonna annoy users; complain to your distro, people! */
    417 	if (nice(ness) == -1 && (eno = errno) != 0)
    418 		warningf(false, "%s: %s", "bgnice", cstrerror(eno));
    419 #else
    420 	(void)nice(ness);
    421 #endif
    422 }
    423 #endif
    424 
    425 /* execute tree in child subprocess */
    426 int
    427 exchild(struct op *t, int flags,
    428     volatile int *xerrok,
    429     /* used if XPCLOSE or XCCLOSE */
    430     int close_fd)
    431 {
    432 	/* for pipelines */
    433 	static Proc *last_proc;
    434 
    435 	int rv = 0, forksleep, jwflags = JW_NONE;
    436 #ifndef MKSH_NOPROSPECTOFWORK
    437 	sigset_t omask;
    438 #endif
    439 	Proc *p;
    440 	Job *j;
    441 	pid_t cldpid;
    442 
    443 	if (flags & XPIPEST) {
    444 		flags &= ~XPIPEST;
    445 		jwflags |= JW_PIPEST;
    446 	}
    447 
    448 	if (flags & XEXEC)
    449 		/*
    450 		 * Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND
    451 		 * (also done in another execute() below)
    452 		 */
    453 		return (execute(t, flags & (XEXEC | XERROK), xerrok));
    454 
    455 #ifndef MKSH_NOPROSPECTOFWORK
    456 	/* no SIGCHLDs while messing with job and process lists */
    457 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    458 #endif
    459 
    460 	p = new_proc();
    461 	p->next = NULL;
    462 	p->state = PRUNNING;
    463 	p->status = 0;
    464 	p->pid = 0;
    465 
    466 	/* link process into jobs list */
    467 	if (flags & XPIPEI) {
    468 		/* continuing with a pipe */
    469 		if (!last_job)
    470 			internal_errorf("%s %d",
    471 			    "exchild: XPIPEI and no last_job - pid",
    472 			    (int)procpid);
    473 		j = last_job;
    474 		if (last_proc)
    475 			last_proc->next = p;
    476 		last_proc = p;
    477 	} else {
    478 		/* fills in j->job */
    479 		j = new_job();
    480 		/*
    481 		 * we don't consider XXCOMs foreground since they don't get
    482 		 * tty process group and we don't save or restore tty modes.
    483 		 */
    484 		j->flags = (flags & XXCOM) ? JF_XXCOM :
    485 		    ((flags & XBGND) ? 0 : (JF_FG|JF_USETTYMODE));
    486 		timerclear(&j->usrtime);
    487 		timerclear(&j->systime);
    488 		j->state = PRUNNING;
    489 		j->pgrp = 0;
    490 		j->ppid = procpid;
    491 		j->age = ++njobs;
    492 		j->proc_list = p;
    493 		j->coproc_id = 0;
    494 		last_job = j;
    495 		last_proc = p;
    496 		put_job(j, PJ_PAST_STOPPED);
    497 	}
    498 
    499 	vistree(p->command, sizeof(p->command), t);
    500 
    501 	/* create child process */
    502 	forksleep = 1;
    503 	while ((cldpid = fork()) < 0 && errno == EAGAIN && forksleep < 32) {
    504 		if (intrsig)
    505 			/* allow user to ^C out... */
    506 			break;
    507 		sleep(forksleep);
    508 		forksleep <<= 1;
    509 	}
    510 	/* ensure $RANDOM changes between parent and child */
    511 	rndset((unsigned long)cldpid);
    512 	/* fork failed? */
    513 	if (cldpid < 0) {
    514 		kill_job(j, SIGKILL);
    515 		remove_job(j, "fork failed");
    516 #ifndef MKSH_NOPROSPECTOFWORK
    517 		sigprocmask(SIG_SETMASK, &omask, NULL);
    518 #endif
    519 		errorf("can't fork - try again");
    520 	}
    521 	p->pid = cldpid ? cldpid : (procpid = getpid());
    522 
    523 #ifndef MKSH_UNEMPLOYED
    524 	/* job control set up */
    525 	if (Flag(FMONITOR) && !(flags&XXCOM)) {
    526 		bool dotty = false;
    527 
    528 		if (j->pgrp == 0) {
    529 			/* First process */
    530 			j->pgrp = p->pid;
    531 			dotty = true;
    532 		}
    533 
    534 		/*
    535 		 * set pgrp in both parent and child to deal with race
    536 		 * condition
    537 		 */
    538 		setpgid(p->pid, j->pgrp);
    539 		if (ttypgrp_ok && dotty && !(flags & XBGND))
    540 			tcsetpgrp(tty_fd, j->pgrp);
    541 	}
    542 #endif
    543 
    544 	/* used to close pipe input fd */
    545 	if (close_fd >= 0 && (((flags & XPCLOSE) && cldpid) ||
    546 	    ((flags & XCCLOSE) && !cldpid)))
    547 		close(close_fd);
    548 	if (!cldpid) {
    549 		/* child */
    550 
    551 		/* Do this before restoring signal */
    552 		if (flags & XCOPROC)
    553 			coproc_cleanup(false);
    554 		cleanup_parents_env();
    555 #ifndef MKSH_UNEMPLOYED
    556 		/*
    557 		 * If FMONITOR or FTALKING is set, these signals are ignored,
    558 		 * if neither FMONITOR nor FTALKING are set, the signals have
    559 		 * their inherited values.
    560 		 */
    561 		if (Flag(FMONITOR) && !(flags & XXCOM)) {
    562 			for (forksleep = NELEM(tt_sigs); --forksleep >= 0; )
    563 				setsig(&sigtraps[tt_sigs[forksleep]], SIG_DFL,
    564 				    SS_RESTORE_DFL|SS_FORCE);
    565 		}
    566 #endif
    567 #if HAVE_NICE
    568 		if (Flag(FBGNICE) && (flags & XBGND))
    569 			ksh_nice(4);
    570 #endif
    571 		if ((flags & XBGND)
    572 #ifndef MKSH_UNEMPLOYED
    573 		    && !Flag(FMONITOR)
    574 #endif
    575 		    ) {
    576 			setsig(&sigtraps[SIGINT], SIG_IGN,
    577 			    SS_RESTORE_IGN|SS_FORCE);
    578 			setsig(&sigtraps[SIGQUIT], SIG_IGN,
    579 			    SS_RESTORE_IGN|SS_FORCE);
    580 			if ((!(flags & (XPIPEI | XCOPROC))) &&
    581 			    ((forksleep = open("/dev/null", 0)) > 0)) {
    582 				(void)ksh_dup2(forksleep, 0, true);
    583 				close(forksleep);
    584 			}
    585 		}
    586 		/* in case of $(jobs) command */
    587 		remove_job(j, "child");
    588 #ifndef MKSH_NOPROSPECTOFWORK
    589 		/* remove_job needs SIGCHLD blocked still */
    590 		sigprocmask(SIG_SETMASK, &omask, NULL);
    591 #endif
    592 		nzombie = 0;
    593 #ifndef MKSH_UNEMPLOYED
    594 		ttypgrp_ok = false;
    595 		Flag(FMONITOR) = 0;
    596 #endif
    597 		Flag(FTALKING) = 0;
    598 		cleartraps();
    599 		/* no return */
    600 		execute(t, (flags & XERROK) | XEXEC, NULL);
    601 #ifndef MKSH_SMALL
    602 		if (t->type == TPIPE)
    603 			unwind(LLEAVE);
    604 		internal_warningf("%s: %s", "exchild", "execute() returned");
    605 		fptreef(shl_out, 8, "%s: tried to execute {\n\t%T\n}\n",
    606 		    "exchild", t);
    607 		shf_flush(shl_out);
    608 #endif
    609 		unwind(LLEAVE);
    610 		/* NOTREACHED */
    611 	}
    612 
    613 	/* shell (parent) stuff */
    614 	if (!(flags & XPIPEO)) {
    615 		/* last process in a job */
    616 		j_startjob(j);
    617 		if (flags & XCOPROC) {
    618 			j->coproc_id = coproc.id;
    619 			/* n jobs using co-process output */
    620 			coproc.njobs++;
    621 			/* j using co-process input */
    622 			coproc.job = (void *)j;
    623 		}
    624 		if (flags & XBGND) {
    625 			j_set_async(j);
    626 			if (Flag(FTALKING)) {
    627 				shf_fprintf(shl_out, "[%d]", j->job);
    628 				for (p = j->proc_list; p; p = p->next)
    629 					shf_fprintf(shl_out, " %d",
    630 					    (int)p->pid);
    631 				shf_putchar('\n', shl_out);
    632 				shf_flush(shl_out);
    633 			}
    634 		} else
    635 			rv = j_waitj(j, jwflags, "jw:last proc");
    636 	}
    637 
    638 #ifndef MKSH_NOPROSPECTOFWORK
    639 	sigprocmask(SIG_SETMASK, &omask, NULL);
    640 #endif
    641 
    642 	return (rv);
    643 }
    644 
    645 /* start the last job: only used for $(command) jobs */
    646 void
    647 startlast(void)
    648 {
    649 #ifndef MKSH_NOPROSPECTOFWORK
    650 	sigset_t omask;
    651 
    652 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    653 #endif
    654 
    655 	/* no need to report error - waitlast() will do it */
    656 	if (last_job) {
    657 		/* ensure it isn't removed by check_job() */
    658 		last_job->flags |= JF_WAITING;
    659 		j_startjob(last_job);
    660 	}
    661 #ifndef MKSH_NOPROSPECTOFWORK
    662 	sigprocmask(SIG_SETMASK, &omask, NULL);
    663 #endif
    664 }
    665 
    666 /* wait for last job: only used for $(command) jobs */
    667 int
    668 waitlast(void)
    669 {
    670 	int rv;
    671 	Job *j;
    672 #ifndef MKSH_NOPROSPECTOFWORK
    673 	sigset_t omask;
    674 
    675 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    676 #endif
    677 
    678 	j = last_job;
    679 	if (!j || !(j->flags & JF_STARTED)) {
    680 		if (!j)
    681 			warningf(true, "%s: %s", "waitlast", "no last job");
    682 		else
    683 			internal_warningf("%s: %s", "waitlast", "not started");
    684 #ifndef MKSH_NOPROSPECTOFWORK
    685 		sigprocmask(SIG_SETMASK, &omask, NULL);
    686 #endif
    687 		/* not so arbitrary, non-zero value */
    688 		return (125);
    689 	}
    690 
    691 	rv = j_waitj(j, JW_NONE, "waitlast");
    692 
    693 #ifndef MKSH_NOPROSPECTOFWORK
    694 	sigprocmask(SIG_SETMASK, &omask, NULL);
    695 #endif
    696 
    697 	return (rv);
    698 }
    699 
    700 /* wait for child, interruptable. */
    701 int
    702 waitfor(const char *cp, int *sigp)
    703 {
    704 	int rv, ecode, flags = JW_INTERRUPT|JW_ASYNCNOTIFY;
    705 	Job *j;
    706 #ifndef MKSH_NOPROSPECTOFWORK
    707 	sigset_t omask;
    708 
    709 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    710 #endif
    711 
    712 	*sigp = 0;
    713 
    714 	if (cp == NULL) {
    715 		/*
    716 		 * wait for an unspecified job - always returns 0, so
    717 		 * don't have to worry about exited/signaled jobs
    718 		 */
    719 		for (j = job_list; j; j = j->next)
    720 			/* AT&T ksh will wait for stopped jobs - we don't */
    721 			if (j->ppid == procpid && j->state == PRUNNING)
    722 				break;
    723 		if (!j) {
    724 #ifndef MKSH_NOPROSPECTOFWORK
    725 			sigprocmask(SIG_SETMASK, &omask, NULL);
    726 #endif
    727 			return (-1);
    728 		}
    729 	} else if ((j = j_lookup(cp, &ecode))) {
    730 		/* don't report normal job completion */
    731 		flags &= ~JW_ASYNCNOTIFY;
    732 		if (j->ppid != procpid) {
    733 #ifndef MKSH_NOPROSPECTOFWORK
    734 			sigprocmask(SIG_SETMASK, &omask, NULL);
    735 #endif
    736 			return (-1);
    737 		}
    738 	} else {
    739 #ifndef MKSH_NOPROSPECTOFWORK
    740 		sigprocmask(SIG_SETMASK, &omask, NULL);
    741 #endif
    742 		if (ecode != JL_NOSUCH)
    743 			bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
    744 		return (-1);
    745 	}
    746 
    747 	/* AT&T ksh will wait for stopped jobs - we don't */
    748 	rv = j_waitj(j, flags, "jw:waitfor");
    749 
    750 #ifndef MKSH_NOPROSPECTOFWORK
    751 	sigprocmask(SIG_SETMASK, &omask, NULL);
    752 #endif
    753 
    754 	if (rv < 0)
    755 		/* we were interrupted */
    756 		*sigp = ksh_sigmask(-rv);
    757 
    758 	return (rv);
    759 }
    760 
    761 /* kill (built-in) a job */
    762 int
    763 j_kill(const char *cp, int sig)
    764 {
    765 	Job *j;
    766 	int rv = 0, ecode;
    767 #ifndef MKSH_NOPROSPECTOFWORK
    768 	sigset_t omask;
    769 
    770 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    771 #endif
    772 
    773 	if ((j = j_lookup(cp, &ecode)) == NULL) {
    774 #ifndef MKSH_NOPROSPECTOFWORK
    775 		sigprocmask(SIG_SETMASK, &omask, NULL);
    776 #endif
    777 		bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
    778 		return (1);
    779 	}
    780 
    781 	if (j->pgrp == 0) {
    782 		/* started when !Flag(FMONITOR) */
    783 		if (kill_job(j, sig) < 0) {
    784 			bi_errorf("%s: %s", cp, cstrerror(errno));
    785 			rv = 1;
    786 		}
    787 	} else {
    788 #ifndef MKSH_UNEMPLOYED
    789 		if (j->state == PSTOPPED && (sig == SIGTERM || sig == SIGHUP))
    790 			mksh_killpg(j->pgrp, SIGCONT);
    791 #endif
    792 		if (mksh_killpg(j->pgrp, sig) < 0) {
    793 			bi_errorf("%s: %s", cp, cstrerror(errno));
    794 			rv = 1;
    795 		}
    796 	}
    797 
    798 #ifndef MKSH_NOPROSPECTOFWORK
    799 	sigprocmask(SIG_SETMASK, &omask, NULL);
    800 #endif
    801 
    802 	return (rv);
    803 }
    804 
    805 #ifndef MKSH_UNEMPLOYED
    806 /* fg and bg built-ins: called only if Flag(FMONITOR) set */
    807 int
    808 j_resume(const char *cp, int bg)
    809 {
    810 	Job *j;
    811 	Proc *p;
    812 	int ecode, rv = 0;
    813 	bool running;
    814 	sigset_t omask;
    815 
    816 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    817 
    818 	if ((j = j_lookup(cp, &ecode)) == NULL) {
    819 		sigprocmask(SIG_SETMASK, &omask, NULL);
    820 		bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
    821 		return (1);
    822 	}
    823 
    824 	if (j->pgrp == 0) {
    825 		sigprocmask(SIG_SETMASK, &omask, NULL);
    826 		bi_errorf("job not job-controlled");
    827 		return (1);
    828 	}
    829 
    830 	if (bg)
    831 		shprintf("[%d] ", j->job);
    832 
    833 	running = false;
    834 	for (p = j->proc_list; p != NULL; p = p->next) {
    835 		if (p->state == PSTOPPED) {
    836 			p->state = PRUNNING;
    837 			p->status = 0;
    838 			running = true;
    839 		}
    840 		shf_puts(p->command, shl_stdout);
    841 		if (p->next)
    842 			shf_puts("| ", shl_stdout);
    843 	}
    844 	shf_putc('\n', shl_stdout);
    845 	shf_flush(shl_stdout);
    846 	if (running)
    847 		j->state = PRUNNING;
    848 
    849 	put_job(j, PJ_PAST_STOPPED);
    850 	if (bg)
    851 		j_set_async(j);
    852 	else {
    853 		/* attach tty to job */
    854 		if (j->state == PRUNNING) {
    855 			if (ttypgrp_ok && (j->flags & JF_SAVEDTTY))
    856 				mksh_tcset(tty_fd, &j->ttystat);
    857 			/* See comment in j_waitj regarding saved_ttypgrp. */
    858 			if (ttypgrp_ok &&
    859 			    tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP) ?
    860 			    j->saved_ttypgrp : j->pgrp) < 0) {
    861 				rv = errno;
    862 				if (j->flags & JF_SAVEDTTY)
    863 					mksh_tcset(tty_fd, &tty_state);
    864 				sigprocmask(SIG_SETMASK, &omask, NULL);
    865 				bi_errorf("%s %s(%d, %ld) %s: %s",
    866 				    "1st", "tcsetpgrp", tty_fd,
    867 				    (long)((j->flags & JF_SAVEDTTYPGRP) ?
    868 				    j->saved_ttypgrp : j->pgrp), "failed",
    869 				    cstrerror(rv));
    870 				return (1);
    871 			}
    872 		}
    873 		j->flags |= JF_FG;
    874 		j->flags &= ~JF_KNOWN;
    875 		if (j == async_job)
    876 			async_job = NULL;
    877 	}
    878 
    879 	if (j->state == PRUNNING && mksh_killpg(j->pgrp, SIGCONT) < 0) {
    880 		int eno = errno;
    881 
    882 		if (!bg) {
    883 			j->flags &= ~JF_FG;
    884 			if (ttypgrp_ok && (j->flags & JF_SAVEDTTY))
    885 				mksh_tcset(tty_fd, &tty_state);
    886 			if (ttypgrp_ok && tcsetpgrp(tty_fd, kshpgrp) < 0)
    887 				warningf(true, "%s %s(%d, %ld) %s: %s",
    888 				    "fg: 2nd", "tcsetpgrp", tty_fd,
    889 				    (long)kshpgrp, "failed", cstrerror(errno));
    890 		}
    891 		sigprocmask(SIG_SETMASK, &omask, NULL);
    892 		bi_errorf("%s %s: %s", "can't continue job",
    893 		    cp, cstrerror(eno));
    894 		return (1);
    895 	}
    896 	if (!bg) {
    897 		if (ttypgrp_ok) {
    898 			j->flags &= ~(JF_SAVEDTTY | JF_SAVEDTTYPGRP);
    899 		}
    900 		rv = j_waitj(j, JW_NONE, "jw:resume");
    901 	}
    902 	sigprocmask(SIG_SETMASK, &omask, NULL);
    903 	return (rv);
    904 }
    905 #endif
    906 
    907 /* are there any running or stopped jobs ? */
    908 int
    909 j_stopped_running(void)
    910 {
    911 	Job *j;
    912 	int which = 0;
    913 
    914 	for (j = job_list; j != NULL; j = j->next) {
    915 #ifndef MKSH_UNEMPLOYED
    916 		if (j->ppid == procpid && j->state == PSTOPPED)
    917 			which |= 1;
    918 #endif
    919 		if (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid &&
    920 		    j->ppid == procpid && j->state == PRUNNING)
    921 			which |= 2;
    922 	}
    923 	if (which) {
    924 		shellf("You have %s%s%s jobs\n",
    925 		    which & 1 ? "stopped" : "",
    926 		    which == 3 ? " and " : "",
    927 		    which & 2 ? "running" : "");
    928 		return (1);
    929 	}
    930 
    931 	return (0);
    932 }
    933 
    934 
    935 /* list jobs for jobs built-in */
    936 int
    937 j_jobs(const char *cp, int slp,
    938     /* 0: short, 1: long, 2: pgrp */
    939     int nflag)
    940 {
    941 	Job *j, *tmp;
    942 	int how, zflag = 0;
    943 #ifndef MKSH_NOPROSPECTOFWORK
    944 	sigset_t omask;
    945 
    946 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    947 #endif
    948 
    949 	if (nflag < 0) {
    950 		/* kludge: print zombies */
    951 		nflag = 0;
    952 		zflag = 1;
    953 	}
    954 	if (cp) {
    955 		int ecode;
    956 
    957 		if ((j = j_lookup(cp, &ecode)) == NULL) {
    958 #ifndef MKSH_NOPROSPECTOFWORK
    959 			sigprocmask(SIG_SETMASK, &omask, NULL);
    960 #endif
    961 			bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
    962 			return (1);
    963 		}
    964 	} else
    965 		j = job_list;
    966 	how = slp == 0 ? JP_MEDIUM : (slp == 1 ? JP_LONG : JP_PGRP);
    967 	for (; j; j = j->next) {
    968 		if ((!(j->flags & JF_ZOMBIE) || zflag) &&
    969 		    (!nflag || (j->flags & JF_CHANGED))) {
    970 			j_print(j, how, shl_stdout);
    971 			if (j->state == PEXITED || j->state == PSIGNALLED)
    972 				j->flags |= JF_REMOVE;
    973 		}
    974 		if (cp)
    975 			break;
    976 	}
    977 	/* Remove jobs after printing so there won't be multiple + or - jobs */
    978 	for (j = job_list; j; j = tmp) {
    979 		tmp = j->next;
    980 		if (j->flags & JF_REMOVE)
    981 			remove_job(j, "jobs");
    982 	}
    983 #ifndef MKSH_NOPROSPECTOFWORK
    984 	sigprocmask(SIG_SETMASK, &omask, NULL);
    985 #endif
    986 	return (0);
    987 }
    988 
    989 /* list jobs for top-level notification */
    990 void
    991 j_notify(void)
    992 {
    993 	Job *j, *tmp;
    994 #ifndef MKSH_NOPROSPECTOFWORK
    995 	sigset_t omask;
    996 
    997 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
    998 #endif
    999 	for (j = job_list; j; j = j->next) {
   1000 #ifndef MKSH_UNEMPLOYED
   1001 		if (Flag(FMONITOR) && (j->flags & JF_CHANGED))
   1002 			j_print(j, JP_MEDIUM, shl_out);
   1003 #endif
   1004 		/*
   1005 		 * Remove job after doing reports so there aren't
   1006 		 * multiple +/- jobs.
   1007 		 */
   1008 		if (j->state == PEXITED || j->state == PSIGNALLED)
   1009 			j->flags |= JF_REMOVE;
   1010 	}
   1011 	for (j = job_list; j; j = tmp) {
   1012 		tmp = j->next;
   1013 		if (j->flags & JF_REMOVE)
   1014 			remove_job(j, "notify");
   1015 	}
   1016 	shf_flush(shl_out);
   1017 #ifndef MKSH_NOPROSPECTOFWORK
   1018 	sigprocmask(SIG_SETMASK, &omask, NULL);
   1019 #endif
   1020 }
   1021 
   1022 /* Return pid of last process in last asynchronous job */
   1023 pid_t
   1024 j_async(void)
   1025 {
   1026 #ifndef MKSH_NOPROSPECTOFWORK
   1027 	sigset_t omask;
   1028 
   1029 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
   1030 #endif
   1031 
   1032 	if (async_job)
   1033 		async_job->flags |= JF_KNOWN;
   1034 
   1035 #ifndef MKSH_NOPROSPECTOFWORK
   1036 	sigprocmask(SIG_SETMASK, &omask, NULL);
   1037 #endif
   1038 
   1039 	return (async_pid);
   1040 }
   1041 
   1042 /*
   1043  * Make j the last async process
   1044  *
   1045  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1046  */
   1047 static void
   1048 j_set_async(Job *j)
   1049 {
   1050 	Job *jl, *oldest;
   1051 
   1052 	if (async_job && (async_job->flags & (JF_KNOWN|JF_ZOMBIE)) == JF_ZOMBIE)
   1053 		remove_job(async_job, "async");
   1054 	if (!(j->flags & JF_STARTED)) {
   1055 		internal_warningf("%s: %s", "j_async", "job not started");
   1056 		return;
   1057 	}
   1058 	async_job = j;
   1059 	async_pid = j->last_proc->pid;
   1060 	while (nzombie > CHILD_MAX) {
   1061 		oldest = NULL;
   1062 		for (jl = job_list; jl; jl = jl->next)
   1063 			if (jl != async_job && (jl->flags & JF_ZOMBIE) &&
   1064 			    (!oldest || jl->age < oldest->age))
   1065 				oldest = jl;
   1066 		if (!oldest) {
   1067 			/* XXX debugging */
   1068 			if (!(async_job->flags & JF_ZOMBIE) || nzombie != 1) {
   1069 				internal_warningf("%s: bad nzombie (%d)",
   1070 				    "j_async", nzombie);
   1071 				nzombie = 0;
   1072 			}
   1073 			break;
   1074 		}
   1075 		remove_job(oldest, "zombie");
   1076 	}
   1077 }
   1078 
   1079 /*
   1080  * Start a job: set STARTED, check for held signals and set j->last_proc
   1081  *
   1082  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1083  */
   1084 static void
   1085 j_startjob(Job *j)
   1086 {
   1087 	Proc *p;
   1088 
   1089 	j->flags |= JF_STARTED;
   1090 	for (p = j->proc_list; p->next; p = p->next)
   1091 		;
   1092 	j->last_proc = p;
   1093 
   1094 #ifndef MKSH_NOPROSPECTOFWORK
   1095 	if (held_sigchld) {
   1096 		held_sigchld = 0;
   1097 		/* Don't call j_sigchld() as it may remove job... */
   1098 		kill(procpid, SIGCHLD);
   1099 	}
   1100 #endif
   1101 }
   1102 
   1103 /*
   1104  * wait for job to complete or change state
   1105  *
   1106  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1107  */
   1108 static int
   1109 j_waitj(Job *j,
   1110     /* see JW_* */
   1111     int flags,
   1112     const char *where)
   1113 {
   1114 	Proc *p;
   1115 	int rv;
   1116 #ifdef MKSH_NO_SIGSUSPEND
   1117 	sigset_t omask;
   1118 #endif
   1119 
   1120 	/*
   1121 	 * No auto-notify on the job we are waiting on.
   1122 	 */
   1123 	j->flags |= JF_WAITING;
   1124 	if (flags & JW_ASYNCNOTIFY)
   1125 		j->flags |= JF_W_ASYNCNOTIFY;
   1126 
   1127 #ifndef MKSH_UNEMPLOYED
   1128 	if (!Flag(FMONITOR))
   1129 #endif
   1130 		flags |= JW_STOPPEDWAIT;
   1131 
   1132 	while (j->state == PRUNNING ||
   1133 	    ((flags & JW_STOPPEDWAIT) && j->state == PSTOPPED)) {
   1134 #ifndef MKSH_NOPROSPECTOFWORK
   1135 #ifdef MKSH_NO_SIGSUSPEND
   1136 		sigprocmask(SIG_SETMASK, &sm_default, &omask);
   1137 		pause();
   1138 		/* note that handlers may run here so they need to know */
   1139 		sigprocmask(SIG_SETMASK, &omask, NULL);
   1140 #else
   1141 		sigsuspend(&sm_default);
   1142 #endif
   1143 #else
   1144 		j_sigchld(SIGCHLD);
   1145 #endif
   1146 		if (fatal_trap) {
   1147 			int oldf = j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY);
   1148 			j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
   1149 			runtraps(TF_FATAL);
   1150 			/* not reached... */
   1151 			j->flags |= oldf;
   1152 		}
   1153 		if ((flags & JW_INTERRUPT) && (rv = trap_pending())) {
   1154 			j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
   1155 			return (-rv);
   1156 		}
   1157 	}
   1158 	j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
   1159 
   1160 	if (j->flags & JF_FG) {
   1161 		j->flags &= ~JF_FG;
   1162 #ifndef MKSH_UNEMPLOYED
   1163 		if (Flag(FMONITOR) && ttypgrp_ok && j->pgrp) {
   1164 			/*
   1165 			 * Save the tty's current pgrp so it can be restored
   1166 			 * when the job is foregrounded. This is to
   1167 			 * deal with things like the GNU su which does
   1168 			 * a fork/exec instead of an exec (the fork means
   1169 			 * the execed shell gets a different pid from its
   1170 			 * pgrp, so naturally it sets its pgrp and gets hosed
   1171 			 * when it gets foregrounded by the parent shell which
   1172 			 * has restored the tty's pgrp to that of the su
   1173 			 * process).
   1174 			 */
   1175 			if (j->state == PSTOPPED &&
   1176 			    (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0)
   1177 				j->flags |= JF_SAVEDTTYPGRP;
   1178 			if (tcsetpgrp(tty_fd, kshpgrp) < 0)
   1179 				warningf(true, "%s %s(%d, %ld) %s: %s",
   1180 				    "j_waitj:", "tcsetpgrp", tty_fd,
   1181 				    (long)kshpgrp, "failed", cstrerror(errno));
   1182 			if (j->state == PSTOPPED) {
   1183 				j->flags |= JF_SAVEDTTY;
   1184 				mksh_tcget(tty_fd, &j->ttystat);
   1185 			}
   1186 		}
   1187 #endif
   1188 		if (tty_hasstate) {
   1189 			/*
   1190 			 * Only restore tty settings if job was originally
   1191 			 * started in the foreground. Problems can be
   1192 			 * caused by things like 'more foobar &' which will
   1193 			 * typically get and save the shell's vi/emacs tty
   1194 			 * settings before setting up the tty for itself;
   1195 			 * when more exits, it restores the 'original'
   1196 			 * settings, and things go down hill from there...
   1197 			 */
   1198 			if (j->state == PEXITED && j->status == 0 &&
   1199 			    (j->flags & JF_USETTYMODE)) {
   1200 				mksh_tcget(tty_fd, &tty_state);
   1201 			} else {
   1202 				mksh_tcset(tty_fd, &tty_state);
   1203 				/*-
   1204 				 * Don't use tty mode if job is stopped and
   1205 				 * later restarted and exits. Consider
   1206 				 * the sequence:
   1207 				 *	vi foo (stopped)
   1208 				 *	...
   1209 				 *	stty something
   1210 				 *	...
   1211 				 *	fg (vi; ZZ)
   1212 				 * mode should be that of the stty, not what
   1213 				 * was before the vi started.
   1214 				 */
   1215 				if (j->state == PSTOPPED)
   1216 					j->flags &= ~JF_USETTYMODE;
   1217 			}
   1218 		}
   1219 #ifndef MKSH_UNEMPLOYED
   1220 		/*
   1221 		 * If it looks like user hit ^C to kill a job, pretend we got
   1222 		 * one too to break out of for loops, etc. (AT&T ksh does this
   1223 		 * even when not monitoring, but this doesn't make sense since
   1224 		 * a tty generated ^C goes to the whole process group)
   1225 		 */
   1226 		if (Flag(FMONITOR) && j->state == PSIGNALLED &&
   1227 		    WIFSIGNALED(j->last_proc->status)) {
   1228 			int termsig;
   1229 
   1230 			if ((termsig = WTERMSIG(j->last_proc->status)) > 0 &&
   1231 			    termsig < ksh_NSIG &&
   1232 			    (sigtraps[termsig].flags & TF_TTY_INTR))
   1233 				trapsig(termsig);
   1234 		}
   1235 #endif
   1236 	}
   1237 
   1238 	j_usrtime = j->usrtime;
   1239 	j_systime = j->systime;
   1240 	rv = j->status;
   1241 
   1242 	if (!(p = j->proc_list)) {
   1243 		;	/* nothing */
   1244 	} else if (flags & JW_PIPEST) {
   1245 		uint32_t num = 0;
   1246 		struct tbl *vp;
   1247 
   1248 		unset(vp_pipest, 1);
   1249 		vp = vp_pipest;
   1250 		vp->flag = DEFINED | ISSET | INTEGER | RDONLY | ARRAY | INT_U;
   1251 		goto got_array;
   1252 
   1253 		while (p != NULL) {
   1254 			{
   1255 				struct tbl *vq;
   1256 
   1257 				/* strlen(vp_pipest->name) == 10 */
   1258 				vq = alloc(offsetof(struct tbl, name[0]) + 11,
   1259 				    vp_pipest->areap);
   1260 				memset(vq, 0, offsetof(struct tbl, name[0]));
   1261 				memcpy(vq->name, vp_pipest->name, 11);
   1262 				vp->u.array = vq;
   1263 				vp = vq;
   1264 			}
   1265 			vp->areap = vp_pipest->areap;
   1266 			vp->ua.index = ++num;
   1267 			vp->flag = DEFINED | ISSET | INTEGER | RDONLY |
   1268 			    ARRAY | INT_U | AINDEX;
   1269  got_array:
   1270 			vp->val.i = proc_errorlevel(p);
   1271 			if (Flag(FPIPEFAIL) && vp->val.i)
   1272 				rv = vp->val.i;
   1273 			p = p->next;
   1274 		}
   1275 	} else if (Flag(FPIPEFAIL)) {
   1276 		do {
   1277 			const int i = proc_errorlevel(p);
   1278 
   1279 			if (i)
   1280 				rv = i;
   1281 		} while ((p = p->next));
   1282 	}
   1283 
   1284 	if (!(flags & JW_ASYNCNOTIFY)
   1285 #ifndef MKSH_UNEMPLOYED
   1286 	    && (!Flag(FMONITOR) || j->state != PSTOPPED)
   1287 #endif
   1288 	    ) {
   1289 		j_print(j, JP_SHORT, shl_out);
   1290 		shf_flush(shl_out);
   1291 	}
   1292 	if (j->state != PSTOPPED
   1293 #ifndef MKSH_UNEMPLOYED
   1294 	    && (!Flag(FMONITOR) || !(flags & JW_ASYNCNOTIFY))
   1295 #endif
   1296 	    )
   1297 		remove_job(j, where);
   1298 
   1299 	return (rv);
   1300 }
   1301 
   1302 /*
   1303  * SIGCHLD handler to reap children and update job states
   1304  *
   1305  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1306  */
   1307 /* ARGSUSED */
   1308 static void
   1309 j_sigchld(int sig MKSH_A_UNUSED)
   1310 {
   1311 	int saved_errno = errno;
   1312 	Job *j;
   1313 	Proc *p = NULL;
   1314 	pid_t pid;
   1315 	int status;
   1316 	struct rusage ru0, ru1;
   1317 #ifdef MKSH_NO_SIGSUSPEND
   1318 	sigset_t omask;
   1319 
   1320 	/* this handler can run while SIGCHLD is not blocked, so block it now */
   1321 	sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
   1322 #endif
   1323 
   1324 #ifndef MKSH_NOPROSPECTOFWORK
   1325 	/*
   1326 	 * Don't wait for any processes if a job is partially started.
   1327 	 * This is so we don't do away with the process group leader
   1328 	 * before all the processes in a pipe line are started (so the
   1329 	 * setpgid() won't fail)
   1330 	 */
   1331 	for (j = job_list; j; j = j->next)
   1332 		if (j->ppid == procpid && !(j->flags & JF_STARTED)) {
   1333 			held_sigchld = 1;
   1334 			goto j_sigchld_out;
   1335 		}
   1336 #endif
   1337 
   1338 	getrusage(RUSAGE_CHILDREN, &ru0);
   1339 	do {
   1340 #ifndef MKSH_NOPROSPECTOFWORK
   1341 		pid = waitpid(-1, &status, (WNOHANG |
   1342 #if defined(WCONTINUED) && defined(WIFCONTINUED)
   1343 		    WCONTINUED |
   1344 #endif
   1345 		    WUNTRACED));
   1346 #else
   1347 		pid = wait(&status);
   1348 #endif
   1349 
   1350 		/*
   1351 		 * return if this would block (0) or no children
   1352 		 * or interrupted (-1)
   1353 		 */
   1354 		if (pid <= 0)
   1355 			goto j_sigchld_out;
   1356 
   1357 		getrusage(RUSAGE_CHILDREN, &ru1);
   1358 
   1359 		/* find job and process structures for this pid */
   1360 		for (j = job_list; j != NULL; j = j->next)
   1361 			for (p = j->proc_list; p != NULL; p = p->next)
   1362 				if (p->pid == pid)
   1363 					goto found;
   1364  found:
   1365 		if (j == NULL) {
   1366 			/* Can occur if process has kids, then execs shell
   1367 			warningf(true, "bad process waited for (pid = %d)",
   1368 				pid);
   1369 			 */
   1370 			ru0 = ru1;
   1371 			continue;
   1372 		}
   1373 
   1374 		timeradd(&j->usrtime, &ru1.ru_utime, &j->usrtime);
   1375 		timersub(&j->usrtime, &ru0.ru_utime, &j->usrtime);
   1376 		timeradd(&j->systime, &ru1.ru_stime, &j->systime);
   1377 		timersub(&j->systime, &ru0.ru_stime, &j->systime);
   1378 		ru0 = ru1;
   1379 		p->status = status;
   1380 #ifndef MKSH_UNEMPLOYED
   1381 		if (WIFSTOPPED(status))
   1382 			p->state = PSTOPPED;
   1383 		else
   1384 #if defined(WCONTINUED) && defined(WIFCONTINUED)
   1385 		  if (WIFCONTINUED(status)) {
   1386 			p->state = j->state = PRUNNING;
   1387 			/* skip check_job(), no-op in this case */
   1388 			continue;
   1389 		} else
   1390 #endif
   1391 #endif
   1392 		  if (WIFSIGNALED(status))
   1393 			p->state = PSIGNALLED;
   1394 		else
   1395 			p->state = PEXITED;
   1396 
   1397 		/* check to see if entire job is done */
   1398 		check_job(j);
   1399 	}
   1400 #ifndef MKSH_NOPROSPECTOFWORK
   1401 	    while (/* CONSTCOND */ 1);
   1402 #else
   1403 	    while (/* CONSTCOND */ 0);
   1404 #endif
   1405 
   1406  j_sigchld_out:
   1407 #ifdef MKSH_NO_SIGSUSPEND
   1408 	sigprocmask(SIG_SETMASK, &omask, NULL);
   1409 #endif
   1410 	errno = saved_errno;
   1411 }
   1412 
   1413 /*
   1414  * Called only when a process in j has exited/stopped (ie, called only
   1415  * from j_sigchld()). If no processes are running, the job status
   1416  * and state are updated, asynchronous job notification is done and,
   1417  * if unneeded, the job is removed.
   1418  *
   1419  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1420  */
   1421 static void
   1422 check_job(Job *j)
   1423 {
   1424 	int jstate;
   1425 	Proc *p;
   1426 
   1427 	/* XXX debugging (nasty - interrupt routine using shl_out) */
   1428 	if (!(j->flags & JF_STARTED)) {
   1429 		internal_warningf("check_job: job started (flags 0x%x)",
   1430 		    j->flags);
   1431 		return;
   1432 	}
   1433 
   1434 	jstate = PRUNNING;
   1435 	for (p=j->proc_list; p != NULL; p = p->next) {
   1436 		if (p->state == PRUNNING)
   1437 			/* some processes still running */
   1438 			return;
   1439 		if (p->state > jstate)
   1440 			jstate = p->state;
   1441 	}
   1442 	j->state = jstate;
   1443 	j->status = proc_errorlevel(j->last_proc);
   1444 
   1445 	/*
   1446 	 * Note when co-process dies: can't be done in j_wait() nor
   1447 	 * remove_job() since neither may be called for non-interactive
   1448 	 * shells.
   1449 	 */
   1450 	if (j->state == PEXITED || j->state == PSIGNALLED) {
   1451 		/*
   1452 		 * No need to keep co-process input any more
   1453 		 * (at least, this is what ksh93d thinks)
   1454 		 */
   1455 		if (coproc.job == j) {
   1456 			coproc.job = NULL;
   1457 			/*
   1458 			 * XXX would be nice to get the closes out of here
   1459 			 * so they aren't done in the signal handler.
   1460 			 * Would mean a check in coproc_getfd() to
   1461 			 * do "if job == 0 && write >= 0, close write".
   1462 			 */
   1463 			coproc_write_close(coproc.write);
   1464 		}
   1465 		/* Do we need to keep the output? */
   1466 		if (j->coproc_id && j->coproc_id == coproc.id &&
   1467 		    --coproc.njobs == 0)
   1468 			coproc_readw_close(coproc.read);
   1469 	}
   1470 
   1471 	j->flags |= JF_CHANGED;
   1472 #ifndef MKSH_UNEMPLOYED
   1473 	if (Flag(FMONITOR) && !(j->flags & JF_XXCOM)) {
   1474 		/*
   1475 		 * Only put stopped jobs at the front to avoid confusing
   1476 		 * the user (don't want finished jobs effecting %+ or %-)
   1477 		 */
   1478 		if (j->state == PSTOPPED)
   1479 			put_job(j, PJ_ON_FRONT);
   1480 		if (Flag(FNOTIFY) &&
   1481 		    (j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY)) != JF_WAITING) {
   1482 			/* Look for the real file descriptor 2 */
   1483 			{
   1484 				struct env *ep;
   1485 				int fd = 2;
   1486 
   1487 				for (ep = e; ep; ep = ep->oenv)
   1488 					if (ep->savefd && ep->savefd[2])
   1489 						fd = ep->savefd[2];
   1490 				shf_reopen(fd, SHF_WR, shl_j);
   1491 			}
   1492 			/*
   1493 			 * Can't call j_notify() as it removes jobs. The job
   1494 			 * must stay in the job list as j_waitj() may be
   1495 			 * running with this job.
   1496 			 */
   1497 			j_print(j, JP_MEDIUM, shl_j);
   1498 			shf_flush(shl_j);
   1499 			if (!(j->flags & JF_WAITING) && j->state != PSTOPPED)
   1500 				remove_job(j, "notify");
   1501 		}
   1502 	}
   1503 #endif
   1504 	if (
   1505 #ifndef MKSH_UNEMPLOYED
   1506 	    !Flag(FMONITOR) &&
   1507 #endif
   1508 	    !(j->flags & (JF_WAITING|JF_FG)) &&
   1509 	    j->state != PSTOPPED) {
   1510 		if (j == async_job || (j->flags & JF_KNOWN)) {
   1511 			j->flags |= JF_ZOMBIE;
   1512 			j->job = -1;
   1513 			nzombie++;
   1514 		} else
   1515 			remove_job(j, "checkjob");
   1516 	}
   1517 }
   1518 
   1519 /*
   1520  * Print job status in either short, medium or long format.
   1521  *
   1522  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1523  */
   1524 static void
   1525 j_print(Job *j, int how, struct shf *shf)
   1526 {
   1527 	Proc *p;
   1528 	int state;
   1529 	int status;
   1530 	bool coredumped;
   1531 	char jobchar = ' ';
   1532 	char buf[64];
   1533 	const char *filler;
   1534 	int output = 0;
   1535 
   1536 	if (how == JP_PGRP) {
   1537 		/*
   1538 		 * POSIX doesn't say what to do it there is no process
   1539 		 * group leader (ie, !FMONITOR). We arbitrarily return
   1540 		 * last pid (which is what $! returns).
   1541 		 */
   1542 		shf_fprintf(shf, "%d\n", (int)(j->pgrp ? j->pgrp :
   1543 		    (j->last_proc ? j->last_proc->pid : 0)));
   1544 		return;
   1545 	}
   1546 	j->flags &= ~JF_CHANGED;
   1547 	filler = j->job > 10 ? "\n       " : "\n      ";
   1548 	if (j == job_list)
   1549 		jobchar = '+';
   1550 	else if (j == job_list->next)
   1551 		jobchar = '-';
   1552 
   1553 	for (p = j->proc_list; p != NULL;) {
   1554 		coredumped = false;
   1555 		switch (p->state) {
   1556 		case PRUNNING:
   1557 			memcpy(buf, "Running", 8);
   1558 			break;
   1559 		case PSTOPPED: {
   1560 			int stopsig = WSTOPSIG(p->status);
   1561 
   1562 			strlcpy(buf, stopsig > 0 && stopsig < ksh_NSIG ?
   1563 			    sigtraps[stopsig].mess : "Stopped", sizeof(buf));
   1564 			break;
   1565 		}
   1566 		case PEXITED: {
   1567 			int exitstatus = (WEXITSTATUS(p->status)) & 255;
   1568 
   1569 			if (how == JP_SHORT)
   1570 				buf[0] = '\0';
   1571 			else if (exitstatus == 0)
   1572 				memcpy(buf, "Done", 5);
   1573 			else
   1574 				shf_snprintf(buf, sizeof(buf), "Done (%d)",
   1575 				    exitstatus);
   1576 			break;
   1577 		}
   1578 		case PSIGNALLED: {
   1579 			int termsig = WTERMSIG(p->status);
   1580 #ifdef WCOREDUMP
   1581 			if (WCOREDUMP(p->status))
   1582 				coredumped = true;
   1583 #endif
   1584 			/*
   1585 			 * kludge for not reporting 'normal termination
   1586 			 * signals' (i.e. SIGINT, SIGPIPE)
   1587 			 */
   1588 			if (how == JP_SHORT && !coredumped &&
   1589 			    (termsig == SIGINT || termsig == SIGPIPE)) {
   1590 				buf[0] = '\0';
   1591 			} else
   1592 				strlcpy(buf, termsig > 0 && termsig < ksh_NSIG ?
   1593 				    sigtraps[termsig].mess : "Signalled",
   1594 				    sizeof(buf));
   1595 			break;
   1596 		}
   1597 		default:
   1598 			buf[0] = '\0';
   1599 		}
   1600 
   1601 		if (how != JP_SHORT) {
   1602 			if (p == j->proc_list)
   1603 				shf_fprintf(shf, "[%d] %c ", j->job, jobchar);
   1604 			else
   1605 				shf_puts(filler, shf);
   1606 		}
   1607 
   1608 		if (how == JP_LONG)
   1609 			shf_fprintf(shf, "%5d ", (int)p->pid);
   1610 
   1611 		if (how == JP_SHORT) {
   1612 			if (buf[0]) {
   1613 				output = 1;
   1614 				shf_fprintf(shf, "%s%s ",
   1615 				    buf, coredumped ? " (core dumped)" : null);
   1616 			}
   1617 		} else {
   1618 			output = 1;
   1619 			shf_fprintf(shf, "%-20s %s%s%s", buf, p->command,
   1620 			    p->next ? "|" : null,
   1621 			    coredumped ? " (core dumped)" : null);
   1622 		}
   1623 
   1624 		state = p->state;
   1625 		status = p->status;
   1626 		p = p->next;
   1627 		while (p && p->state == state && p->status == status) {
   1628 			if (how == JP_LONG)
   1629 				shf_fprintf(shf, "%s%5d %-20s %s%s", filler,
   1630 				    (int)p->pid, " ", p->command,
   1631 				    p->next ? "|" : null);
   1632 			else if (how == JP_MEDIUM)
   1633 				shf_fprintf(shf, " %s%s", p->command,
   1634 				    p->next ? "|" : null);
   1635 			p = p->next;
   1636 		}
   1637 	}
   1638 	if (output)
   1639 		shf_putc('\n', shf);
   1640 }
   1641 
   1642 /*
   1643  * Convert % sequence to job
   1644  *
   1645  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1646  */
   1647 static Job *
   1648 j_lookup(const char *cp, int *ecodep)
   1649 {
   1650 	Job *j, *last_match;
   1651 	Proc *p;
   1652 	size_t len;
   1653 	int job = 0;
   1654 
   1655 	if (ksh_isdigit(*cp) && getn(cp, &job)) {
   1656 		/* Look for last_proc->pid (what $! returns) first... */
   1657 		for (j = job_list; j != NULL; j = j->next)
   1658 			if (j->last_proc && j->last_proc->pid == job)
   1659 				return (j);
   1660 		/*
   1661 		 * ...then look for process group (this is non-POSIX,
   1662 		 * but should not break anything
   1663 		 */
   1664 		for (j = job_list; j != NULL; j = j->next)
   1665 			if (j->pgrp && j->pgrp == job)
   1666 				return (j);
   1667 		goto j_lookup_nosuch;
   1668 	}
   1669 	if (*cp != '%') {
   1670  j_lookup_invalid:
   1671 		if (ecodep)
   1672 			*ecodep = JL_INVALID;
   1673 		return (NULL);
   1674 	}
   1675 	switch (*++cp) {
   1676 	case '\0': /* non-standard */
   1677 	case '+':
   1678 	case '%':
   1679 		if (job_list != NULL)
   1680 			return (job_list);
   1681 		break;
   1682 
   1683 	case '-':
   1684 		if (job_list != NULL && job_list->next)
   1685 			return (job_list->next);
   1686 		break;
   1687 
   1688 	case '0': case '1': case '2': case '3': case '4':
   1689 	case '5': case '6': case '7': case '8': case '9':
   1690 		if (!getn(cp, &job))
   1691 			goto j_lookup_invalid;
   1692 		for (j = job_list; j != NULL; j = j->next)
   1693 			if (j->job == job)
   1694 				return (j);
   1695 		break;
   1696 
   1697 	/* %?string */
   1698 	case '?':
   1699 		last_match = NULL;
   1700 		for (j = job_list; j != NULL; j = j->next)
   1701 			for (p = j->proc_list; p != NULL; p = p->next)
   1702 				if (strstr(p->command, cp+1) != NULL) {
   1703 					if (last_match) {
   1704 						if (ecodep)
   1705 							*ecodep = JL_AMBIG;
   1706 						return (NULL);
   1707 					}
   1708 					last_match = j;
   1709 				}
   1710 		if (last_match)
   1711 			return (last_match);
   1712 		break;
   1713 
   1714 	/* %string */
   1715 	default:
   1716 		len = strlen(cp);
   1717 		last_match = NULL;
   1718 		for (j = job_list; j != NULL; j = j->next)
   1719 			if (strncmp(cp, j->proc_list->command, len) == 0) {
   1720 				if (last_match) {
   1721 					if (ecodep)
   1722 						*ecodep = JL_AMBIG;
   1723 					return (NULL);
   1724 				}
   1725 				last_match = j;
   1726 			}
   1727 		if (last_match)
   1728 			return (last_match);
   1729 		break;
   1730 	}
   1731  j_lookup_nosuch:
   1732 	if (ecodep)
   1733 		*ecodep = JL_NOSUCH;
   1734 	return (NULL);
   1735 }
   1736 
   1737 static Job	*free_jobs;
   1738 static Proc	*free_procs;
   1739 
   1740 /*
   1741  * allocate a new job and fill in the job number.
   1742  *
   1743  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1744  */
   1745 static Job *
   1746 new_job(void)
   1747 {
   1748 	int i;
   1749 	Job *newj, *j;
   1750 
   1751 	if (free_jobs != NULL) {
   1752 		newj = free_jobs;
   1753 		free_jobs = free_jobs->next;
   1754 	} else
   1755 		newj = alloc(sizeof(Job), APERM);
   1756 
   1757 	/* brute force method */
   1758 	for (i = 1; ; i++) {
   1759 		for (j = job_list; j && j->job != i; j = j->next)
   1760 			;
   1761 		if (j == NULL)
   1762 			break;
   1763 	}
   1764 	newj->job = i;
   1765 
   1766 	return (newj);
   1767 }
   1768 
   1769 /*
   1770  * Allocate new process struct
   1771  *
   1772  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1773  */
   1774 static Proc *
   1775 new_proc(void)
   1776 {
   1777 	Proc *p;
   1778 
   1779 	if (free_procs != NULL) {
   1780 		p = free_procs;
   1781 		free_procs = free_procs->next;
   1782 	} else
   1783 		p = alloc(sizeof(Proc), APERM);
   1784 
   1785 	return (p);
   1786 }
   1787 
   1788 /*
   1789  * Take job out of job_list and put old structures into free list.
   1790  * Keeps nzombies, last_job and async_job up to date.
   1791  *
   1792  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1793  */
   1794 static void
   1795 remove_job(Job *j, const char *where)
   1796 {
   1797 	Proc *p, *tmp;
   1798 	Job **prev, *curr;
   1799 
   1800 	prev = &job_list;
   1801 	curr = job_list;
   1802 	while (curr && curr != j) {
   1803 		prev = &curr->next;
   1804 		curr = *prev;
   1805 	}
   1806 	if (curr != j) {
   1807 		internal_warningf("remove_job: job %s (%s)", "not found", where);
   1808 		return;
   1809 	}
   1810 	*prev = curr->next;
   1811 
   1812 	/* free up proc structures */
   1813 	for (p = j->proc_list; p != NULL; ) {
   1814 		tmp = p;
   1815 		p = p->next;
   1816 		tmp->next = free_procs;
   1817 		free_procs = tmp;
   1818 	}
   1819 
   1820 	if ((j->flags & JF_ZOMBIE) && j->ppid == procpid)
   1821 		--nzombie;
   1822 	j->next = free_jobs;
   1823 	free_jobs = j;
   1824 
   1825 	if (j == last_job)
   1826 		last_job = NULL;
   1827 	if (j == async_job)
   1828 		async_job = NULL;
   1829 }
   1830 
   1831 /*
   1832  * put j in a particular location (taking it out job_list if it is there
   1833  * already)
   1834  *
   1835  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1836  */
   1837 static void
   1838 put_job(Job *j, int where)
   1839 {
   1840 	Job **prev, *curr;
   1841 
   1842 	/* Remove job from list (if there) */
   1843 	prev = &job_list;
   1844 	curr = job_list;
   1845 	while (curr && curr != j) {
   1846 		prev = &curr->next;
   1847 		curr = *prev;
   1848 	}
   1849 	if (curr == j)
   1850 		*prev = curr->next;
   1851 
   1852 	switch (where) {
   1853 	case PJ_ON_FRONT:
   1854 		j->next = job_list;
   1855 		job_list = j;
   1856 		break;
   1857 
   1858 	case PJ_PAST_STOPPED:
   1859 		prev = &job_list;
   1860 		curr = job_list;
   1861 		for (; curr && curr->state == PSTOPPED; prev = &curr->next,
   1862 		    curr = *prev)
   1863 			;
   1864 		j->next = curr;
   1865 		*prev = j;
   1866 		break;
   1867 	}
   1868 }
   1869 
   1870 /*
   1871  * nuke a job (called when unable to start full job).
   1872  *
   1873  * If jobs are compiled in then this routine expects sigchld to be blocked.
   1874  */
   1875 static int
   1876 kill_job(Job *j, int sig)
   1877 {
   1878 	Proc *p;
   1879 	int rval = 0;
   1880 
   1881 	for (p = j->proc_list; p != NULL; p = p->next)
   1882 		if (p->pid != 0)
   1883 			if (kill(p->pid, sig) < 0)
   1884 				rval = -1;
   1885 	return (rval);
   1886 }
   1887 
   1888 static void
   1889 tty_init_talking(void)
   1890 {
   1891 	switch (tty_init_fd()) {
   1892 	case 0:
   1893 		break;
   1894 	case 1:
   1895 #ifndef MKSH_DISABLE_TTY_WARNING
   1896 		warningf(false, "%s: %s %s: %s",
   1897 		    "No controlling tty", "open", "/dev/tty",
   1898 		    cstrerror(errno));
   1899 #endif
   1900 		break;
   1901 	case 2:
   1902 #ifndef MKSH_DISABLE_TTY_WARNING
   1903 		warningf(false, "%s: %s", "can't find tty fd", cstrerror(errno));
   1904 #endif
   1905 		break;
   1906 	case 3:
   1907 		warningf(false, "%s: %s %s: %s", "j_ttyinit",
   1908 		    "dup of tty fd", "failed", cstrerror(errno));
   1909 		break;
   1910 	case 4:
   1911 		warningf(false, "%s: %s: %s", "j_ttyinit",
   1912 		    "can't set close-on-exec flag", cstrerror(errno));
   1913 		break;
   1914 	}
   1915 }
   1916 
   1917 static void
   1918 tty_init_state(void)
   1919 {
   1920 	if (tty_fd >= 0) {
   1921 		mksh_tcget(tty_fd, &tty_state);
   1922 		tty_hasstate = true;
   1923 	}
   1924 }
   1925