/*

 * 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 "exec.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

#ifdef __SYMBIAN32__

#include <pthread.h>

#include <sys/param.h>

#include <sys/select.h>

#include <sys/stat.h>

#include <stdlib.h>

#include "dummy.h"

#endif //__SYMBIAN32__

#ifdef __SYMBIAN32__

typedef struct

	{

	Eprog p;

	int dont_change_job;

	int exiting;	

	} st_exec;	

#endif //	__SYMBIAN32__

/* used to suppress ERREXIT and trapping of SIGZERR, SIGEXIT. */

/**/

int noerrexit;

/* suppress error messages */

/**/

mod_export int noerrs;

/* do not save history on exec and exit */

/**/

int nohistsave;

/* error/break flag */

/**/

mod_export int errflag;

/* Status of return from a trap */

/**/

int trapreturn;

/* != 0 if this is a subshell */

/**/

int subsh;

/* != 0 if we have a return pending */

/**/

mod_export int retflag;

/**/

long lastval2;

/* The table of file descriptors.  A table element is zero if the  *

 * corresponding fd is not used by the shell.  It is greater than  *

 * 1 if the fd is used by a <(...) or >(...) substitution and 1 if *

 * it is an internal file descriptor which must be closed before   *

 * executing an external command.  The first ten elements of the   *

 * table is not used.  A table element is set by movefd and cleard *

 * by zclose.                                                      */

/**/

char *fdtable;

/* The allocated size of fdtable */

/**/

int fdtable_size;

/* The highest fd that marked with nonzero in fdtable */

/**/

int max_zsh_fd;

/* input fd from the coprocess */

/**/

mod_export int coprocin;

/* output fd from the coprocess */

/**/

mod_export int coprocout;

/* != 0 if the line editor is active */

/**/

mod_export int zleactive;

/* pid of process undergoing 'process substitution' */

/**/

pid_t cmdoutpid;

/* exit status of process undergoing 'process substitution' */

/**/

int cmdoutval;

/* The context in which a shell function is called, see SFC_* in zsh.h. */ 

/**/

mod_export int sfcontext;

/* Stack to save some variables before executing a signal handler function */

/**/

struct execstack *exstack;

/* Stack with names of functions currently active. */

/**/

mod_export Funcstack funcstack;

#define execerr() if (!forked) { lastval = 1; goto done; } else _exit(1)

static LinkList args;

static int doneps4;

static char *STTYval;

/* Execution functions. */

static int (*execfuncs[WC_COUNT-WC_CURSH]) _((Estate, int)) = {

    execcursh, exectime, execfuncdef, execfor, execselect,

    execwhile, execrepeat, execcase, execif, execcond,

    execarith, execautofn, exectry

};

/* structure for command builtin for when it is used with -v or -V */

static struct builtin commandbn =

    BUILTIN(0, 0, bin_whence, 0, -1, BIN_COMMAND, "vV", NULL);

/* parse string into a list */

/**/

mod_export Eprog

parse_string(char *s)

{

    Eprog p;

    int oldlineno = lineno;

    lexsave();

    inpush(s, INP_LINENO, NULL);

    strinbeg(0);

    lineno = 1;

    p = parse_list();

    lineno = oldlineno;

    if (tok == LEXERR && !lastval)

	lastval = 1;

    strinend();

    inpop();

    lexrestore();

    return p;

}

/**/

#ifdef HAVE_GETRLIMIT

/* the resource limits for the shell and its children */

/**/

mod_export struct rlimit current_limits[RLIM_NLIMITS], limits[RLIM_NLIMITS];

/**/

mod_export int

zsetlimit(int limnum, char *nam)

{

    if (limits[limnum].rlim_max != current_limits[limnum].rlim_max ||

	limits[limnum].rlim_cur != current_limits[limnum].rlim_cur) {

	if (setrlimit(limnum, limits + limnum)) {

	    if (nam)

		zwarnnam(nam, "setrlimit failed: %e", NULL, errno);

	    return -1;

	}

	current_limits[limnum] = limits[limnum];

    }

    return 0;

}

/**/

mod_export int

setlimits(char *nam)

{

    int limnum;

    int ret = 0;

    for (limnum = 0; limnum < RLIM_NLIMITS; limnum++)

	if (zsetlimit(limnum, nam))

	    ret++;

    return ret;

}

/**/

#endif /* HAVE_GETRLIMIT */

/* fork and set limits */

/**/

#ifndef __SYMBIAN32__

static pid_t

zfork(struct timeval *tv)

{

    pid_t pid;

    struct timezone dummy_tz;

    /*

     * Is anybody willing to explain this test?

     */

    if (thisjob != -1 && thisjob >= jobtabsize - 1 && !expandjobtab()) {

	zerr("job table full", NULL, 0);

	return -1;

    }

    if (tv)

	gettimeofday(tv, &dummy_tz);

    pid = fork();

    if (pid == -1) {

	zerr("fork failed: %e", NULL, errno);

	return -1;

    }

#ifdef HAVE_GETRLIMIT

    if (!pid)

	/* set resource limits for the child process */

	setlimits(NULL);

#endif

    return pid;

}

#endif //__SYMBIAN32__

/*

 *   Allen Edeln gebiet ich Andacht,

 *   Hohen und Niedern von Heimdalls Geschlecht;

 *   Ich will list_pipe's Wirken kuenden

 *   Die aeltesten Sagen, der ich mich entsinne...

 *

 * In most shells, if you do something like:

 *

 *   cat foo | while read a; do grep $a bar; done

 *

 * the shell forks and executes the loop in the sub-shell thus created.

 * In zsh this traditionally executes the loop in the current shell, which

 * is nice to have if the loop does something to change the shell, like

 * setting parameters or calling builtins.

 * Putting the loop in a sub-shell makes life easy, because the shell only

 * has to put it into the job-structure and then treats it as a normal

 * process. Suspending and interrupting is no problem then.

 * Some years ago, zsh either couldn't suspend such things at all, or

 * it got really messed up when users tried to do it. As a solution, we

 * implemented the list_pipe-stuff, which has since then become a reason

 * for many nightmares.

 * Pipelines like the one above are executed by the functions in this file

 * which call each other (and sometimes recursively). The one above, for

 * example would lead to a function call stack roughly like:

 *

 *  execlist->execpline->execcmd->execwhile->execlist->execpline

 *

 * (when waiting for the grep, ignoring execpline2 for now). At this time,

 * zsh has built two job-table entries for it: one for the cat and one for

 * the grep. If the user hits ^Z at this point (and jobbing is used), the 

 * shell is notified that the grep was suspended. The list_pipe flag is

 * used to tell the execpline where it was waiting that it was in a pipeline

 * with a shell construct at the end (which may also be a shell function or

 * several other things). When zsh sees the suspended grep, it forks to let

 * the sub-shell execute the rest of the while loop. The parent shell walks

 * up in the function call stack to the first execpline. There it has to find

 * out that it has just forked and then has to add information about the sub-

 * shell (its pid and the text for it) in the job entry of the cat. The pid

 * is passed down in the list_pipe_pid variable.

 * But there is a problem: the suspended grep is a child of the parent shell

 * and can't be adopted by the sub-shell. So the parent shell also has to 

 * keep the information about this process (more precisely: this pipeline)

 * by keeping the job table entry it created for it. The fact that there

 * are two jobs which have to be treated together is remembered by setting

 * the STAT_SUPERJOB flag in the entry for the cat-job (which now also

 * contains a process-entry for the whole loop -- the sub-shell) and by

 * setting STAT_SUBJOB in the job of the grep-job. With that we can keep

 * sub-jobs from being displayed and we can handle an fg/bg on the super-

 * job correctly. When the super-job is continued, the shell also wakes up

 * the sub-job. But then, the grep will exit sometime. Now the parent shell

 * has to remember not to try to wake it up again (in case of another ^Z).

 * It also has to wake up the sub-shell (which suspended itself immediately

 * after creation), so that the rest of the loop is executed by it.

 * But there is more: when the sub-shell is created, the cat may already

 * have exited, so we can't put the sub-shell in the process group of it.

 * In this case, we put the sub-shell in the process group of the parent

 * shell and in any case, the sub-shell has to put all commands executed

 * by it into its own process group, because only this way the parent

 * shell can control them since it only knows the process group of the sub-

 * shell. Of course, this information is also important when putting a job

 * in the foreground, where we have to attach its process group to the

 * controlling tty.

 * All this is made more difficult because we have to handle return values

 * correctly. If the grep is signaled, its exit status has to be propagated

 * back to the parent shell which needs it to set the exit status of the

 * super-job. And of course, when the grep is signaled (including ^C), the

 * loop has to be stopped, etc.

 * The code for all this is distributed over three files (exec.c, jobs.c,

 * and signals.c) and none of them is a simple one. So, all in all, there

 * may still be bugs, but considering the complexity (with race conditions,

 * signal handling, and all that), this should probably be expected.

 */

/**/

int list_pipe = 0, simple_pline = 0;

static pid_t list_pipe_pid;

static struct timeval list_pipe_start;

static int nowait, pline_level = 0;

static int list_pipe_child = 0, list_pipe_job;

static char list_pipe_text[JOBTEXTSIZE];

/* execute a current shell command */

/**/

static int

execcursh(Estate state, int do_exec)

{

    Wordcode end = state->pc + WC_CURSH_SKIP(state->pc[-1]);

    /* Skip word only used for try/always */

    state->pc++;

    if (!list_pipe && thisjob != list_pipe_job && !hasprocs(thisjob))

	deletejob(jobtab + thisjob);

    cmdpush(CS_CURSH);

    execlist(state, 1, do_exec);

    cmdpop();

    state->pc = end;

    return lastval;

}

/* execve after handling $_ and #! */

#define POUNDBANGLIMIT 64

/**/

static int

zexecve(char *pth, char **argv)

{

    int eno =0;

#ifndef __SYMBIAN32__

    static char buf[PATH_MAX * 2];

    char **eep;

    unmetafy(pth, NULL);

    for (eep = argv; *eep; eep++)

	if (*eep != pth)

	    unmetafy(*eep, NULL);

    buf[0] = '_';

    buf[1] = '=';

    if (*pth == '/')

	strcpy(buf + 2, pth);

    else

	sprintf(buf + 2, "%s/%s", pwd, pth);

    zputenv(buf);

    closedumps();

    execve(pth, argv, environ);

    /* If the execve returns (which in general shouldn't happen),   *

     * then check for an errno equal to ENOEXEC.  This errno is set *

     * if the process file has the appropriate access permission,   *

     * but has an invalid magic number in its header.               */

    if ((eno = errno) == ENOEXEC) {

	char execvebuf[POUNDBANGLIMIT + 1], *ptr, *ptr2, *argv0;

	int fd, ct, t0;

	if ((fd = open(pth, O_RDONLY|O_NOCTTY)) >= 0) {

	    argv0 = *argv;

	    *argv = pth;

	    ct = read(fd, execvebuf, POUNDBANGLIMIT);

	    close(fd);

	    if (ct > 0) {

		if (execvebuf[0] == '#') {

		    if (execvebuf[1] == '!') {

			for (t0 = 0; t0 != ct; t0++)

			    if (execvebuf[t0] == '\n')

				break;

			while (inblank(execvebuf[t0]))

			    execvebuf[t0--] = '\0';

			execvebuf[POUNDBANGLIMIT] = '\0';

			for (ptr = execvebuf + 2; *ptr && *ptr == ' '; ptr++);

			for (ptr2 = ptr; *ptr && *ptr != ' '; ptr++);

			if (*ptr) {

			    *ptr = '\0';

			    argv[-2] = ptr2;

			    argv[-1] = ptr + 1;

			    execve(ptr2, argv - 2, environ);

			} else {

			    argv[-1] = ptr2;

			    execve(ptr2, argv - 1, environ);

			}

		    } else {

			argv[-1] = "sh";

			execve("/bin/sh", argv - 1, environ);

		    }

		} else {

		    for (t0 = 0; t0 != ct; t0++)

			if (!execvebuf[t0])

			    break;

		    if (t0 == ct) {

			argv[-1] = "sh";

			execve("/bin/sh", argv - 1, environ);

		    }

		}

	    } else

		eno = errno;

	    *argv = argv0;

	} else

	    eno = errno;

    }

    /* restore the original arguments and path but do not bother with *

     * null characters as these cannot be passed to external commands *

     * anyway.  So the result is truncated at the first null char.    */

    pth = metafy(pth, -1, META_NOALLOC);

    for (eep = argv; *eep; eep++)

	if (*eep != pth)

	    (void) metafy(*eep, -1, META_NOALLOC);

#endif//__SYMBIAN32__

    return eno;

}

#define MAXCMDLEN (PATH_MAX*4)

/* test whether we really want to believe the error number */

/**/

static int

isgooderr(int e, char *dir)

{

    /*

     * Maybe the directory was unreadable, or maybe it wasn't

     * even a directory. 

     */

    return ((e != EACCES || !access(dir, X_OK)) &&

	    e != ENOENT && e != ENOTDIR); 

}

/* execute an external command */

/**/

void

execute(UNUSED(Cmdnam cmdname), int dash, int defpath)

{

    Cmdnam cn;

    char buf[MAXCMDLEN], buf2[MAXCMDLEN];

    char *s, *z, *arg0;

    char **argv, **pp;

    int eno = 0, ee;

    arg0 = (char *) peekfirst(args);

    if (isset(RESTRICTED) && (strchr(arg0, '/') || defpath)) {

	zerr("%s: restricted", arg0, 0);

	_exit(1);

    }

    /* If the parameter STTY is set in the command's environment, *

     * we first run the stty command with the value of this       *

     * parameter as it arguments.                                 */

    if ((s = STTYval) && isatty(0) && (GETPGRP() == getpid())) {

	LinkList exargs = args;

	char *t = tricat("stty", " ", s);

	STTYval = 0;	/* this prevents infinite recursion */

	zsfree(s);

	args = NULL;

	execstring(t, 1, 0);