/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved	*/

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved. The Berkeley Software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#include "sh.h"
#include "sh.dir.h"
#include "sh.proc.h"
#include "wait.h"
#include "sh.tconst.h"

/*
 * C Shell - functions that manage processes, handling hanging, termination
 */

bool	neednote;
bool	pjobs;
static struct process *pprevious;
static short	pmaxindex;
static struct process proclist;
static struct process *pcurrent;
struct process *pcurrjob;
static struct process *pholdjob;

#define	BIGINDEX	9	/* largest desirable job index */

void	pjwait(struct process *);
void	pflush(struct process *);
void	pclrcurr(struct process *);
void	padd(struct command *);
void	pads(tchar *);
void	ptprint(struct process *);
void	pkill(tchar **, int);
void	pstart(struct process *, int);
void	okpcntl(void);
struct process	*pgetcurr(struct process *);
struct process	*pfind(tchar *);

/*
 * pchild - called at interrupt level by the SIGCHLD signal
 *	indicating that at least one child has terminated or stopped
 *	thus at least one wait system call will definitely return a
 *	childs status.  Top level routines (like pwait) must be sure
 *	to mask interrupts when playing with the proclist data structures!
 */
void
pchild(int signal __unused)
{
	struct process *pp;
	struct process	*fp;
	int pid;
	union wait w;
	int jobflags;
	struct rusage ru;

#ifdef TRACE
	tprintf("TRACE- pchile()\n");
#endif
loop:
	pid = csh_wait3(&w, (setintr ? WNOHANG|WUNTRACED:WNOHANG), &ru);
	/*
	 * SysV sends a SIGCHLD when the child process
	 * receives a SIGCONT, and result of that action is ignored here
	 */
	if (w.w_status == WCONTFLG)
		return;
	if (pid <= 0) {
		if (errno == EINTR) {
			errno = 0;
			goto loop;
		}
		return;
	}
	for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next)
		if (pid == pp->p_pid)
			goto found;
	goto loop;
found:
	if (pid == atoi_(value(S_child /* "child" */)))
		unsetv(S_child /* "child" */);
	pp->p_flags &= ~(PRUNNING|PSTOPPED|PREPORTED);
	if (WIFSTOPPED(w)) {
		pp->p_flags |= PSTOPPED;
		pp->p_reason = w.w_stopsig;
	} else {
		if (pp->p_flags & (PTIME|PPTIME) || adrof(S_time /* "time" */))
			(void) gettimeofday(&pp->p_etime, (struct timezone *)0);
		pp->p_rusage = ru;
		if (WIFSIGNALED(w)) {
			if (w.w_termsig == SIGINT)
				pp->p_flags |= PINTERRUPTED;
			else
				pp->p_flags |= PSIGNALED;
			if (w.w_coredump)
				pp->p_flags |= PDUMPED;
			pp->p_reason = w.w_termsig;
		} else {
			pp->p_reason = w.w_retcode;
			if (pp->p_reason != 0)
				pp->p_flags |= PAEXITED;
			else
				pp->p_flags |= PNEXITED;
		}
	}
	jobflags = 0;
	fp = pp;
	do {
		if ((fp->p_flags & (PPTIME|PRUNNING|PSTOPPED)) == 0 &&
		    !child && adrof(S_time /* "time" */) &&
		    fp->p_rusage.ru_utime.tv_sec+fp->p_rusage.ru_stime.tv_sec >=
		    atoi_(value(S_time /* "time" */)))
			fp->p_flags |= PTIME;
		jobflags |= fp->p_flags;
	} while ((fp = fp->p_friends) != pp);
	pp->p_flags &= ~PFOREGND;
	if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
		pp->p_flags &= ~PPTIME;
		pp->p_flags |= PTIME;
	}
	if ((jobflags & (PRUNNING|PREPORTED)) == 0) {
		fp = pp;
		do {
			if (fp->p_flags&PSTOPPED)
				fp->p_flags |= PREPORTED;
		} while ((fp = fp->p_friends) != pp);
		while (fp->p_pid != fp->p_jobid)
			fp = fp->p_friends;
		if (jobflags&PSTOPPED) {
			if (pcurrent && pcurrent != fp)
				pprevious = pcurrent;
			pcurrent = fp;
		} else
			pclrcurr(fp);
		if (jobflags&PFOREGND) {
			if (jobflags & (PSIGNALED|PSTOPPED|PPTIME) ||
#ifdef IIASA
			    jobflags & PAEXITED ||
#endif
			    !eq(dcwd->di_name, fp->p_cwd->di_name)) {
				;	/* print in pjwait */
			}
		} else {
			if (jobflags&PNOTIFY || adrof(S_notify /* "notify" */)) {
				write_string("\015\n");
				flush();
				(void) pprint(pp, NUMBER|NAME|REASON);
				if ((jobflags&PSTOPPED) == 0)
					pflush(pp);
			} else {
				fp->p_flags |= PNEEDNOTE;
				neednote++;
			}
		}
	}
	goto loop;
}

void
pnote(void)
{
	struct process *pp;
	int flags, omask;

#ifdef TRACE
	tprintf("TRACE- pnote()\n");
#endif
	neednote = 0;
	for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next) {
		if (pp->p_flags & PNEEDNOTE) {
			omask = sigblock(sigmask(SIGCHLD));
			pp->p_flags &= ~PNEEDNOTE;
			flags = pprint(pp, NUMBER|NAME|REASON);
			if ((flags&(PRUNNING|PSTOPPED)) == 0)
				pflush(pp);
			(void) sigsetmask(omask);
		}
	}
}

/*
 * pwait - wait for current job to terminate, maintaining integrity
 *	of current and previous job indicators.
 */
void
pwait(void)
{
	struct process *fp, *pp;
	int omask;

#ifdef TRACE
	tprintf("TRACE- pwait()\n");
#endif
	/*
	 * Here's where dead procs get flushed.
	 */
	omask = sigblock(sigmask(SIGCHLD));
	for (pp = (fp = &proclist)->p_next; pp != PNULL; pp = (fp = pp)->p_next)
		if (pp->p_pid == 0) {
			fp->p_next = pp->p_next;
			xfree(pp->p_command);
			if (pp->p_cwd && --pp->p_cwd->di_count == 0)
				if (pp->p_cwd->di_next == 0)
					dfree(pp->p_cwd);
			xfree((tchar *)pp);
			pp = fp;
		}
	(void) sigsetmask(omask);
	pjwait(pcurrjob);
}

/*
 * pjwait - wait for a job to finish or become stopped
 *	It is assumed to be in the foreground state (PFOREGND)
 */
void
pjwait(struct process *pp)
{
	struct process *fp;
	int jobflags, reason, omask;

#ifdef TRACE
	tprintf("TRACE- pjwait()\n");
#endif
	while (pp->p_pid != pp->p_jobid)
		pp = pp->p_friends;
	fp = pp;
	do {
		if ((fp->p_flags&(PFOREGND|PRUNNING)) == PRUNNING)
			printf("BUG: waiting for background job!\n");
	} while ((fp = fp->p_friends) != pp);
	/*
	 * Now keep pausing as long as we are not interrupted (SIGINT),
	 * and the target process, or any of its friends, are running
	 */
	fp = pp;
	omask = sigblock(sigmask(SIGCHLD));
	for (;;) {
		jobflags = 0;
		do
			jobflags |= fp->p_flags;
		while ((fp = (fp->p_friends)) != pp);
		if ((jobflags & PRUNNING) == 0)
			break;
		/*
		 * At this point, csh used to call:
		 *	sigpause(sigblock(0) &~ sigmask(SIGCHLD));
		 * expecting to receive a SIGCHLD signal from the
		 * termination of the child and to invoke the
		 * signal handler, pchild(), as a result.
		 *
		 * However, vfork() now causes a vfork()'d child to
		 * have all of its active signal handlers reset to
		 * SIG_DFL, to forstall parent memory corruption due
		 * to race conditions with signal handling.
		 *
		 * If this instance of csh is itself a child of vfork(),
		 * which can happen when the top-level csh performs a
		 * command substitution inside an i/o redirection, like:
		 *	/bin/echo foo >`/bin/echo trash`
		 * then we will never receive SIGCHLD.  To accommodate
		 * this, we wait until one of our children terminates
		 * (without actually reaping the child) and call the
		 * SIGCHLD signal handler (pchild()) directly.
		 */
		if (csh_wait_noreap() > 0)
			pchild(SIGCHLD);	/* simulate receipt of SIGCHLD */
	}
	(void) sigsetmask(omask);
	if (tpgrp > 0)			/* get tty back */
		(void) ioctl(FSHTTY, TIOCSPGRP,  (char *)&tpgrp);
	if ((jobflags&(PSIGNALED|PSTOPPED|PTIME)) ||
	    !eq(dcwd->di_name, fp->p_cwd->di_name)) {
		if (jobflags&PSTOPPED)
			printf("\n");
		(void) pprint(pp, AREASON|SHELLDIR);
	}
	if ((jobflags&(PINTERRUPTED|PSTOPPED)) && setintr &&
	    (!gointr || !eq(gointr, S_MINUS /* "-" */))) {
		if ((jobflags & PSTOPPED) == 0)
			pflush(pp);
		pintr1(0);
		/*NOTREACHED*/
	}
	reason = 0;
	fp = pp;
	do {
		if (fp->p_reason)
			reason = fp->p_flags & (PSIGNALED|PINTERRUPTED) ?
				fp->p_reason | ABN_TERM : fp->p_reason;
	} while ((fp = fp->p_friends) != pp);
	set(S_status /* "status" */, putn(reason));
	if (reason && exiterr)
		exitstat();
	pflush(pp);
}

/*
 * dowait - wait for all processes to finish
 */
void
dowait(void)
{
	struct process *pp;
	int omask;

#ifdef TRACE
	tprintf("TRACE- dowait()\n");
#endif
	pjobs++;
	omask = sigblock(sigmask(SIGCHLD));
loop:
	for (pp = proclist.p_next; pp; pp = pp->p_next)
		if (pp->p_pid && /* pp->p_pid == pp->p_jobid && */
		    pp->p_flags&PRUNNING) {
			sigpause(0);
			goto loop;
		}
	(void) sigsetmask(omask);
	pjobs = 0;
}

/*
 * pflushall - flush all jobs from list (e.g. at fork())
 */
void
pflushall(void)
{
	struct process	*pp;

#ifdef TRACE
	tprintf("TRACE- pflush()\n");
#endif
	for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next)
		if (pp->p_pid)
			pflush(pp);
}

/*
 * pflush - flag all process structures in the same job as the
 *	the argument process for deletion.  The actual free of the
 *	space is not done here since pflush is called at interrupt level.
 */
void
pflush(struct process *pp)
{
	struct process *np;
	int index;

#ifdef TRACE
	tprintf("TRACE- pflush()\n");
#endif
	if (pp->p_pid == 0) {
		printf("BUG: process flushed twice");
		return;
	}
	while (pp->p_pid != pp->p_jobid)
		pp = pp->p_friends;
	pclrcurr(pp);
	if (pp == pcurrjob)
		pcurrjob = 0;
	index = pp->p_index;
	np = pp;
	do {
		np->p_index = np->p_pid = 0;
		np->p_flags &= ~PNEEDNOTE;
	} while ((np = np->p_friends) != pp);
	if (index == pmaxindex) {
		for (np = proclist.p_next, index = 0; np; np = np->p_next)
			if (np->p_index > (tchar)index)
				index = np->p_index;
		pmaxindex = index;
	}
}

/*
 * pclrcurr - make sure the given job is not the current or previous job;
 *	pp MUST be the job leader
 */
void
pclrcurr(struct process *pp)
{

#ifdef TRACE
	tprintf("TRACE- pclrcurr()\n");
#endif
	if (pp == pcurrent)
		if (pprevious != PNULL) {
			pcurrent = pprevious;
			pprevious = pgetcurr(pp);
		} else {
			pcurrent = pgetcurr(pp);
			pprevious = pgetcurr(pp);
		}
	else if (pp == pprevious)
		pprevious = pgetcurr(pp);
}

/* +4 here is 1 for '\0', 1 ea for << >& >> */
tchar	command[PMAXLEN+4];
int	cmdlen;
tchar	*cmdp;
/*
 * palloc - allocate a process structure and fill it up.
 *	an important assumption is made that the process is running.
 */
void
palloc(int pid, struct command *t)
{
	struct process	*pp;
	int i;

#ifdef TRACE
	tprintf("TRACE- palloc()\n");
#endif
	pp = (struct process *)xcalloc(1, sizeof (struct process));
	pp->p_pid = pid;
	pp->p_flags = t->t_dflg & FAND ? PRUNNING : PRUNNING|PFOREGND;
	if (t->t_dflg & FTIME)
		pp->p_flags |= PPTIME;
	cmdp = command;
	cmdlen = 0;
	padd(t);
	*cmdp++ = 0;
	if (t->t_dflg & FPOU) {
		pp->p_flags |= PPOU;
		if (t->t_dflg & FDIAG)
			pp->p_flags |= PDIAG;
	}
	pp->p_command = savestr(command);
	if (pcurrjob) {
		struct process *fp;
		/* careful here with interrupt level */
		pp->p_cwd = 0;
		pp->p_index = pcurrjob->p_index;
		pp->p_friends = pcurrjob;
		pp->p_jobid = pcurrjob->p_pid;
		for (fp = pcurrjob; fp->p_friends != pcurrjob; fp = fp->p_friends)
			;
		fp->p_friends = pp;
	} else {
		pcurrjob = pp;
		pp->p_jobid = pid;
		pp->p_friends = pp;
		pp->p_cwd = dcwd;
		dcwd->di_count++;
		if (pmaxindex < BIGINDEX)
			pp->p_index = ++pmaxindex;
		else {
			struct process *np;

			for (i = 1; ; i++) {
				for (np = proclist.p_next; np; np = np->p_next)
					if (np->p_index == i)
						goto tryagain;
				pp->p_index = i;
				if (i > pmaxindex)
					pmaxindex = i;
				break;
			tryagain:;
			}
		}
		pprevious = pcurrent;
		pcurrent = pp;
	}
	pp->p_next = proclist.p_next;
	proclist.p_next = pp;
	(void) gettimeofday(&pp->p_btime, (struct timezone *)0);
}

void
padd(struct command *t)
{
	tchar **argp;

#ifdef TRACE
	tprintf("TRACE- padd()\n");
#endif
	if (t == 0)
		return;
	switch (t->t_dtyp) {

	case TPAR:
		pads(S_LBRASP /* "( " */);
		padd(t->t_dspr);
		pads(S_SPRBRA /* " )" */);
		break;

	case TCOM:
		for (argp = t->t_dcom; *argp; argp++) {
			pads(*argp);
			if (argp[1])
				pads(S_SP /* " " */);
		}
		break;

	case TOR:
	case TAND:
	case TFIL:
	case TLST:
		padd(t->t_dcar);
		switch (t->t_dtyp) {
		case TOR:
			pads(S_SPBARBARSP /* " || " */);
			break;
		case TAND:
			pads(S_SPANDANDSP /* " && " */);
			break;
		case TFIL:
			pads(S_SPBARSP /* " | " */);
			break;
		case TLST:
			pads(S_SEMICOLONSP /* "; " */);
			break;
		}
		padd(t->t_dcdr);
		return;
	}
	if ((t->t_dflg & FPIN) == 0 && t->t_dlef) {
		pads((t->t_dflg & FHERE) ? S_SPLESLESSP /* " << " */ : S_SPLESSP /* " < " */);
		pads(t->t_dlef);
	}
	if ((t->t_dflg & FPOU) == 0 && t->t_drit) {
		pads((t->t_dflg & FCAT) ? S_SPGTRGTRSP /* " >>" */ : S_SPGTR /* " >" */);
		if (t->t_dflg & FDIAG)
			pads(S_AND /* "&" */);
		pads(S_SP /* " " */);
		pads(t->t_drit);
	}
}

void
pads(tchar *cp)
{
	int i = strlen_(cp);

#ifdef TRACE
	tprintf("TRACE- pads()\n");
#endif
	if (cmdlen >= PMAXLEN)
		return;
	if (cmdlen + i >= PMAXLEN) {
		(void) strcpy_(cmdp, S_SPPPP /* " ..." */);
		cmdlen = PMAXLEN;
		cmdp += 4;
		return;
	}
	(void) strcpy_(cmdp, cp);
	cmdp += i;
	cmdlen += i;
}

/*
 * psavejob - temporarily save the current job on a one level stack
 *	so another job can be created.  Used for { } in exp6
 *	and `` in globbing.
 */
void
psavejob(void)
{

#ifdef TRACE
	tprintf("TRACE- psavejob()\n");
#endif
	pholdjob = pcurrjob;
	pcurrjob = PNULL;
}

/*
 * prestjob - opposite of psavejob.  This may be missed if we are interrupted
 *	somewhere, but pendjob cleans up anyway.
 */
void
prestjob(void)
{

#ifdef TRACE
	tprintf("TRACE- prestjob()\n");
#endif
	pcurrjob = pholdjob;
	pholdjob = PNULL;
}

/*
 * pendjob - indicate that a job (set of commands) has been completed
 *	or is about to begin.
 */
void
pendjob(void)
{
	struct process *pp, *tp;

#ifdef TRACE
	tprintf("TRACE- pendjob()\n");
#endif
	if (pcurrjob && (pcurrjob->p_flags&(PFOREGND|PSTOPPED)) == 0) {
		pp = pcurrjob;
		while (pp->p_pid != pp->p_jobid)
			pp = pp->p_friends;
		printf("[%d]", pp->p_index);
		tp = pp;
		do {
			printf(" %d", pp->p_pid);
			pp = pp->p_friends;
		} while (pp != tp);
		printf("\n");
	}
	pholdjob = pcurrjob = 0;
}

/*
 * pprint - print a job
 */
int
pprint(struct process *pp, int flag)
{
	int status, reason;
	struct process *tp;
	extern char *linp, linbuf[];
	int jobflags, pstatus;
	char *format;

#ifdef TRACE
	tprintf("TRACE- pprint()\n");
#endif
	while (pp->p_pid != pp->p_jobid)
		pp = pp->p_friends;
	if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
		pp->p_flags &= ~PPTIME;
		pp->p_flags |= PTIME;
	}
	tp = pp;
	status = reason = -1;
	jobflags = 0;
	do {
		jobflags |= pp->p_flags;
		pstatus = pp->p_flags & PALLSTATES;
		if (tp != pp && linp != linbuf && !(flag&FANCY) &&
		    (pstatus == status && pp->p_reason == reason ||
		    !(flag&REASON)))
			printf(" ");
		else {
			if (tp != pp && linp != linbuf)
				printf("\n");
			if (flag&NUMBER)
				if (pp == tp)
					printf("[%d]%s %c ", pp->p_index,
					    pp->p_index < 10 ? " " : "",
					    pp == pcurrent ? '+' :
						(pp == pprevious ? (tchar) '-'
							: (tchar) ' '));
				else
					printf("       ");
			if (flag&FANCY)
				printf("%5d ", pp->p_pid);
			if (flag&(REASON|AREASON)) {
				if (flag&NAME)
					format = "%-21s";
				else
					format = "%s";
				if (pstatus == status)
					if (pp->p_reason == reason) {
						printf(format, "");
						goto prcomd;
					} else
						reason = pp->p_reason;
				else {
					status = pstatus;
					reason = pp->p_reason;
				}
				switch (status) {

				case PRUNNING:
					printf(format, "Running ");
					break;

				case PINTERRUPTED:
				case PSTOPPED:
				case PSIGNALED:
					if ((flag&(REASON|AREASON))
					    && reason != SIGINT
					    && reason != SIGPIPE)
						printf(format,
						    strsignal(pp->p_reason));
					break;

				case PNEXITED:
				case PAEXITED:
					if (flag & REASON)
						if (pp->p_reason)
							printf("Exit %-16d", pp->p_reason);
						else
							printf(format, "Done");
					break;

				default:
					printf("BUG: status=%-9o", status);
				}
			}
		}
prcomd:
		if (flag&NAME) {
			printf("%t", pp->p_command);
			if (pp->p_flags & PPOU)
				printf(" |");
			if (pp->p_flags & PDIAG)
				printf("&");
		}
		if (flag&(REASON|AREASON) && pp->p_flags&PDUMPED)
			printf(" (core dumped)");
		if (tp == pp->p_friends) {
			if (flag&AMPERSAND)
				printf(" &");
			if (flag&JOBDIR &&
			    !eq(tp->p_cwd->di_name, dcwd->di_name)) {
				printf(" (wd: ");
				dtildepr(value(S_home /* "home" */), tp->p_cwd->di_name);
				printf(")");
			}
		}
		if (pp->p_flags&PPTIME && !(status&(PSTOPPED|PRUNNING))) {
			if (linp != linbuf)
				printf("\n\t");
			{ static struct rusage zru;
			    prusage(&zru, &pp->p_rusage, &pp->p_etime,
			    &pp->p_btime);
			}
		}
		if (tp == pp->p_friends) {
			if (linp != linbuf)
				printf("\n");
			if (flag&SHELLDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) {
				printf("(wd now: ");
				dtildepr(value(S_home /* "home" */), dcwd->di_name);
				printf(")\n");
			}
		}
	} while ((pp = pp->p_friends) != tp);
	if (jobflags&PTIME && (jobflags&(PSTOPPED|PRUNNING)) == 0) {
		if (jobflags & NUMBER)
			printf("       ");
		ptprint(tp);
	}
	return (jobflags);
}

void
ptprint(struct process *tp)
{
	struct timeval tetime, diff;
	static struct timeval ztime;
	struct rusage ru;
	static struct rusage zru;
	struct process *pp = tp;

#ifdef TRACE
	tprintf("TRACE- ptprint()\n");
#endif
	ru = zru;
	tetime = ztime;
	do {
		ruadd(&ru, &pp->p_rusage);
		tvsub(&diff, &pp->p_etime, &pp->p_btime);
		if (timercmp(&diff, &tetime, >))
			tetime = diff;
	} while ((pp = pp->p_friends) != tp);
	prusage(&zru, &ru, &tetime, &ztime);
}

/*
 * dojobs - print all jobs
 */
void
dojobs(tchar **v)
{
	struct process *pp;
	int flag = NUMBER|NAME|REASON;
	int i;

#ifdef TRACE
	tprintf("TRACE- dojobs()\n");
#endif
	if (chkstop)
		chkstop = 2;
	if (*++v) {
		if (v[1] || !eq(*v, S_DASHl /* "-l" */))
			error("Usage: jobs [ -l ]");
		flag |= FANCY|JOBDIR;
	}
	for (i = 1; i <= pmaxindex; i++)
		for (pp = proclist.p_next; pp; pp = pp->p_next)
			if (pp->p_index == i && pp->p_pid == pp->p_jobid) {
				pp->p_flags &= ~PNEEDNOTE;
				if (!(pprint(pp, flag) & (PRUNNING|PSTOPPED)))
					pflush(pp);
				break;
			}
}

/*
 * dofg - builtin - put the job into the foreground
 */
void
dofg(tchar **v)
{
	struct process *pp;

#ifdef TRACE
	tprintf("TRACE- dofg()\n");
#endif
	okpcntl();
	++v;
	do {
		pp = pfind(*v);
		pstart(pp, 1);
		pjwait(pp);
	} while (*v && *++v);
}

/*
 * %... - builtin - put the job into the foreground
 */
void
dofg1(tchar **v)
{
	struct process *pp;

#ifdef TRACE
	tprintf("TRACE- untty()\n");
#endif
	okpcntl();
	pp = pfind(v[0]);
	pstart(pp, 1);
	pjwait(pp);
}

/*
 * dobg - builtin - put the job into the background
 */
void
dobg(tchar **v)
{
	struct process *pp;

#ifdef TRACE
	tprintf("TRACE- dobg()\n");
#endif
	okpcntl();
	++v;
	do {
		pp = pfind(*v);
		pstart(pp, 0);
	} while (*v && *++v);
}

/*
 * %... & - builtin - put the job into the background
 */
void
dobg1(tchar **v)
{
	struct process *pp;

#ifdef TRACE
	tprintf("TRACE- dobg1()\n");
#endif
	pp = pfind(v[0]);
	pstart(pp, 0);
}

/*
 * dostop - builtin - stop the job
 */
void
dostop(tchar **v)
{

#ifdef TRACE
	tprintf("TRACE- dostop()\n");
#endif
	pkill(++v, SIGSTOP);
}

/*
 * dokill - builtin - superset of kill (1)
 */
void
dokill(tchar **v)
{
	int signum;
	tchar *name;

#ifdef TRACE
	tprintf("TRACE- dokill()\n");
#endif
	v++;
	if (v[0] && v[0][0] == '-') {
		if (v[0][1] == 'l') {
			for (signum = 1; signum <= NSIG-1; signum++) {
				char	sbuf[BUFSIZ];
				if (sig2str(signum, sbuf) == 0)
					printf("%s ", sbuf);
				if (signum % 8 == 0)
					Putchar('\n');
			}
			Putchar('\n');
			return;
		}
		if (digit(v[0][1])) {
			if (chkalldigit_(v[0]+1) != 0) {
				setname(v[0]+1);
				bferr("Unknown signal; kill -l lists signals");
			}
			signum = atoi_(v[0]+1);
			if (signum < 0 || signum > NSIG)
				bferr("Bad signal number");
		} else {
			int	signo;
			char	sbuf[BUFSIZ];
			name = &v[0][1];
			tstostr(sbuf, name);
			if (str2sig(sbuf, &signo) == 0) {
				signum = signo;
				goto gotsig;
			}
			if (eq(name, S_IOT /* "IOT" */)) {
				signum = SIGABRT;
				goto gotsig;
			}
			setname(name);
			bferr("Unknown signal; kill -l lists signals");
		}
gotsig:
		v++;
	} else
		signum = SIGTERM;
	pkill(v, signum);
}

void
pkill(tchar **v, int signum)
{
	struct process *pp, *np;
	int jobflags = 0;
	int omask, pid, err = 0;
	tchar *cp;

#ifdef TRACE
	tprintf("TRACE- pkill()\n");
#endif
	omask = sigmask(SIGCHLD);
	if (setintr)
		omask |= sigmask(SIGINT);
	omask = sigblock(omask) & ~omask;
	while (*v) {
		cp = globone(*v);
		if (*cp == '%') {
			np = pp = pfind(cp);
			do
				jobflags |= np->p_flags;
			while ((np = np->p_friends) != pp);
			switch (signum) {

			case SIGSTOP:
			case SIGTSTP:
			case SIGTTIN:
			case SIGTTOU:
				if ((jobflags & PRUNNING) == 0) {
					/* %s -> %t */
					printf("%t: Already stopped\n", cp);
					err++;
					goto cont;
				}
			}
			if (killpg(pp->p_jobid, signum) < 0) {
				/* %s -> %t */
				printf("%t: ", cp);
				printf("%s\n", strerror(errno));
				err++;
			}
			if (signum == SIGTERM || signum == SIGHUP)
				(void) killpg(pp->p_jobid, SIGCONT);
		} else if (!(digit(*cp) || *cp == '-'))
			bferr("Arguments should be jobs or process id's");
		else {
			pid = atoi_(cp);
			if (kill(pid, signum) < 0) {
				printf("%d: ", pid);
				printf("%s\n", strerror(errno));
				err++;
				goto cont;
			}
			if (signum == SIGTERM || signum == SIGHUP)
				(void) kill(pid, SIGCONT);
		}
cont:
		xfree(cp);
		v++;
	}
	(void) sigsetmask(omask);
	if (err)
		error(NULL);
}

/*
 * pstart - start the job in foreground/background
 */
void
pstart(struct process *pp, int foregnd)
{
	struct process *np;
	int omask, jobflags = 0;

#ifdef TRACE
	tprintf("TRACE- pstart()\n");
#endif
	omask = sigblock(sigmask(SIGCHLD));
	np = pp;
	do {
		jobflags |= np->p_flags;
		if (np->p_flags&(PRUNNING|PSTOPPED)) {
			np->p_flags |= PRUNNING;
			np->p_flags &= ~PSTOPPED;
			if (foregnd)
				np->p_flags |= PFOREGND;
			else
				np->p_flags &= ~PFOREGND;
		}
	} while ((np = np->p_friends) != pp);

	if (foregnd)
		pclrcurr(pp);
	else
	{
		if (pprevious && (pprevious->p_flags & PSTOPPED))
		{
			pcurrent = pprevious;
			pprevious = pgetcurr(PNULL);
		}
		else
		{
			pcurrent = pgetcurr(pp);
			if (!pcurrent || (pcurrent->p_flags & PRUNNING))
				pcurrent = pp;
			else
				pprevious = pp;
		}
	}
	(void) pprint(pp, foregnd ? NAME|JOBDIR : NUMBER|NAME|AMPERSAND);
	if (foregnd)
		(void) ioctl(FSHTTY, TIOCSPGRP,  (char *)&pp->p_jobid);
	if (jobflags&PSTOPPED)
		(void) killpg(pp->p_jobid, SIGCONT);
	(void) sigsetmask(omask);
}

void
panystop(int neednl)
{
	struct process *pp;

#ifdef TRACE
	tprintf("TRACE- panystop()\n");
#endif
	chkstop = 2;
	for (pp = proclist.p_next; pp; pp = pp->p_next)
		if (pp->p_flags & PSTOPPED)
			error("\nThere are stopped jobs" + 1 - neednl);
}

struct process *
pfind(tchar *cp)
{
	struct process *pp, *np;

#ifdef TRACE
	tprintf("TRACE- pfind()\n");
#endif
	if (cp == 0 || cp[1] == 0 || eq(cp, S_PARCENTPARCENT /* "%%" */) ||
					eq(cp, S_PARCENTPLUS /* "%+" */)) {
		if (pcurrent == PNULL)
			if ((pcurrent = pgetcurr(PNULL)) == PNULL)
				bferr("No current job");
		return (pcurrent);
	}
	if (eq(cp, S_PARCENTMINUS /* "%-" */) ||
	    eq(cp, S_PARCENTSHARP /* "%#" */)) {
		if (pprevious == PNULL)
			bferr("No previous job");
		return (pprevious);
	}
	if (digit(cp[1])) {
		int index = atoi_(cp+1);
		for (pp = proclist.p_next; pp; pp = pp->p_next)
			if (pp->p_index == index && pp->p_pid == pp->p_jobid)
				return (pp);
		bferr("No such job");
	}
	np = PNULL;
	for (pp = proclist.p_next; pp; pp = pp->p_next)
		if (pp->p_pid == pp->p_jobid) {
			if (cp[1] == '?') {
				tchar *dp;
				for (dp = pp->p_command; *dp; dp++) {
					if (*dp != cp[2])
						continue;
					if (prefix(cp+2, dp))
						goto match;
				}
			} else if (prefix(cp+1, pp->p_command)) {
match:
				if (np)
					bferr("Ambiguous");
				np = pp;
			}
		}
	if (np)
		return (np);
	if (cp[1] == '?')
		bferr("No job matches pattern");
	else
		bferr("No such job");
	/*NOTREACHED*/
}

/*
 * pgetcurr - find most recent job that is not pp, preferably stopped
 */
struct process *
pgetcurr(struct process *pp)
{
	struct process *np;
	struct process *xp = PNULL;

#ifdef TRACE
	tprintf("TRACE- pgetcurr()\n");
#endif
	for (np = proclist.p_next; np; np = np->p_next)
		if (np != pcurrent && np != pp && np->p_pid &&
		    np->p_pid == np->p_jobid) {
			if (np->p_flags & PSTOPPED)
				return (np);
			if (xp == PNULL)
				xp = np;
		}
	return (xp);
}

/*
 * donotify - flag the job so as to report termination asynchronously
 */
void
donotify(tchar **v)
{
	struct process *pp;

#ifdef TRACE
	tprintf("TRACE- donotify()\n");
#endif
	pp = pfind(*++v);
	pp->p_flags |= PNOTIFY;
}

/*
 * Do the fork and whatever should be done in the child side that
 * should not be done if we are not forking at all (like for simple builtin's)
 * Also do everything that needs any signals fiddled with in the parent side
 *
 * Wanttty tells whether process and/or tty pgrps are to be manipulated:
 *	-1:	leave tty alone; inherit pgrp from parent
 *	 0:	already have tty; manipulate process pgrps only
 *	 1:	want to claim tty; manipulate process and tty pgrps
 * It is usually just the value of tpgrp.
 *
 * argument:
 *	 t:	command we are forking for
 */
int
pfork(struct command *t, int wanttty)
{
	int pid;
	bool ignint = 0;
	int pgrp, omask;
	int child_pid;

#ifdef TRACE
	tprintf("TRACE- pfork()\n");
#endif
	/*
	 * A child will be uninterruptible only under very special
	 * conditions. Remember that the semantics of '&' is
	 * implemented by disconnecting the process from the tty so
	 * signals do not need to ignored just for '&'.
	 * Thus signals are set to default action for children unless:
	 *	we have had an "onintr -" (then specifically ignored)
	 *	we are not playing with signals (inherit action)
	 */
	if (setintr)
		ignint = (tpgrp == -1 && (t->t_dflg&FINT))
		    || (gointr && eq(gointr, S_MINUS /* "-" */));
	/*
	 * Hold SIGCHLD until we have the process installed in our table.
	 */
	omask = sigblock(sigmask(SIGCHLD));
	while ((pid = fork()) < 0)
		if (setintr == 0)
			sleep(FORKSLEEP);
		else {
			(void) sigsetmask(omask);
			error("Fork failed");
		}

	/*
	 * setup the process group
	 */
	if (pid == 0)
		child_pid = getpid();
	else
		child_pid = pid;
	pgrp = pcurrjob ? pcurrjob->p_jobid : child_pid;

	if (pid == 0) {
		int sigttou;
		settimes();
		pflushall();
		pcurrjob = PNULL;
		child++;
		if (setintr) {
			setintr = 0;		/* until I think otherwise */
			/*
			 * Children just get blown away on SIGINT, SIGQUIT
			 * unless "onintr -" seen.
			 */
			(void) signal(SIGINT, ignint ? SIG_IGN : SIG_DFL);
			(void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
			if (wanttty >= 0) {
				/* make stoppable */
				(void) signal(SIGTSTP, SIG_DFL);
				(void) signal(SIGTTIN, SIG_DFL);
				(void) signal(SIGTTOU, SIG_DFL);
			}
			(void) signal(SIGTERM, parterm);
		} else if (tpgrp == -1 && (t->t_dflg&FINT)) {
			(void) signal(SIGINT, SIG_IGN);
			(void) signal(SIGQUIT, SIG_IGN);
		}
		if (wanttty >= 0 && tpgrp >= 0)
			(void) setpgid(0, pgrp);
		if (wanttty > 0) {
			sigttou = sigblock(sigmask(SIGTTOU) |
					    sigmask(SIGTTIN) |
					    sigmask(SIGTSTP));
			(void) ioctl(FSHTTY, TIOCSPGRP,  (char *)&pgrp);
			sigsetmask(sigttou);
		}
		if (tpgrp > 0)
			tpgrp = 0;		/* gave tty away */
		/*
		 * Nohup and nice apply only to TCOM's but it would be
		 * nice (?!?) if you could say "nohup (foo;bar)"
		 * Then the parser would have to know about nice/nohup/time
		 */
		if (t->t_dflg & FNOHUP)
			(void) signal(SIGHUP, SIG_IGN);
		if (t->t_dflg & FNICE)
			(void) setpriority(PRIO_PROCESS, 0, t->t_nice);
	} else {
		if (wanttty >= 0 && tpgrp >= 0)
			setpgid(pid, pgrp);
		palloc(pid, t);
		(void) sigsetmask(omask);
	}

	return (pid);
}

void
okpcntl(void)
{
#ifdef TRACE
	tprintf("TRACE- okpcntl()\n");
#endif

	if (tpgrp == -1)
		error("No job control in this shell");
	if (tpgrp == 0)
		error("No job control in subshells");
}

void
hupforegnd(void)
{
	struct process *pp;
	int omask;

	omask = sigblock(sigmask(SIGCHLD));
	for (pp = (&proclist)->p_next; pp != PNULL; pp = pp->p_next)
		if (pp->p_pid > 0) {
			if (pp->p_flags & PFOREGND)
				(void) kill(pp->p_pid, SIGHUP);
		}
	(void) sigsetmask(omask);
}