/*	$OpenBSD: exec.c,v 1.52 2015/09/10 22:48:58 nicm Exp $	*/

/*-

 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

 *		 2011, 2012, 2013, 2014, 2015, 2016, 2017

 *	mirabilos <m@mirbsd.org>

 *

 * Provided that these terms and disclaimer and all copyright notices

 * are retained or reproduced in an accompanying document, permission

 * is granted to deal in this work without restriction, including un-

 * limited rights to use, publicly perform, distribute, sell, modify,

 * merge, give away, or sublicence.

 *

 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to

 * the utmost extent permitted by applicable law, neither express nor

 * implied; without malicious intent or gross negligence. In no event

 * may a licensor, author or contributor be held liable for indirect,

 * direct, other damage, loss, or other issues arising in any way out

 * of dealing in the work, even if advised of the possibility of such

 * damage or existence of a defect, except proven that it results out

 * of said person's immediate fault when using the work as intended.

 */

#include "sh.h"

__RCSID("$MirOS: src/bin/mksh/exec.c,v 1.201 2017/10/11 21:09:24 tg Exp $");

#ifndef MKSH_DEFAULT_EXECSHELL

#define MKSH_DEFAULT_EXECSHELL	MKSH_UNIXROOT "/bin/sh"

#endif

static int comexec(struct op *, struct tbl * volatile, const char **,

    int volatile, volatile int *);

static void scriptexec(struct op *, const char **) MKSH_A_NORETURN;

static int call_builtin(struct tbl *, const char **, const char *, bool);

static int iosetup(struct ioword *, struct tbl *);

static const char *do_selectargs(const char **, bool);

static Test_op dbteste_isa(Test_env *, Test_meta);

static const char *dbteste_getopnd(Test_env *, Test_op, bool);

static void dbteste_error(Test_env *, int, const char *);

/* XXX: horrible kludge to fit within the framework */

static void plain_fmt_entry(char *, size_t, unsigned int, const void *);

static void select_fmt_entry(char *, size_t, unsigned int, const void *);

/*

 * execute command tree

 */

int

execute(struct op * volatile t,

    /* if XEXEC don't fork */

    volatile int flags,

    volatile int * volatile xerrok)

{

	int i;

	volatile int rv = 0, dummy = 0;

	int pv[2];

	const char ** volatile ap = NULL;

	char ** volatile up;

	const char *s, *ccp;

	struct ioword **iowp;

	struct tbl *tp = NULL;

	if (t == NULL)

		return (0);

	/* Caller doesn't care if XERROK should propagate. */

	if (xerrok == NULL)

		xerrok = &dummy;

	if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)

		/* run in sub-process */

		return (exchild(t, flags & ~XTIME, xerrok, -1));

	newenv(E_EXEC);

	if (trap)

		runtraps(0);

	/* we want to run an executable, do some variance checks */

	if (t->type == TCOM) {

		/*

		 * Clear subst_exstat before argument expansion. Used by

		 * null commands (see comexec() and c_eval()) and by c_set().

		 */

		subst_exstat = 0;

		/* for $LINENO */

		current_lineno = t->lineno;

		/* check if this is 'var=<

		if (

		    /* we have zero arguments, i.e. no program to run */

		    t->args[0] == NULL &&

		    /* we have exactly one variable assignment */

		    t->vars[0] != NULL && t->vars[1] == NULL &&

		    /* we have exactly one I/O redirection */

		    t->ioact != NULL && t->ioact[0] != NULL &&

		    t->ioact[1] == NULL &&

		    /* of type "here document" (or "here string") */

		    (t->ioact[0]->ioflag & IOTYPE) == IOHERE &&

		    /* the variable assignment begins with a valid varname */

		    (ccp = skip_wdvarname(t->vars[0], true)) != t->vars[0] &&

		    /* and has no right-hand side (i.e. "varname=") */

		    ccp[0] == CHAR && ((ccp[1] == '=' && ccp[2] == EOS) ||

		    /* or "varname+=" */ (ccp[1] == '+' && ccp[2] == CHAR &&

		    ccp[3] == '=' && ccp[4] == EOS))) {

			char *cp, *dp;

			if ((rv = herein(t->ioact[0], &cp) /*? 1 : 0*/))

				cp = NULL;

			dp = shf_smprintf(Tf_ss, evalstr(t->vars[0],

			    DOASNTILDE | DOSCALAR), rv ? null : cp);

			typeset(dp, Flag(FEXPORT) ? EXPORT : 0, 0, 0, 0);

			/* free the expanded value */

			afree(cp, APERM);

			afree(dp, ATEMP);

			goto Break;

		}

		/*

		 * POSIX says expand command words first, then redirections,

		 * and assignments last..

		 */

		up = eval(t->args, t->u.evalflags | DOBLANK | DOGLOB | DOTILDE);

		if (flags & XTIME)

			/* Allow option parsing (bizarre, but POSIX) */

			timex_hook(t, &up);

		ap = (const char **)up;

		if (ap[0])

			tp = findcom(ap[0], FC_BI|FC_FUNC);

	}

	flags &= ~XTIME;

	if (t->ioact != NULL || t->type == TPIPE || t->type == TCOPROC) {

		e->savefd = alloc2(NUFILE, sizeof(short), ATEMP);

		/* initialise to not redirected */

		memset(e->savefd, 0, NUFILE * sizeof(short));

	}

	/* mark for replacement later (unless TPIPE) */

	vp_pipest->flag |= INT_L;

	/* do redirection, to be restored in quitenv() */

	if (t->ioact != NULL)

		for (iowp = t->ioact; *iowp != NULL; iowp++) {

			if (iosetup(*iowp, tp) < 0) {

				exstat = rv = 1;

				/*

				 * Redirection failures for special commands

				 * cause (non-interactive) shell to exit.

				 */

				if (tp && tp->type == CSHELL &&

				    (tp->flag & SPEC_BI))

					errorfz();

				/* Deal with FERREXIT, quitenv(), etc. */

				goto Break;

			}

		}

	switch (t->type) {

	case TCOM:

		rv = comexec(t, tp, (const char **)ap, flags, xerrok);

		break;

	case TPAREN:

		rv = execute(t->left, flags | XFORK, xerrok);

		break;

	case TPIPE:

		flags |= XFORK;

		flags &= ~XEXEC;

		e->savefd[0] = savefd(0);

		e->savefd[1] = savefd(1);

		while (t->type == TPIPE) {

			openpipe(pv);

			/* stdout of curr */

			ksh_dup2(pv[1], 1, false);

			/**

			 * Let exchild() close pv[0] in child

			 * (if this isn't done, commands like

			 *	(: ; cat /etc/termcap) | sleep 1

			 * will hang forever).

			 */

			exchild(t->left, flags | XPIPEO | XCCLOSE,

			    NULL, pv[0]);

			/* stdin of next */

			ksh_dup2(pv[0], 0, false);

			closepipe(pv);

			flags |= XPIPEI;

			t = t->right;

		}

		/* stdout of last */

		restfd(1, e->savefd[1]);

		/* no need to re-restore this */

		e->savefd[1] = 0;

		/* Let exchild() close 0 in parent, after fork, before wait */

		i = exchild(t, flags | XPCLOSE | XPIPEST, xerrok, 0);

		if (!(flags&XBGND) && !(flags&XXCOM))

			rv = i;

		break;

	case TLIST:

		while (t->type == TLIST) {

			execute(t->left, flags & XERROK, NULL);

			t = t->right;

		}

		rv = execute(t, flags & XERROK, xerrok);

		break;

	case TCOPROC: {

#ifndef MKSH_NOPROSPECTOFWORK

		sigset_t omask;

		/*

		 * Block sigchild as we are using things changed in the

		 * signal handler

		 */

		sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);

		e->type = E_ERRH;

		if ((i = kshsetjmp(e->jbuf))) {

			sigprocmask(SIG_SETMASK, &omask, NULL);

			quitenv(NULL);

			unwind(i);

			/* NOTREACHED */

		}

#endif

		/* Already have a (live) co-process? */

		if (coproc.job && coproc.write >= 0)

			errorf("coprocess already exists");

		/* Can we re-use the existing co-process pipe? */

		coproc_cleanup(true);

		/* do this before opening pipes, in case these fail */

		e->savefd[0] = savefd(0);

		e->savefd[1] = savefd(1);

		openpipe(pv);

		if (pv[0] != 0) {

			ksh_dup2(pv[0], 0, false);

			close(pv[0]);

		}

		coproc.write = pv[1];

		coproc.job = NULL;

		if (coproc.readw >= 0)

			ksh_dup2(coproc.readw, 1, false);

		else {

			openpipe(pv);

			coproc.read = pv[0];

			ksh_dup2(pv[1], 1, false);

			/* closed before first read */

			coproc.readw = pv[1];

			coproc.njobs = 0;

			/* create new coprocess id */

			++coproc.id;

		}

#ifndef MKSH_NOPROSPECTOFWORK

		sigprocmask(SIG_SETMASK, &omask, NULL);

		/* no more need for error handler */

		e->type = E_EXEC;

#endif

		/*

		 * exchild() closes coproc.* in child after fork,

		 * will also increment coproc.njobs when the

		 * job is actually created.

		 */

		flags &= ~XEXEC;

		exchild(t->left, flags | XBGND | XFORK | XCOPROC | XCCLOSE,

		    NULL, coproc.readw);

		break;

	}

	case TASYNC:

		/*

		 * XXX non-optimal, I think - "(foo &)", forks for (),

		 * forks again for async... parent should optimise

		 * this to "foo &"...

		 */

		rv = execute(t->left, (flags&~XEXEC)|XBGND|XFORK, xerrok);

		break;

	case TOR:

	case TAND:

		rv = execute(t->left, XERROK, NULL);

		if ((rv == 0) == (t->type == TAND))

			rv = execute(t->right, flags & XERROK, xerrok);

		else {

			flags |= XERROK;

			if (xerrok)

				*xerrok = 1;

		}

		break;

	case TBANG:

		rv = !execute(t->right, XERROK, xerrok);

		flags |= XERROK;

		if (xerrok)

			*xerrok = 1;

		break;

	case TDBRACKET: {

		Test_env te;

		te.flags = TEF_DBRACKET;

		te.pos.wp = t->args;

		te.isa = dbteste_isa;

		te.getopnd = dbteste_getopnd;

		te.eval = test_eval;

		te.error = dbteste_error;

		rv = test_parse(&te);

		break;

	}

	case TFOR:

	case TSELECT: {

		volatile bool is_first = true;

		ap = (t->vars == NULL) ? e->loc->argv + 1 :

		    (const char **)eval((const char **)t->vars,

		    DOBLANK | DOGLOB | DOTILDE);

		e->type = E_LOOP;

		while ((i = kshsetjmp(e->jbuf))) {

			if ((e->flags&EF_BRKCONT_PASS) ||

			    (i != LBREAK && i != LCONTIN)) {

				quitenv(NULL);

				unwind(i);

			} else if (i == LBREAK) {

				rv = 0;

				goto Break;

			}

		}

		/* in case of a continue */

		rv = 0;

		if (t->type == TFOR) {

			while (*ap != NULL) {

				setstr(global(t->str), *ap++, KSH_UNWIND_ERROR);

				rv = execute(t->left, flags & XERROK, xerrok);

			}

		} else {

 do_TSELECT:

			if ((ccp = do_selectargs(ap, is_first))) {

				is_first = false;

				setstr(global(t->str), ccp, KSH_UNWIND_ERROR);

				execute(t->left, flags & XERROK, xerrok);

				goto do_TSELECT;

			}

			rv = 1;

		}

		break;

	}

	case TWHILE:

	case TUNTIL:

		e->type = E_LOOP;

		while ((i = kshsetjmp(e->jbuf))) {

			if ((e->flags&EF_BRKCONT_PASS) ||

			    (i != LBREAK && i != LCONTIN)) {

				quitenv(NULL);

				unwind(i);

			} else if (i == LBREAK) {

				rv = 0;

				goto Break;

			}

		}

		/* in case of a continue */

		rv = 0;

		while ((execute(t->left, XERROK, NULL) == 0) ==

		    (t->type == TWHILE))

			rv = execute(t->right, flags & XERROK, xerrok);

		break;

	case TIF:

	case TELIF:

		if (t->right == NULL)

			/* should be error */

			break;

		rv = execute(execute(t->left, XERROK, NULL) == 0 ?

		    t->right->left : t->right->right, flags & XERROK, xerrok);

		break;

	case TCASE:

		i = 0;

		ccp = evalstr(t->str, DOTILDE | DOSCALAR);

		for (t = t->left; t != NULL && t->type == TPAT; t = t->right) {

			for (ap = (const char **)t->vars; *ap; ap++) {

				if (i || ((s = evalstr(*ap, DOTILDE|DOPAT)) &&

				    gmatchx(ccp, s, false))) {

					record_match(ccp);

					rv = execute(t->left, flags & XERROK,

					    xerrok);

					i = 0;

					switch (t->u.charflag) {

					case '&':

						i = 1;

						/* FALLTHROUGH */

					case '|':

						goto TCASE_next;

					}

					goto TCASE_out;

				}

			}

			i = 0;

 TCASE_next:

			/* empty */;

		}

 TCASE_out:

		break;

	case TBRACE:

		rv = execute(t->left, flags & XERROK, xerrok);

		break;

	case TFUNCT:

		rv = define(t->str, t);

		break;

	case TTIME:

		/*

		 * Clear XEXEC so nested execute() call doesn't exit

		 * (allows "ls -l | time grep foo").

		 */

		rv = timex(t, flags & ~XEXEC, xerrok);

		break;

	case TEXEC:

		/* an eval'd TCOM */

		up = makenv();

		restoresigs();

		cleanup_proc_env();

		{

			union mksh_ccphack cargs;

			cargs.ro = t->args;

			execve(t->str, cargs.rw, up);

			rv = errno;

		}

		if (rv == ENOEXEC)

			scriptexec(t, (const char **)up);

		else

			errorf(Tf_sD_s, t->str, cstrerror(rv));

	}

 Break:

	exstat = rv & 0xFF;

	if (vp_pipest->flag & INT_L) {

		unset(vp_pipest, 1);

		vp_pipest->flag = DEFINED | ISSET | INTEGER | RDONLY |

		    ARRAY | INT_U | INT_L;

		vp_pipest->val.i = rv;

	}

	/* restores IO */

	quitenv(NULL);

	if ((flags&XEXEC))

		/* exit child */

		unwind(LEXIT);

	if (rv != 0 && !(flags & XERROK) &&

	    (xerrok == NULL || !*xerrok)) {

		if (Flag(FERREXIT) & 0x80) {

			/* inside eval */

			Flag(FERREXIT) = 0;

		} else {

			trapsig(ksh_SIGERR);

			if (Flag(FERREXIT))

				unwind(LERROR);

		}

	}

	return (rv);

}

/*

 * execute simple command

 */

static int

comexec(struct op *t, struct tbl * volatile tp, const char **ap,

    volatile int flags, volatile int *xerrok)

{

	int i;

	volatile int rv = 0;

	const char *cp;

	const char **lastp;

	/* Must be static (XXX but why?) */

	static struct op texec;

	int type_flags;

	bool resetspec;

	int fcflags = FC_BI|FC_FUNC|FC_PATH;

	struct block *l_expand, *l_assign;

	int optc;

	const char *exec_argv0 = NULL;

	bool exec_clrenv = false;

	/* snag the last argument for $_ */

	if (Flag(FTALKING) && *(lastp = ap)) {

		/*

		 * XXX not the same as AT&T ksh, which only seems to set $_

		 * after a newline (but not in functions/dot scripts, but in

		 * interactive and script) - perhaps save last arg here and

		 * set it in shell()?.

		 */

		while (*++lastp)

			;

		/* setstr() can't fail here */

		setstr(typeset("_", LOCAL, 0, INTEGER, 0), *--lastp,

		    KSH_RETURN_ERROR);

	}

	/**

	 * Deal with the shell builtins builtin, exec and command since

	 * they can be followed by other commands. This must be done before

	 * we know if we should create a local block which must be done

	 * before we can do a path search (in case the assignments change

	 * PATH).

	 * Odd cases:

	 *	FOO=bar exec >/dev/null		FOO is kept but not exported

	 *	FOO=bar exec foobar		FOO is exported

	 *	FOO=bar command exec >/dev/null	FOO is neither kept nor exported

	 *	FOO=bar command			FOO is neither kept nor exported

	 *	PATH=... foobar			use new PATH in foobar search

	 */

	resetspec = false;

	while (tp && tp->type == CSHELL) {

		/* undo effects of command */

		fcflags = FC_BI|FC_FUNC|FC_PATH;

		if (tp->val.f == c_builtin) {

			if ((cp = *++ap) == NULL ||

			    (!strcmp(cp, "--") && (cp = *++ap) == NULL)) {

				tp = NULL;

				break;

			}

			if ((tp = findcom(cp, FC_BI)) == NULL)

				errorf(Tf_sD_sD_s, Tbuiltin, cp, Tnot_found);

			if (tp->type == CSHELL && (tp->flag & LOW_BI))

				break;

			continue;

		} else if (tp->val.f == c_exec) {

			if (ap[1] == NULL)

				break;

			ksh_getopt_reset(&builtin_opt, GF_ERROR);

			while ((optc = ksh_getopt(ap, &builtin_opt, "a:c")) != -1)

				switch (optc) {

				case 'a':

					exec_argv0 = builtin_opt.optarg;

					break;

				case 'c':

					exec_clrenv = true;

					/* ensure we can actually do this */

					resetspec = true;

					break;

				default:

					rv = 2;

					goto Leave;

				}

			ap += builtin_opt.optind;

			flags |= XEXEC;

			/* POSuX demands ksh88-like behaviour here */

			if (Flag(FPOSIX))

				fcflags = FC_PATH;

		} else if (tp->val.f == c_command) {

			bool saw_p = false;

			/*

			 * Ugly dealing with options in two places (here

			 * and in c_command(), but such is life)

			 */

			ksh_getopt_reset(&builtin_opt, 0);

			while ((optc = ksh_getopt(ap, &builtin_opt, ":p")) == 'p')

				saw_p = true;

			if (optc != -1)

				/* command -vV or something */

				break;

			/* don't look for functions */

			fcflags = FC_BI|FC_PATH;

			if (saw_p) {

				if (Flag(FRESTRICTED)) {

					warningf(true, Tf_sD_s,

					    "command -p", "restricted");

					rv = 1;

					goto Leave;

				}

				fcflags |= FC_DEFPATH;

			}

			ap += builtin_opt.optind;

			/*

			 * POSIX says special builtins lose their status

			 * if accessed using command.

			 */

			resetspec = true;

			if (!ap[0]) {

				/* ensure command with no args exits with 0 */

				subst_exstat = 0;

				break;

			}

		} else if (tp->flag & LOW_BI) {

			/* if we have any flags, do not use the builtin */

			if ((ap[1] && ap[1][0] == '-' && ap[1][1] != '\0' &&

			    /* argument, begins with -, is not - or -- */

			    (ap[1][1] != '-' || ap[1][2] != '\0')) ||

			    /* always prefer the external utility */

			    (tp->flag & LOWER_BI)) {

				struct tbl *ext_cmd;

				ext_cmd = findcom(tp->name, FC_PATH | FC_FUNC);

				if (ext_cmd && (ext_cmd->type != CTALIAS ||

				    (ext_cmd->flag & ISSET)))

					tp = ext_cmd;

			}

			break;

		} else if (tp->val.f == c_trap) {

			t->u.evalflags &= ~DOTCOMEXEC;

			break;

		} else

			break;

		tp = findcom(ap[0], fcflags & (FC_BI|FC_FUNC));

	}

	if (t->u.evalflags & DOTCOMEXEC)

		flags |= XEXEC;

	l_expand = e->loc;

	if (!resetspec && (!ap[0] || (tp && (tp->flag & KEEPASN))))

		type_flags = 0;

	else {

		/* create new variable/function block */

		newblock();

		/* ksh functions don't keep assignments, POSIX functions do. */

		if (!resetspec && tp && tp->type == CFUNC &&

		    !(tp->flag & FKSH))

			type_flags = EXPORT;

		else

			type_flags = LOCAL|LOCAL_COPY|EXPORT;

	}

	l_assign = e->loc;

	if (exec_clrenv)

		l_assign->flags |= BF_STOPENV;

	if (Flag(FEXPORT))

		type_flags |= EXPORT;

	if (Flag(FXTRACE))

		change_xtrace(2, false);

	for (i = 0; t->vars[i]; i++) {

		/* do NOT lookup in the new var/fn block just created */

		e->loc = l_expand;

		cp = evalstr(t->vars[i], DOASNTILDE | DOSCALAR);

		e->loc = l_assign;

		if (Flag(FXTRACE)) {

			const char *ccp;

			ccp = skip_varname(cp, true);

			if (*ccp == '+')

				++ccp;

			if (*ccp == '=')

				++ccp;

			shf_write(cp, ccp - cp, shl_xtrace);

			print_value_quoted(shl_xtrace, ccp);

			shf_putc(' ', shl_xtrace);

		}

		/* but assign in there as usual */

		typeset(cp, type_flags, 0, 0, 0);

	}

	if (Flag(FXTRACE)) {

		change_xtrace(2, false);

		if (ap[rv = 0]) {

 xtrace_ap_loop:

			print_value_quoted(shl_xtrace, ap[rv]);

			if (ap[++rv]) {

				shf_putc(' ', shl_xtrace);

				goto xtrace_ap_loop;

			}

		}

		change_xtrace(1, false);

	}

	if ((cp = *ap) == NULL) {

		rv = subst_exstat;

		goto Leave;

	} else if (!tp) {

		if (Flag(FRESTRICTED) && mksh_vdirsep(cp)) {

			warningf(true, Tf_sD_s, cp, "restricted");

			rv = 1;

			goto Leave;

		}

		tp = findcom(cp, fcflags);

	}

	switch (tp->type) {

	/* shell built-in */

	case CSHELL:

 do_call_builtin:

		rv = call_builtin(tp, (const char **)ap, null, resetspec);

		if (resetspec && tp->val.f == c_shift) {

			l_expand->argc = l_assign->argc;

			l_expand->argv = l_assign->argv;

		}

		break;

	/* function call */

	case CFUNC: {

		volatile uint32_t old_inuse;

		const char * volatile old_kshname;

		volatile uint8_t old_flags[FNFLAGS];

		if (!(tp->flag & ISSET)) {

			struct tbl *ftp;

			if (!tp->u.fpath) {

 fpath_error:

				rv = (tp->u2.errnov == ENOENT) ? 127 : 126;

				warningf(true, Tf_sD_s_sD_s, cp,

				    Tcant_find, Tfile_fd,

				    cstrerror(tp->u2.errnov));

				break;

			}

			errno = 0;

			if (include(tp->u.fpath, 0, NULL, false) < 0 ||

			    !(ftp = findfunc(cp, hash(cp), false)) ||

			    !(ftp->flag & ISSET)) {

				rv = errno;

				if ((ftp = findcom(cp, FC_BI)) &&

				    (ftp->type == CSHELL) &&

				    (ftp->flag & LOW_BI)) {

					tp = ftp;

					goto do_call_builtin;

				}

				if (rv) {

					tp->u2.errnov = rv;

					cp = tp->u.fpath;

					goto fpath_error;

				}

				warningf(true, Tf_sD_s_s, cp,

				    "function not defined by", tp->u.fpath);

				rv = 127;

				break;

			}

			tp = ftp;

		}

		/*

		 * ksh functions set $0 to function name, POSIX

		 * functions leave $0 unchanged.

		 */

		old_kshname = kshname;

		if (tp->flag & FKSH)

			kshname = ap[0];

		else

			ap[0] = kshname;

		e->loc->argv = ap;

		for (i = 0; *ap++ != NULL; i++)

			;

		e->loc->argc = i - 1;

		/*

		 * ksh-style functions handle getopts sanely,

		 * Bourne/POSIX functions are insane...

		 */

		if (tp->flag & FKSH) {

			e->loc->flags |= BF_DOGETOPTS;

			e->loc->getopts_state = user_opt;

			getopts_reset(1);

		}

		for (type_flags = 0; type_flags < FNFLAGS; ++type_flags)

			old_flags[type_flags] = shell_flags[type_flags];

		change_xtrace((Flag(FXTRACEREC) ? Flag(FXTRACE) : 0) |

		    ((tp->flag & TRACE) ? 1 : 0), false);

		old_inuse = tp->flag & FINUSE;

		tp->flag |= FINUSE;

		e->type = E_FUNC;

		if (!(i = kshsetjmp(e->jbuf))) {

			execute(tp->val.t, flags & XERROK, NULL);

			i = LRETURN;

		}

		kshname = old_kshname;

		change_xtrace(old_flags[(int)FXTRACE], false);

#ifndef MKSH_LEGACY_MODE

		if (tp->flag & FKSH) {

			/* Korn style functions restore Flags on return */

			old_flags[(int)FXTRACE] = Flag(FXTRACE);

			for (type_flags = 0; type_flags < FNFLAGS; ++type_flags)

				shell_flags[type_flags] = old_flags[type_flags];

		}

#endif

		tp->flag = (tp->flag & ~FINUSE) | old_inuse;

		/*

		 * Were we deleted while executing? If so, free the

		 * execution tree.

		 */

		if ((tp->flag & (FDELETE|FINUSE)) == FDELETE) {

			if (tp->flag & ALLOC) {

				tp->flag &= ~ALLOC;

				tfree(tp->val.t, tp->areap);

			}

			tp->flag = 0;

		}

		switch (i) {

		case LRETURN:

		case LERROR:

			rv = exstat & 0xFF;

			break;

		case LINTR:

		case LEXIT:

		case LLEAVE:

		case LSHELL:

			quitenv(NULL);

			unwind(i);

			/* NOTREACHED */

		default:

			quitenv(NULL);

			internal_errorf(Tunexpected_type, Tunwind, Tfunction, i);

		}

		break;

	}

	/* executable command */

	case CEXEC:

	/* tracked alias */

	case CTALIAS:

		if (!(tp->flag&ISSET)) {

			if (tp->u2.errnov == ENOENT) {

				rv = 127;

				warningf(true, Tf_sD_s, cp, Tnot_found);

			} else {

				rv = 126;

				warningf(true, Tf_sD_sD_s, cp, "can't execute",

				    cstrerror(tp->u2.errnov));

			}

			break;

		}

		/* set $_ to program's full path */

		/* setstr() can't fail here */

		setstr(typeset("_", LOCAL | EXPORT, 0, INTEGER, 0),

		    tp->val.s, KSH_RETURN_ERROR);

		/* to fork, we set up a TEXEC node and call execute */

		texec.type = TEXEC;

		/* for vistree/dumptree */

		texec.left = t;

		texec.str = tp->val.s;

		texec.args = ap;

		/* in this case we do not fork, of course */

		if (flags & XEXEC) {

			if (exec_argv0)

				texec.args[0] = exec_argv0;

			j_exit();

			if (!(flags & XBGND)

#ifndef MKSH_UNEMPLOYED

			    || Flag(FMONITOR)

#endif

			    ) {

				setexecsig(&sigtraps[SIGINT], SS_RESTORE_ORIG);

				setexecsig(&sigtraps[SIGQUIT], SS_RESTORE_ORIG);

			}

		}

		rv = exchild(&texec, flags, xerrok, -1);

		break;

	}

 Leave:

	if (flags & XEXEC) {

		exstat = rv & 0xFF;

		unwind(LLEAVE);

	}

	return (rv);

}

static void

scriptexec(struct op *tp, const char **ap)

{

	const char *sh;

#ifndef MKSH_SMALL

	int fd;

	unsigned char buf[68];

#endif

	union mksh_ccphack args, cap;

	sh = str_val(global(TEXECSHELL));