/*      $NetBSD: jobs.c,v 1.19 2017/06/30 04:41:19 kamil Exp $  */

/*
 * Process and job control
 */

/*
 * 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 :)
 *
 * Notes regarding the copious ifdefs:
 *      - TTY_PGRP defined iff JOBS is defined - defined if there are tty
 *        process groups
 *      - NEED_PGRP_SYNC defined iff JOBS is defined - see comment below
 */
#include <sys/cdefs.h>

#ifndef lint
__RCSID("$NetBSD: jobs.c,v 1.19 2017/06/30 04:41:19 kamil Exp $");
#endif

#include <sys/stat.h>
#include <sys/times.h>
#include <sys/wait.h>

#include "sh.h"
#include "tty.h"

/* Start of system configuration stuff */

/* We keep CHILD_MAX zombie processes around (exact value isn't critical) */
#ifndef CHILD_MAX
# if defined(HAVE_SYSCONF) && defined(_SC_CHILD_MAX)
#  define CHILD_MAX sysconf(_SC_CHILD_MAX)
# else /* _SC_CHILD_MAX */
#  ifdef _POSIX_CHILD_MAX
#   define CHILD_MAX    ((_POSIX_CHILD_MAX) * 2)
#  else /* _POSIX_CHILD_MAX */
#   define CHILD_MAX    20
#  endif /* _POSIX_CHILD_MAX */
# endif /* _SC_CHILD_MAX */
#endif /* !CHILD_MAX */

#ifdef JOBS
# if defined(HAVE_TCSETPGRP) || defined(TIOCSPGRP)
#  define TTY_PGRP
# endif
# ifdef BSD_PGRP
#  define setpgid       setpgrp
#  define getpgID()     getpgrp(0)
# else
#  define getpgID()     getpgrp()
# endif
# if defined(TTY_PGRP) && !defined(HAVE_TCSETPGRP)
int tcsetpgrp ARGS((int fd, pid_t grp));
int tcgetpgrp ARGS((int fd));

int
tcsetpgrp(fd, grp)
        int fd;
        pid_t grp;
{
        return ioctl(fd, TIOCSPGRP, &grp);
}

int
tcgetpgrp(fd)
        int     fd;
{
        int r, grp;

        if ((r = ioctl(fd, TIOCGPGRP, &grp)) < 0)
                return r;
        return grp;
}
# endif /* !HAVE_TCSETPGRP && TIOCSPGRP */
#else /* JOBS */
/* These so we can use ifdef xxx instead of if defined(JOBS) && defined(xxx) */
# undef TTY_PGRP
# undef NEED_PGRP_SYNC
#endif /* JOBS */

/* End of system configuration stuff */


/* Order important! */
#define PRUNNING        0
#define PEXITED         1
#define PSIGNALLED      2
#define PSTOPPED        3

typedef struct proc     Proc;
struct 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 */
};

/* Notify/print flag - j_print() argument */
#define JP_NONE         0       /* don't print anything */
#define JP_SHORT        1       /* print signals processes were killed by */
#define JP_MEDIUM       2       /* print [job-num] -/+ command */
#define JP_LONG         3       /* print [job-num] -/+ pid command */
#define JP_PGRP         4       /* print pgrp */

/* put_job() flags */
#define PJ_ON_FRONT     0       /* at very front */
#define PJ_PAST_STOPPED 1       /* just past any stopped jobs */

/* Job.flags values */
#define JF_STARTED      0x001   /* set when all processes in job are started */
#define JF_WAITING      0x002   /* set if j_waitj() is waiting on job */
#define JF_W_ASYNCNOTIFY 0x004  /* set if waiting and async notification ok */
#define JF_XXCOM        0x008   /* set for `command` jobs */
#define JF_FG           0x010   /* running in foreground (also has tty pgrp) */
#define JF_SAVEDTTY     0x020   /* j->ttystate is valid */
#define JF_CHANGED      0x040   /* process has changed state */
#define JF_KNOWN        0x080   /* $! referenced */
#define JF_ZOMBIE       0x100   /* known, unwaited process */
#define JF_REMOVE       0x200   /* flagged for removal (j_jobs()/j_noityf()) */
#define JF_USETTYMODE   0x400   /* tty mode saved if process exits normally */
#define JF_SAVEDTTYPGRP 0x800   /* j->saved_ttypgrp is valid */

typedef struct job Job;
struct 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_least32_t   age;    /* number of jobs started */
        clock_t systime;        /* system time used by job */
        clock_t usrtime;        /* user time used by job */
        Proc    *proc_list;     /* process list */
        Proc    *last_proc;     /* last process in list */
#ifdef KSH
        Coproc_id coproc_id;    /* 0 or id of coprocess output pipe */
#endif /* KSH */
#ifdef TTY_PGRP
        TTY_state ttystate;     /* saved tty state for stopped jobs */
        pid_t   saved_ttypgrp;  /* saved tty process group for stopped jobs */
#endif /* TTY_PGRP */
};

/* Flags for j_waitj() */
#define JW_NONE         0x00
#define JW_INTERRUPT    0x01    /* ^C will stop the wait */
#define JW_ASYNCNOTIFY  0x02    /* asynchronous notification during wait ok */
#define JW_STOPPEDWAIT  0x04    /* wait even if job stopped */

/* Error codes for j_lookup() */
#define JL_OK           0
#define JL_NOSUCH       1       /* no such job */
#define JL_AMBIG        2       /* %foo or %?foo is ambiguous */
#define JL_INVALID      3       /* non-pid, non-% job id */

static const char       *const lookup_msgs[] = {
                                null,
                                "no such job",
                                "ambiguous",
                                "argument must be %job or process id",
                                (char *) 0
                            };
clock_t j_systime, j_usrtime;   /* user and system time of last j_waitjed job */

static Job              *job_list;      /* job list */
static Job              *last_job;
static Job              *async_job;
static pid_t            async_pid;

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


/* held_sigchld is set if sigchld occurs before a job is completely started */
static int              held_sigchld;

#ifdef JOBS
static struct shf       *shl_j;
#endif /* JOBS */

#ifdef NEED_PGRP_SYNC
/* On some systems, the kernel doesn't count zombie processes when checking
 * if a process group is valid, which can cause problems in creating the
 * pipeline "cmd1 | cmd2": if cmd1 can die (and go into the zombie state)
 * before cmd2 is started, the kernel doesn't allow the setpgid() for cmd2
 * to succeed.  Solution is to create a pipe between the parent and the first
 * process; the first process doesn't do anything until the pipe is closed
 * and the parent doesn't close the pipe until all the processes are started.
 */
static int              j_sync_pipe[2];
static int              j_sync_open;
#endif /* NEED_PGRP_SYNC */

#ifdef TTY_PGRP
static int              ttypgrp_ok;     /* set if can use tty pgrps */
static pid_t            restore_ttypgrp = -1;
static pid_t            our_pgrp;
static int const        tt_sigs[] = { SIGTSTP, SIGTTIN, SIGTTOU };
#endif /* TTY_PGRP */

static void             j_set_async ARGS((Job *j));
static void             j_startjob ARGS((Job *j));
static int              j_waitj ARGS((Job *j, int flags, const char *where));
static RETSIGTYPE       j_sigchld ARGS((int sig));
static void             j_print ARGS((Job *j, int how, struct shf *shf));
static Job              *j_lookup ARGS((const char *cp, int *ecodep));
static Job              *new_job ARGS((void));
static Proc             *new_proc ARGS((void));
static void             check_job ARGS((Job *j));
static void             put_job ARGS((Job *j, int where));
static void             remove_job ARGS((Job *j, const char *where));
static int              kill_job ARGS((Job *j, int sig));

/* initialize job control */
void
j_init(mflagset)
        int mflagset;
{
        child_max = CHILD_MAX; /* so syscon() isn't always being called */

        sigemptyset(&sm_default);
        sigprocmask(SIG_SETMASK, &sm_default, (sigset_t *) 0);

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

        setsig(&sigtraps[SIGCHLD], j_sigchld,
                SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);

#ifdef JOBS
        if (!mflagset && Flag(FTALKING))
                Flag(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_WR, (struct shf *) 0);

# ifdef TTY_PGRP
        if (Flag(FMONITOR) || Flag(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); --i >= 0; ) {
                        sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES;
                        /* j_change() sets this to SS_RESTORE_DFL if FMONITOR */
                        setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
                                SS_RESTORE_IGN|SS_FORCE);
                }
        }
# endif /* TTY_PGRP */

        /* j_change() calls tty_init() */
        if (Flag(FMONITOR))
                j_change();
        else
#endif /* JOBS */
          if (Flag(FTALKING))
                tty_init(true);
}

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

        for (j = job_list; j != (Job *) 0; j = j->next) {
                if (j->ppid == procpid
                    && (j->state == PSTOPPED
                        || (j->state == PRUNNING
                            && ((j->flags & JF_FG)
                                || (Flag(FLOGIN) && !Flag(FNOHUP)
                                    && procpid == kshpid)))))
                {
                        killed = 1;
                        if (j->pgrp == 0)
                                kill_job(j, SIGHUP);
                        else
                                killpg(j->pgrp, SIGHUP);
#ifdef JOBS
                        if (j->state == PSTOPPED) {
                                if (j->pgrp == 0)
                                        kill_job(j, SIGCONT);
                                else
                                        killpg(j->pgrp, SIGCONT);
                        }
#endif /* JOBS */
                }
        }
        if (killed)
                sleep(1);
        j_notify();

#ifdef JOBS
# ifdef TTY_PGRP
        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);
        }
# endif /* TTY_PGRP */
        if (Flag(FMONITOR)) {
                Flag(FMONITOR) = 0;
                j_change();
        }
#endif /* JOBS */
}

#ifdef JOBS
/* turn job control on or off according to Flag(FMONITOR) */
void
j_change()
{
        int i;

        if (Flag(FMONITOR)) {
                /* Don't call get_tty() 'til we own the tty process group */
                tty_init(false);

# ifdef TTY_PGRP
                /* no controlling tty, no SIGT* */
                ttypgrp_ok = tty_fd >= 0 && tty_devtty;

                if (ttypgrp_ok && (our_pgrp = getpgID()) < 0) {
                        warningf(false, "j_init: getpgrp() failed: %s",
                                strerror(errno));
                        ttypgrp_ok = 0;
                }
                if (ttypgrp_ok) {
                        setsig(&sigtraps[SIGTTIN], SIG_DFL,
                                SS_RESTORE_ORIG|SS_FORCE);
                        /* wait to be given tty (POSIX.1, B.2, job control) */
                        while (1) {
                                pid_t ttypgrp;

                                if ((ttypgrp = tcgetpgrp(tty_fd)) < 0) {
                                        warningf(false,
                                        "j_init: tcgetpgrp() failed: %s",
                                                strerror(errno));
                                        ttypgrp_ok = 0;
                                        break;
                                }
                                if (ttypgrp == our_pgrp)
                                        break;
                                kill(0, SIGTTIN);
                        }
                }
                for (i = NELEM(tt_sigs); --i >= 0; )
                        setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
                                SS_RESTORE_DFL|SS_FORCE);
                if (ttypgrp_ok && our_pgrp != kshpid) {
                        if (setpgid(0, kshpid) < 0) {
                                warningf(false,
                                        "j_init: setpgid() failed: %s",
                                        strerror(errno));
                                ttypgrp_ok = 0;
                        } else {
                                if (tcsetpgrp(tty_fd, kshpid) < 0) {
                                        warningf(false,
                                        "j_init: tcsetpgrp() failed: %s",
                                                strerror(errno));
                                        ttypgrp_ok = 0;
                                } else
                                        restore_ttypgrp = our_pgrp;
                                our_pgrp = kshpid;
                        }
                }
#  if defined(NTTYDISC) && defined(TIOCSETD) && !defined(HAVE_TERMIOS_H) && !defined(HAVE_TERMIO_H)
                if (ttypgrp_ok) {
                        int ldisc = NTTYDISC;

                        if (ioctl(tty_fd, TIOCSETD, &ldisc) < 0)
                                warningf(false,
                                "j_init: can't set new line discipline: %s",
                                        strerror(errno));
                }
#  endif /* NTTYDISC && TIOCSETD */
                if (!ttypgrp_ok)
                        warningf(false, "warning: won't have full job control");
# endif /* TTY_PGRP */
                if (tty_fd >= 0)
                        get_tty(tty_fd, &tty_state);
        } else {
# ifdef TTY_PGRP
                ttypgrp_ok = 0;
                if (Flag(FTALKING))
                        for (i = NELEM(tt_sigs); --i >= 0; )
                                setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
                                        SS_RESTORE_IGN|SS_FORCE);
                else
                        for (i = NELEM(tt_sigs); --i >= 0; ) {
                                if (sigtraps[tt_sigs[i]].flags & (TF_ORIG_IGN
                                                                  |TF_ORIG_DFL))
                                        setsig(&sigtraps[tt_sigs[i]],
                                                (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN) ? SIG_IGN : SIG_DFL,
                                                SS_RESTORE_ORIG|SS_FORCE);
                        }
# endif /* TTY_PGRP */
                if (!Flag(FTALKING))
                        tty_close();
        }
}
#endif /* JOBS */

/* execute tree in child subprocess */
int
exchild(t, flags, close_fd)
        struct op       *t;
        int             flags;
        int             close_fd;       /* used if XPCLOSE or XCCLOSE */
{
        static Proc     *last_proc;     /* for pipelines */

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

        if (flags & XEXEC)
                /* Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND
                 * (also done in another execute() below)
                 */
                return execute(t, flags & (XEXEC | XERROK));

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

        p = new_proc();
        p->next = (Proc *) 0;
        p->state = PRUNNING;
        p->status = 0;
        p->pid = 0;

        /* link process into jobs list */
        if (flags&XPIPEI) {     /* continuing with a pipe */
                if (!last_job)
                        internal_errorf(1, "exchild: XPIPEI and no last_job - pid %d", (int) procpid);
                j = last_job;
                last_proc->next = p;
                last_proc = p;
        } else {
#ifdef NEED_PGRP_SYNC
                if (j_sync_open) {      /* should never happen */
                        j_sync_open = 0;
                        closepipe(j_sync_pipe);
                }
                /* don't do the sync pipe business if there is no pipeline */
                if (flags & XPIPEO) {
                        openpipe(j_sync_pipe);
                        j_sync_open = 1;
                }
#endif /* NEED_PGRP_SYNC */
                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) ? JF_XXCOM
                        : ((flags & XBGND) ? 0 : (JF_FG|JF_USETTYMODE));
                j->usrtime = j->systime = 0;
                j->state = PRUNNING;
                j->pgrp = 0;
                j->ppid = procpid;
                j->age = ++njobs;
                j->proc_list = p;
#ifdef KSH
                j->coproc_id = 0;
#endif /* KSH */
                last_job = j;
                last_proc = p;
                put_job(j, PJ_PAST_STOPPED);
        }

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

        /* create child process */
        forksleep = 1;
        while ((i = fork()) < 0 && errno == EAGAIN && forksleep < 32) {
                if (intrsig)     /* allow user to ^C out... */
                        break;
                sleep(forksleep);
                forksleep <<= 1;
        }
        if (i < 0) {
                kill_job(j, SIGKILL);
                remove_job(j, "fork failed");
#ifdef NEED_PGRP_SYNC
                if (j_sync_open) {
                        closepipe(j_sync_pipe);
                        j_sync_open = 0;
                }
#endif /* NEED_PGRP_SYNC */
                sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                errorf("cannot fork - try again");
        }
        ischild = i == 0;
        if (ischild)
                p->pid = procpid = getpid();
        else
                p->pid = i;

#ifdef JOBS
        /* job control set up */
        if (Flag(FMONITOR) && !(flags&XXCOM)) {
                int     dotty = 0;
# ifdef NEED_PGRP_SYNC
                int     first_child_sync = 0;
# endif /* NEED_PGRP_SYNC */

# ifdef NEED_PGRP_SYNC
                if (j_sync_open) {
                        /*
                         * The Parent closes 0, keeps 1 open 'til the whole
                         * pipeline is started.  The First child closes 1,
                         * keeps 0 open (reads from it).  The remaining
                         * children just have to close 1 (parent has already
                         * closeed 0).
                         */
                        if (j->pgrp == 0) { /* First process */
                                close(j_sync_pipe[ischild]);
                                j_sync_pipe[ischild] = -1;
                                first_child_sync = ischild;
                        } else if (ischild) {
                                j_sync_open = 0;
                                closepipe(j_sync_pipe);
                        }
                }
# endif /* NEED_PGRP_SYNC */
                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);
# ifdef TTY_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))
                        tcsetpgrp(tty_fd, j->pgrp);
# endif /* TTY_PGRP */
# ifdef NEED_PGRP_SYNC
                if (first_child_sync) {
                        char c;
                        while (read(j_sync_pipe[0], &c, 1) == -1
                               && errno == EINTR)
                                ;
                        close(j_sync_pipe[0]);
                        j_sync_open = 0;
                }
# endif /* NEED_PGRP_SYNC */
        }
#endif /* JOBS */

        /* used to close pipe input fd */
        if (close_fd >= 0 && (((flags & XPCLOSE) && !ischild)
                              || ((flags & XCCLOSE) && ischild)))
                close(close_fd);
        if (ischild) {          /* child */
#ifdef KSH
                /* Do this before restoring signal */
                if (flags & XCOPROC)
                        coproc_cleanup(false);
#endif /* KSH */
                sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                cleanup_parents_env();
#ifdef TTY_PGRP
                /* 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) && !(flags & XXCOM)) {
                        for (i = NELEM(tt_sigs); --i >= 0; )
                                setsig(&sigtraps[tt_sigs[i]], SIG_DFL,
                                        SS_RESTORE_DFL|SS_FORCE);
                }
#endif /* TTY_PGRP */
#ifdef HAVE_NICE
                if (Flag(FBGNICE) && (flags & XBGND))
                        nice(4);
#endif /* HAVE_NICE */
                if ((flags & XBGND) && !Flag(FMONITOR)) {
                        setsig(&sigtraps[SIGINT], SIG_IGN,
                                SS_RESTORE_IGN|SS_FORCE);
                        setsig(&sigtraps[SIGQUIT], SIG_IGN,
                                SS_RESTORE_IGN|SS_FORCE);
                        if (!(flags & (XPIPEI | XCOPROC))) {
                                int fd = open("/dev/null", 0);
                                if (fd != 0) {
                                        (void) ksh_dup2(fd, 0, true);
                                        close(fd);
                                }
                        }
                }
                remove_job(j, "child"); /* in case of `jobs` command */
                nzombie = 0;
#ifdef JOBS
                ttypgrp_ok = 0;
                Flag(FMONITOR) = 0;
#endif /* JOBS */
                Flag(FTALKING) = 0;
                tty_close();
                cleartraps();
                execute(t, (flags & XERROK) | XEXEC); /* no return */
                internal_errorf(0, "exchild: execute() returned");
                unwind(LLEAVE);
                /* NOTREACHED */
        }

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

        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);

        return rv;
}

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

        sigprocmask(SIG_BLOCK, &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_WAITING;
                j_startjob(last_job);
        }
        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
}

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

        sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);

        j = last_job;
        if (!j || !(j->flags & JF_STARTED)) {
                if (!j)
                        warningf(true, "waitlast: no last job");
                else
                        internal_errorf(0, "waitlast: not started");
                sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                return 125; /* not so arbitrary, non-zero value */
        }

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

        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);

        return rv;
}

/* wait for child, interruptable. */
int
waitfor(cp, sigp)
        const char *cp;
        int     *sigp;
{
        int     rv;
        Job     *j;
        int     ecode;
        int     flags = JW_INTERRUPT|JW_ASYNCNOTIFY;
        sigset_t omask;

        sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);

        *sigp = 0;

        if (cp == (char *) 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 == PRUNNING)
                                break;
                if (!j) {
                        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                        return -1;
                }
        } else if ((j = j_lookup(cp, &ecode))) {
                /* don't report normal job completion */
                flags &= ~JW_ASYNCNOTIFY;
                if (j->ppid != procpid) {
                        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                        return -1;
                }
        } else {
                sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                if (ecode != JL_NOSUCH)
                        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_SETMASK, &omask, (sigset_t *) 0);

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

        return rv;
}

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

        sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);

        if ((j = j_lookup(cp, &ecode)) == (Job *) 0) {
                sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 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));
                        rv = 1;
                }
        } else {
#ifdef JOBS
                if (j->state == PSTOPPED && (sig == SIGTERM || sig == SIGHUP))
                        (void) killpg(j->pgrp, SIGCONT);
#endif /* JOBS */
                if (killpg(j->pgrp, sig) < 0) {
                        bi_errorf("%s: %s", cp, strerror(errno));
                        rv = 1;
                }
        }

        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);

        return rv;
}

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

        sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);

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

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

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

        running = 0;
        for (p = j->proc_list; p != (Proc *) 0; p = p->next) {
                if (p->state == PSTOPPED) {
                        p->state = PRUNNING;
                        p->status = 0;
                        running = 1;
                }
                shprintf("%s%s", p->command, p->next ? "| " : null);
        }
        shprintf("%s", newline);
        shf_flush(shl_stdout);
        if (running)
                j->state = PRUNNING;

        put_job(j, PJ_PAST_STOPPED);
        if (bg)
                j_set_async(j);
        else {
# ifdef TTY_PGRP
                /* attach tty to job */
                if (j->state == PRUNNING) {
                        if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) {
                                set_tty(tty_fd, &j->ttystate, TF_NONE);
                        }
                        /* See comment in j_waitj regarding saved_ttypgrp. */
                        if (ttypgrp_ok && tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP) ? j->saved_ttypgrp : j->pgrp) < 0) {
                                if (j->flags & JF_SAVEDTTY) {
                                        set_tty(tty_fd, &tty_state, TF_NONE);
                                }
                                sigprocmask(SIG_SETMASK, &omask,
                                        (sigset_t *) 0);
                                bi_errorf("1st tcsetpgrp(%d, %d) failed: %s",
                                        tty_fd, (int) ((j->flags & JF_SAVEDTTYPGRP) ? j->saved_ttypgrp : j->pgrp), strerror(errno));
                                return 1;
                        }
                }
# endif /* TTY_PGRP */
                j->flags |= JF_FG;
                j->flags &= ~JF_KNOWN;
                if (j == async_job)
                        async_job = (Job *) 0;
        }

        if (j->state == PRUNNING && killpg(j->pgrp, SIGCONT) < 0) {
                int     err = errno;

                if (!bg) {
                        j->flags &= ~JF_FG;
# ifdef TTY_PGRP
                        if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) {
                                set_tty(tty_fd, &tty_state, TF_NONE);
                        }
                        if (ttypgrp_ok && tcsetpgrp(tty_fd, our_pgrp) < 0) {
                                warningf(true,
                                "fg: 2nd tcsetpgrp(%d, %d) failed: %s",
                                        tty_fd, (int) our_pgrp,
                                        strerror(errno));
                        }
# endif /* TTY_PGRP */
                }
                sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                bi_errorf("cannot continue job %s: %s",
                        cp, strerror(err));
                return 1;
        }
        if (!bg) {
# ifdef TTY_PGRP
                if (ttypgrp_ok) {
                        j->flags &= ~(JF_SAVEDTTY | JF_SAVEDTTYPGRP);
                }
# endif /* TTY_PGRP */
                rv = j_waitj(j, JW_NONE, "jw:resume");
        }
        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
        return rv;
}
#endif /* JOBS */

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

        for (j = job_list; j != (Job *) 0; j = j->next) {
#ifdef JOBS
                if (j->ppid == procpid && j->state == PSTOPPED)
                        which |= 1;
#endif /* JOBS */
                if (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid
                    && j->ppid == procpid && j->state == PRUNNING)
                        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;
}

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

        sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);

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

                if ((j = j_lookup(cp, &ecode)) == (Job *) 0) {
                        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
                        bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
                        return 1;
                }
        } else
                j = job_list;
        how = slp == 0 ? JP_MEDIUM : (slp == 1 ? JP_LONG : JP_PGRP);
        for (; j; j = j->next) {
                if ((!(j->flags & JF_ZOMBIE) || zflag)
                    && (!nflag || (j->flags & JF_CHANGED)))
                {
                        j_print(j, how, shl_stdout);
                        if (j->state == PEXITED || j->state == PSIGNALLED)
                                j->flags |= JF_REMOVE;
                }
                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_REMOVE)
                        remove_job(j, "jobs");
        }
        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
        return 0;
}

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

        sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
        for (j = job_list; j; j = j->next) {
#ifdef JOBS
                if (Flag(FMONITOR) && (j->flags & JF_CHANGED))
                        j_print(j, JP_MEDIUM, shl_out);
#endif /* JOBS */
                /* Remove job after doing reports so there aren't
                 * multiple +/- jobs.
                 */
                if (j->state == PEXITED || j->state == PSIGNALLED)
                        j->flags |= JF_REMOVE;
        }
        for (j = job_list; j; j = tmp) {
                tmp = j->next;
                if (j->flags & JF_REMOVE)
                        remove_job(j, "notify");
        }
        shf_flush(shl_out);
        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
}

/* Return pid of last process in last asynchronous job */
pid_t
j_async()
{
        sigset_t omask;

        sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);

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

        sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);

        return async_pid;
}

/* Make j the last async process
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static void
j_set_async(j)
        Job *j;
{
        Job     *jl, *oldest;

        if (async_job && (async_job->flags & (JF_KNOWN|JF_ZOMBIE)) == JF_ZOMBIE)
                remove_job(async_job, "async");
        if (!(j->flags & JF_STARTED)) {
                internal_errorf(0, "j_async: job not started");
                return;
        }
        async_job = j;
        async_pid = j->last_proc->pid;
        while (nzombie > child_max) {
                oldest = (Job *) 0;
                for (jl = job_list; jl; jl = jl->next)
                        if (jl != async_job && (jl->flags & JF_ZOMBIE)
                            && (!oldest || jl->age < oldest->age))
                                oldest = jl;
                if (!oldest) {
                        /* XXX debugging */
                        if (!(async_job->flags & JF_ZOMBIE) || nzombie != 1) {
                                internal_errorf(0, "j_async: bad nzombie (%d)", nzombie);
                                nzombie = 0;
                        }
                        break;
                }
                remove_job(oldest, "zombie");
        }
}

/* Start a job: set STARTED, check for held signals and set j->last_proc
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static void
j_startjob(j)
        Job *j;
{
        Proc    *p;

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

#ifdef NEED_PGRP_SYNC
        if (j_sync_open) {
                j_sync_open = 0;
                closepipe(j_sync_pipe);
        }
#endif /* NEED_PGRP_SYNC */
        if (held_sigchld) {
                held_sigchld = 0;
                /* Don't call j_sigchld() as it may remove job... */
                kill(procpid, SIGCHLD);
        }
}

/*
 * wait for job to complete or change state
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static int
j_waitj(j, flags, where)
        Job     *j;
        int     flags;          /* see JW_* */
        const char *where;
{
        int     rv;

        /*
         * No auto-notify on the job we are waiting on.
         */
        j->flags |= JF_WAITING;
        if (flags & JW_ASYNCNOTIFY)
                j->flags |= JF_W_ASYNCNOTIFY;

        if (!Flag(FMONITOR))
                flags |= JW_STOPPEDWAIT;

        while ((volatile int) j->state == PRUNNING
                || ((flags & JW_STOPPEDWAIT)
                    && (volatile int) j->state == PSTOPPED))
        {
                sigsuspend(&sm_default);
                if (fatal_trap) {
                        int oldf = j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY);
                        j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
                        runtraps(TF_FATAL);
                        j->flags |= oldf; /* not reached... */
                }
                if ((flags & JW_INTERRUPT) && (rv = trap_pending())) {
                        j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
                        return -rv;
                }
        }
        j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);

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

                j->flags &= ~JF_FG;
#ifdef TTY_PGRP
                if (Flag(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 == PSTOPPED
                            && (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0)
                                j->flags |= JF_SAVEDTTYPGRP;
                        if (tcsetpgrp(tty_fd, our_pgrp) < 0) {
                                warningf(true,
                                "j_waitj: tcsetpgrp(%d, %d) failed: %s",
                                        tty_fd, (int) our_pgrp,
                                        strerror(errno));
                        }
                        if (j->state == PSTOPPED) {
                                j->flags |= JF_SAVEDTTY;
                                get_tty(tty_fd, &j->ttystate);
                        }
                }
#endif /* TTY_PGRP */
                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 == PEXITED && j->status == 0
                            && (j->flags & JF_USETTYMODE))
                        {
                                get_tty(tty_fd, &tty_state);
                        } else {
                                set_tty(tty_fd, &tty_state,
                                    (j->state == PEXITED) ? 0 : TF_MIPSKLUDGE);
                                /* 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 == PSTOPPED)
                                        j->flags &= ~JF_USETTYMODE;
                        }
                }
#ifdef JOBS
                /* 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) && j->state == PSIGNALLED
                    && WIFSIGNALED(status)
                    && (sigtraps[WTERMSIG(status)].flags & TF_TTY_INTR))
                        trapsig(WTERMSIG(status));
#endif /* JOBS */
        }

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

        if (!(flags & JW_ASYNCNOTIFY)
            && (!Flag(FMONITOR) || j->state != PSTOPPED))
        {
                j_print(j, JP_SHORT, shl_out);
                shf_flush(shl_out);
        }
        if (j->state != PSTOPPED
            && (!Flag(FMONITOR) || !(flags & JW_ASYNCNOTIFY)))
                remove_job(j, where);

        return rv;
}

/* SIGCHLD handler to reap children and update job states
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static RETSIGTYPE
j_sigchld(sig)
        int     sig;
{
        int             errno_ = errno;
        Job             *j;
        Proc            UNINITIALIZED(*p);
        int             pid;
        int             status;
        struct tms      t0, t1;

        /* 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_STARTED)) {
                        held_sigchld = 1;
                        return RETSIGVAL;
                }

        times(&t0);
        do {
                pid = waitpid(-1, &status, (WNOHANG|WUNTRACED));

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

                times(&t1);

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

                j->usrtime += t1.tms_cutime - t0.tms_cutime;
                j->systime += t1.tms_cstime - t0.tms_cstime;
                t0 = t1;
                p->status = status;
#ifdef JOBS
                if (WIFSTOPPED(status))
                        p->state = PSTOPPED;
                else
#endif /* JOBS */
                if (WIFSIGNALED(status))
                        p->state = PSIGNALLED;
                else
                        p->state = PEXITED;

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

        errno = errno_;

        return RETSIGVAL;
}

/*
 * 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.
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static void
check_job(j)
        Job     *j;
{
        int     jstate;
        Proc    *p;

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

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

        switch (j->last_proc->state) {
        case PEXITED:
                j->status = WEXITSTATUS(j->last_proc->status);
                break;
        case PSIGNALLED:
                j->status = 128 + WTERMSIG(j->last_proc->status);
                break;
        default:
                j->status = 0;
                break;
        }

#ifdef KSH
        /* 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 == PEXITED || j->state == PSIGNALLED) {
                /* No need to keep co-process input any more
                 * (at least, this is what ksh93d thinks)
                 */
                if (coproc.job == j) {
                        coproc.job = (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);
        }
#endif /* KSH */

        j->flags |= JF_CHANGED;
#ifdef JOBS
        if (Flag(FMONITOR) && !(j->flags & JF_XXCOM)) {
                /* Only put stopped jobs at the front to avoid confusing
                 * the user (don't want finished jobs effecting %+ or %-)
                 */
                if (j->state == PSTOPPED)
                        put_job(j, PJ_ON_FRONT);
                if (Flag(FNOTIFY)
                    && (j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY)) != JF_WAITING)
                {
                        /* Look for the real file descriptor 2 */
                        {
                                struct env *ep;
                                int fd = 2;

                                for (ep = e; ep; ep = ep->oenv)
                                        if (ep->savefd && ep->savefd[2])
                                                fd = ep->savefd[2];
                                shf_reopen(fd, SHF_WR, 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_MEDIUM, shl_j);
                        shf_flush(shl_j);
                        if (!(j->flags & JF_WAITING) && j->state != PSTOPPED)
                                remove_job(j, "notify");
                }
        }
#endif /* JOBS */
        if (!Flag(FMONITOR) && !(j->flags & (JF_WAITING|JF_FG))
            && j->state != PSTOPPED)
        {
                if (j == async_job || (j->flags & JF_KNOWN)) {
                        j->flags |= JF_ZOMBIE;
                        j->job = -1;
                        nzombie++;
                } else
                        remove_job(j, "checkjob");
        }
}

/*
 * Print job status in either short, medium or long format.
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static void
j_print(j, how, shf)
        Job             *j;
        int             how;
        struct shf      *shf;
{
        Proc    *p;
        int     state;
        int     status;
        int     coredumped;
        char    jobchar = ' ';
        char    buf[64];
        const char *filler;
        int     output = 0;

        if (how == JP_PGRP) {
                /* POSIX doesn't say what to do it 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_CHANGED;
        filler = j->job > 10 ?  "\n       " : "\n      ";
        if (j == job_list)
                jobchar = '+';
        else if (j == job_list->next)
                jobchar = '-';

        for (p = j->proc_list; p != (Proc *) 0;) {
                coredumped = 0;
                switch (p->state) {
                case PRUNNING:
                        strlcpy(buf, "Running", sizeof buf);
                        break;
                case PSTOPPED:
                        strlcpy(buf, sigtraps[WSTOPSIG(p->status)].mess,
                            sizeof buf);
                        break;
                case PEXITED:
                        if (how == JP_SHORT)
                                buf[0] = '\0';
                        else if (WEXITSTATUS(p->status) == 0)
                                strlcpy(buf, "Done", sizeof buf);
                        else
                                shf_snprintf(buf, sizeof(buf), "Done (%d)",
                                        WEXITSTATUS(p->status));
                        break;
                case PSIGNALLED:
                        if (WCOREDUMP(p->status))
                                coredumped = 1;
                        /* kludge for not reporting `normal termination signals'
                         * (ie, SIGINT, SIGPIPE)
                         */
                        if (how == JP_SHORT && !coredumped
                            && (WTERMSIG(p->status) == SIGINT
                                || WTERMSIG(p->status) == SIGPIPE)) {
                                buf[0] = '\0';
                        } else
                                strlcpy(buf, sigtraps[WTERMSIG(p->status)].mess,
                                    sizeof buf);
                        break;
                }

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

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

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

                state = p->state;
                status = p->status;
                p = p->next;
                while (p && p->state == state && p->status == status)
                {
                        if (how == JP_LONG)
                                shf_fprintf(shf, "%s%5d %-20s %s%s", filler, p->pid,
                                        space, p->command, p->next ? "|" : null);
                        else if (how == JP_MEDIUM)
                                shf_fprintf(shf, " %s%s", p->command,
                                        p->next ? "|" : null);
                        p = p->next;
                }
        }
        if (output)
                shf_fprintf(shf, newline);
}

/* Convert % sequence to job
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static Job *
j_lookup(cp, ecodep)
        const char *cp;
        int     *ecodep;
{
        Job             *j, *last_match;
        Proc            *p;
        int             len, job = 0;

        if (digit(*cp)) {
                job = atoi(cp);
                /* Look for last_proc->pid (what $! returns) first... */
                for (j = job_list; j != (Job *) 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 != (Job *) 0; j = j->next)
                        if (j->pgrp && j->pgrp == job)
                                return j;
                if (ecodep)
                        *ecodep = JL_NOSUCH;
                return (Job *) 0;
        }
        if (*cp != '%') {
                if (ecodep)
                        *ecodep = JL_INVALID;
                return (Job *) 0;
        }
        switch (*++cp) {
        case '\0': /* non-standard */
        case '+':
        case '%':
                if (job_list != (Job *) 0)
                        return job_list;
                break;

        case '-':
                if (job_list != (Job *) 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 = atoi(cp);
                for (j = job_list; j != (Job *) 0; j = j->next)
                        if (j->job == job)
                                return j;
                break;

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

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

static Job      *free_jobs;
static Proc     *free_procs;

/* allocate a new job and fill in the job number.
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static Job *
new_job()
{
        int     i;
        Job     *newj, *j;

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

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

        return newj;
}

/* Allocate new process struct
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static Proc *
new_proc()
{
        Proc    *p;

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

        return p;
}

/* Take job out of job_list and put old structures into free list.
 * Keeps nzombies, last_job and async_job up to date.
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static void
remove_job(j, where)
        Job     *j;
        const char *where;
{
        Proc    *p, *tmp;
        Job     **prev, *curr;

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

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

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

        if (j == last_job)
                last_job = (Job *) 0;
        if (j == async_job)
                async_job = (Job *) 0;
}

/* put j in a particular location (taking it out job_list if it is there
 * already)
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static void
put_job(j, where)
        Job     *j;
        int     where;
{
        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_FRONT:
                j->next = job_list;
                job_list = j;
                break;

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

/* nuke a job (called when unable to start full job).
 *
 * If jobs are compiled in then this routine expects sigchld to be blocked.
 */
static int
kill_job(j, sig)
        Job     *j;
        int     sig;
{
        Proc    *p;
        int     rval = 0;

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