// jobs.c - job control

//

// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

//

/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1992-1997 Paul Falstad

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Paul Falstad or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Paul Falstad and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Paul Falstad and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Paul Falstad and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zsh.mdh"

#include "jobs.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

#ifdef __SYMBIAN32__

#include "dummy.h"

#endif //__SYMBIAN32__

/* the process group of the shell at startup (equal to mypgprp, except

   when we started without being process group leader */

/**/

mod_export pid_t origpgrp;

/* the process group of the shell */

/**/

mod_export pid_t mypgrp;

/* the job we are working on */

/**/

mod_export int thisjob;

/* the current job (+) */

/**/

mod_export int curjob;

/* the previous job (-) */

/**/

mod_export int prevjob;

/* the job table */

/**/

mod_export struct job *jobtab;

/* Size of the job table. */

/**/

mod_export int jobtabsize;

/* The highest numbered job in the jobtable */

/**/

mod_export int maxjob;

/* If we have entered a subshell, the original shell's job table. */

static struct job *oldjobtab;

/* The size of that. */

static int oldmaxjob;

/* shell timings */

/**/

#ifdef HAVE_GETRUSAGE

/**/

static struct rusage child_usage;

/**/

#else

/**/

static struct tms shtms;

/**/

#endif

/* 1 if ttyctl -f has been executed */

/**/

int ttyfrozen;

/* Previous values of errflag and breaks if the signal handler had to

 * change them. And a flag saying if it did that. */

/**/

int prev_errflag, prev_breaks, errbrk_saved;

/**/

int numpipestats, pipestats[MAX_PIPESTATS];

/* Diff two timevals for elapsed-time computations */

/**/

static struct timeval *

dtime(struct timeval *dt, struct timeval *t1, struct timeval *t2)

{

    dt->tv_sec = t2->tv_sec - t1->tv_sec;

    dt->tv_usec = t2->tv_usec - t1->tv_usec;

    if (dt->tv_usec < 0) {

	dt->tv_usec += 1000000.0;

	dt->tv_sec -= 1.0;

    }

    return dt;

}

/* change job table entry from stopped to running */

/**/

void

makerunning(Job jn)

{

    Process pn;

    jn->stat &= ~STAT_STOPPED;

    for (pn = jn->procs; pn; pn = pn->next)

#if 0

	if (WIFSTOPPED(pn->status) && 

	    (!(jn->stat & STAT_SUPERJOB) || pn->next))

	    pn->status = SP_RUNNING;

#endif

        if (WIFSTOPPED(pn->status))

	    pn->status = SP_RUNNING;

    if (jn->stat & STAT_SUPERJOB)

	makerunning(jobtab + jn->other);

}

/* Find process and job associated with pid.         *

 * Return 1 if search was successful, else return 0. */

/**/

int

findproc(pid_t pid, Job *jptr, Process *pptr, int aux)

{

    Process pn;

    int i;

    for (i = 1; i <= maxjob; i++)

    {

	for (pn = aux ? jobtab[i].auxprocs : jobtab[i].procs;

	     pn; pn = pn->next)

	    if (pn->pid == pid) {

		*pptr = pn;

		*jptr = jobtab + i;

		return 1;

	    }

    }

    return 0;

}

/* Does the given job number have any processes? */

/**/

int

hasprocs(int job)

{

    Job jn = jobtab + job;

    return jn->procs || jn->auxprocs;

}

/* Find the super-job of a sub-job. */

/**/

static int

super_job(int sub)

{

    int i;

    for (i = 1; i <= maxjob; i++)

	if ((jobtab[i].stat & STAT_SUPERJOB) &&

	    jobtab[i].other == sub &&

	    jobtab[i].gleader)

	    return i;

    return 0;

}

/**/

static int

handle_sub(int job, int fg)

{

    Job jn = jobtab + job, sj = jobtab + jn->other;

    if ((sj->stat & STAT_DONE) || (!sj->procs && !sj->auxprocs)) {

	struct process *p;

	for (p = sj->procs; p; p = p->next)

	    if (WIFSIGNALED(p->status)) {

		if (jn->gleader != mypgrp && jn->procs->next)

		    killpg(jn->gleader, WTERMSIG(p->status));

		else

		    kill(jn->procs->pid, WTERMSIG(p->status));

		kill(sj->other, SIGCONT);

		kill(sj->other, WTERMSIG(p->status));

		break;

	    }

	if (!p) {

	    int cp;

	    jn->stat &= ~STAT_SUPERJOB;

	    jn->stat |= STAT_WASSUPER;

	    if ((cp = ((WIFEXITED(jn->procs->status) ||

			WIFSIGNALED(jn->procs->status)) &&

		       killpg(jn->gleader, 0) == -1))) {

		Process p;

		for (p = jn->procs; p->next; p = p->next);

		jn->gleader = p->pid;

	    }

	    /* This deleted the job too early if the parent

	       shell waited for a command in a list that will

	       be executed by the sub-shell (e.g.: if we have

	       `ls|if true;then sleep 20;cat;fi' and ^Z the

	       sleep, the rest will be executed by a sub-shell,

	       but the parent shell gets notified for the

	       sleep.

	       deletejob(sj); */

	    /* If this super-job contains only the sub-shell,

	       we have to attach the tty to its process group

	       now. */

	    if ((fg || thisjob == job) &&

		(!jn->procs->next || cp || jn->procs->pid != jn->gleader))

		attachtty(jn->gleader);

	    kill(sj->other, SIGCONT);

	}

	curjob = jn - jobtab;

    } else if (sj->stat & STAT_STOPPED) {

	struct process *p;

	jn->stat |= STAT_STOPPED;

	for (p = jn->procs; p; p = p->next)

	    if (p->status == SP_RUNNING ||

		(!WIFEXITED(p->status) && !WIFSIGNALED(p->status)))

		p->status = sj->procs->status;

	curjob = jn - jobtab;

	printjob(jn, !!isset(LONGLISTJOBS), 1);

	return 1;

    }

    return 0;

}

/* Get the latest usage information */

/**/

void 

get_usage(void)

{

#ifdef HAVE_GETRUSAGE

    getrusage(RUSAGE_CHILDREN, &child_usage);

#else

    times(&shtms);

#endif

}

#ifndef HAVE_GETRUSAGE

/* Update status of process that we have just WAIT'ed for */

/**/

void

update_process(Process pn, int status)

{

    struct timezone dummy_tz;

    long childs, childu;

    childs = shtms.tms_cstime;

    childu = shtms.tms_cutime;

    /* get time-accounting info          */

    get_usage();

    gettimeofday(&pn->endtime, &dummy_tz);  /* record time process exited        */

    pn->status = status;                    /* save the status returned by WAIT  */

    pn->ti.st  = shtms.tms_cstime - childs; /* compute process system space time */

    pn->ti.ut  = shtms.tms_cutime - childu; /* compute process user space time   */

}

#endif

/* Update status of job, possibly printing it */

/**/

void

update_job(Job jn)

{

    Process pn;

    int job;

    int val = 0, status = 0;

    int somestopped = 0, inforeground = 0;

    for (pn = jn->auxprocs; pn; pn = pn->next)

	if (pn->status == SP_RUNNING)

	    return;

    for (pn = jn->procs; pn; pn = pn->next) {

	if (pn->status == SP_RUNNING)      /* some processes in this job are running       */

	    return;                        /* so no need to update job table entry         */

	if (WIFSTOPPED(pn->status))        /* some processes are stopped                   */

	    somestopped = 1;               /* so job is not done, but entry needs updating */

	if (!pn->next)                     /* last job in pipeline determines exit status  */

	    val = (WIFSIGNALED(pn->status)) ? 0200 | WTERMSIG(pn->status) :

		WEXITSTATUS(pn->status);

	if (pn->pid == jn->gleader)        /* if this process is process group leader      */

	    status = pn->status;

    }

    job = jn - jobtab;   /* compute job number */

    if (somestopped) {

	if (jn->stty_in_env && !jn->ty) {

	    jn->ty = (struct ttyinfo *) zalloc(sizeof(struct ttyinfo));

	    gettyinfo(jn->ty);

	}

	if (jn->stat & STAT_STOPPED) {

	    if (jn->stat & STAT_SUBJOB) {

		/* If we have `cat foo|while read a; grep $a bar;done'

		 * and have hit ^Z, the sub-job is stopped, but the

		 * super-job may still be running, waiting to be stopped

		 * or to exit. So we have to send it a SIGTSTP. */

		int i;

		if ((i = super_job(job)))

		    killpg(jobtab[i].gleader, SIGTSTP);

	    }

	    return;

	}

    }

    {                   /* job is done or stopped, remember return value */

	lastval2 = val;

	/* If last process was run in the current shell, keep old status

	 * and let it handle its own traps, but always allow the test

	 * for the pgrp.

	 */

	if (jn->stat & STAT_CURSH)

	    inforeground = 1;

	else if (job == thisjob) {

	    lastval = val;

	    inforeground = 2;

	}

    }

    if (shout && shout != stderr && !ttyfrozen && !jn->stty_in_env &&

	!zleactive && job == thisjob && !somestopped &&

	!(jn->stat & STAT_NOSTTY)) 

	gettyinfo(&shttyinfo);

    if (isset(MONITOR)) {

	pid_t pgrp = gettygrp();           /* get process group of tty      */

	/* is this job in the foreground of an interactive shell? */

	if (mypgrp != pgrp && inforeground &&

	    (jn->gleader == pgrp || (pgrp > 1 && kill(-pgrp, 0) == -1))) {

	    if (list_pipe) {

		if (somestopped || (pgrp > 1 && kill(-pgrp, 0) == -1)) {

		    attachtty(mypgrp);

		    /* check window size and adjust if necessary */

		    adjustwinsize(0);

		} else {

		    /*

		     * Oh, dear, we're right in the middle of some confusion

		     * of shell jobs on the righthand side of a pipeline, so

		     * it's death to call attachtty() just yet.  Mark the

		     * fact in the job, so that the attachtty() will be called

		     * when the job is finally deleted.

		     */

		    jn->stat |= STAT_ATTACH;

		}

		/* If we have `foo|while true; (( x++ )); done', and hit

		 * ^C, we have to stop the loop, too. */

		if ((val & 0200) && inforeground == 1) {

		    if (!errbrk_saved) {

			errbrk_saved = 1;

			prev_breaks = breaks;

			prev_errflag = errflag;

		    }

		    breaks = loops;

		    errflag = 1;

		    inerrflush();

		}

	    } else {

		attachtty(mypgrp);

		/* check window size and adjust if necessary */

		adjustwinsize(0);

	    }

	}

    } else if (list_pipe && (val & 0200) && inforeground == 1) {

	if (!errbrk_saved) {

	    errbrk_saved = 1;

	    prev_breaks = breaks;

	    prev_errflag = errflag;

	}

	breaks = loops;

	errflag = 1;

	inerrflush();

    }

    if (somestopped && jn->stat & STAT_SUPERJOB)

	return;

    jn->stat |= (somestopped) ? STAT_CHANGED | STAT_STOPPED :

	STAT_CHANGED | STAT_DONE;

    if (job == thisjob && (jn->stat & STAT_DONE)) {

	int i;

	Process p;

	for (p = jn->procs, i = 0; p && i < MAX_PIPESTATS; p = p->next, i++)

	    pipestats[i] = ((WIFSIGNALED(p->status)) ?

			    0200 | WTERMSIG(p->status) :

			    WEXITSTATUS(p->status));

	if ((jn->stat & STAT_CURSH) && i < MAX_PIPESTATS)

	    pipestats[i++] = lastval;

	numpipestats = i;

    }

    if (!inforeground &&

	(jn->stat & (STAT_SUBJOB | STAT_DONE)) == (STAT_SUBJOB | STAT_DONE)) {

	int su;

	if ((su = super_job(jn - jobtab)))

	    handle_sub(su, 0);

    }

    if ((jn->stat & (STAT_DONE | STAT_STOPPED)) == STAT_STOPPED) {

	prevjob = curjob;

	curjob = job;

    }

    if ((isset(NOTIFY) || job == thisjob) && (jn->stat & STAT_LOCKED)) {

	printjob(jn, !!isset(LONGLISTJOBS), 0);

	if (zleactive)

	    zrefresh();

    }

    if (sigtrapped[SIGCHLD] && job != thisjob)

	dotrap(SIGCHLD);

    /* When MONITOR is set, the foreground process runs in a different *

     * process group from the shell, so the shell will not receive     *

     * terminal signals, therefore we we pretend that the shell got    *

     * the signal too.                                                 */

    if (inforeground == 2 && isset(MONITOR) && WIFSIGNALED(status)) {

	int sig = WTERMSIG(status);

	if (sig == SIGINT || sig == SIGQUIT) {

	    if (sigtrapped[sig]) {

		dotrap(sig);

		/* We keep the errflag as set or not by dotrap.

		 * This is to fulfil the promise to carry on

		 * with the jobs if trap returns zero.

		 * Setting breaks = loops ensures a consistent return

		 * status if inside a loop.  Maybe the code in loops

		 * should be changed.

		 */

		if (errflag)

		    breaks = loops;

	    } else {

		breaks = loops;

		errflag = 1;

	    }

	}

    }

}

/* set the previous job to something reasonable */

/**/

static void

setprevjob(void)

{

    int i;

    for (i = maxjob; i; i--)

	if ((jobtab[i].stat & STAT_INUSE) && (jobtab[i].stat & STAT_STOPPED) &&

	    !(jobtab[i].stat & STAT_SUBJOB) && i != curjob && i != thisjob) {

	    prevjob = i;

	    return;

	}

    for (i = maxjob; i; i--)

	if ((jobtab[i].stat & STAT_INUSE) && !(jobtab[i].stat & STAT_SUBJOB) &&

	    i != curjob && i != thisjob) {

	    prevjob = i;

	    return;

	}

    prevjob = -1;

}

/**/

#ifndef HAVE_GETRUSAGE

static long clktck = 0;

/**/

static void

set_clktck(void)

{

#ifdef _SC_CLK_TCK

    if (!clktck)

	/* fetch clock ticks per second from *

	 * sysconf only the first time       */

	clktck = sysconf(_SC_CLK_TCK);

#else

# ifdef __NeXT__

    /* NeXTStep 3.3 defines CLK_TCK wrongly */

    clktck = 60;

# else