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

/*	$OpenBSD: tty.c,v 1.10 2014/08/10 02:44:26 guenther Exp $	*/

/*	$OpenBSD: io.c,v 1.26 2015/09/11 08:00:27 guenther Exp $	*/

/*	$OpenBSD: table.c,v 1.16 2015/09/01 13:12:31 tedu Exp $	*/

/*-

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

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

 *	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.

 */

#define EXTERN

#include "sh.h"

#if HAVE_LANGINFO_CODESET

#include <langinfo.h>

#endif

#if HAVE_SETLOCALE_CTYPE

#include <locale.h>

#endif

__RCSID("$MirOS: src/bin/mksh/main.c,v 1.347 2018/01/13 21:45:07 tg Exp $");

#ifndef MKSHRC_PATH

#define MKSHRC_PATH	"~/.mkshrc"

#endif

#ifndef MKSH_DEFAULT_TMPDIR

#define MKSH_DEFAULT_TMPDIR	MKSH_UNIXROOT "/tmp"

#endif

static uint8_t isuc(const char *);

static int main_init(int, const char *[], Source **, struct block **);

void chvt_reinit(void);

static void reclaim(void);

static void remove_temps(struct temp *);

static mksh_uari_t rndsetup(void);

static void init_environ(void);

#ifdef SIGWINCH

static void x_sigwinch(int);

#endif

static const char initsubs[] =

    "${PS2=> }"

    "${PS3=#? }"

    "${PS4=+ }"

    "${SECONDS=0}"

    "${TMOUT=0}"

    "${EPOCHREALTIME=}";

static const char *initcoms[] = {

	Ttypeset, "-r", initvsn, NULL,

	Ttypeset, "-x", "HOME", TPATH, TSHELL, NULL,

	Ttypeset, "-i10", "COLUMNS", "LINES", "SECONDS", "TMOUT", NULL,

	Talias,

	"integer=\\\\builtin typeset -i",

	"local=\\\\builtin typeset",

	/* not "alias -t --": hash -r needs to work */

	"hash=\\\\builtin alias -t",

	"type=\\\\builtin whence -v",

	"autoload=\\\\builtin typeset -fu",

	"functions=\\\\builtin typeset -f",

	"history=\\\\builtin fc -l",

	"nameref=\\\\builtin typeset -n",

	"nohup=nohup ",

	"r=\\\\builtin fc -e -",

	"login=\\\\builtin exec login",

	NULL,

	 /* this is what AT&T ksh seems to track, with the addition of emacs */

	Talias, "-tU",

	Tcat, "cc", "chmod", "cp", "date", "ed", "emacs", "grep", "ls",

	"make", "mv", "pr", "rm", "sed", Tsh, "vi", "who", NULL,

	NULL

};

static const char *restr_com[] = {

	Ttypeset, "-r", TPATH, "ENV", TSHELL, NULL

};

static bool initio_done;

/* top-level parsing and execution environment */

static struct env env;

struct env *e = &env;

/* compile-time assertions */

#define cta(name, expr) struct cta_ ## name { char t[(expr) ? 1 : -1]; }

/* this one should be defined by the standard */

cta(char_is_1_char, (sizeof(char) == 1) && (sizeof(signed char) == 1) &&

    (sizeof(unsigned char) == 1));

cta(char_is_8_bits, ((CHAR_BIT) == 8) && ((int)(unsigned char)0xFF == 0xFF) &&

    ((int)(unsigned char)0x100 == 0) && ((int)(unsigned char)(int)-1 == 0xFF));

/* the next assertion is probably not really needed */

cta(short_is_2_char, sizeof(short) == 2);

cta(short_size_no_matter_of_signedness, sizeof(short) == sizeof(unsigned short));

/* the next assertion is probably not really needed */

cta(int_is_4_char, sizeof(int) == 4);

cta(int_size_no_matter_of_signedness, sizeof(int) == sizeof(unsigned int));

cta(long_ge_int, sizeof(long) >= sizeof(int));

cta(long_size_no_matter_of_signedness, sizeof(long) == sizeof(unsigned long));

#ifndef MKSH_LEGACY_MODE

/* the next assertion is probably not really needed */

cta(ari_is_4_char, sizeof(mksh_ari_t) == 4);

/* but this is */

cta(ari_has_31_bit, 0 < (mksh_ari_t)(((((mksh_ari_t)1 << 15) << 15) - 1) * 2 + 1));

/* the next assertion is probably not really needed */

cta(uari_is_4_char, sizeof(mksh_uari_t) == 4);

/* but the next three are; we REQUIRE unsigned integer wraparound */

cta(uari_has_31_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 2 + 1));

cta(uari_has_32_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 3));

cta(uari_wrap_32_bit,

    (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 3) >

    (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 4));

#endif

/* these are always required */

cta(ari_is_signed, (mksh_ari_t)-1 < (mksh_ari_t)0);

cta(uari_is_unsigned, (mksh_uari_t)-1 > (mksh_uari_t)0);

/* we require these to have the precisely same size and assume 2s complement */

cta(ari_size_no_matter_of_signedness, sizeof(mksh_ari_t) == sizeof(mksh_uari_t));

cta(sizet_size_no_matter_of_signedness, sizeof(ssize_t) == sizeof(size_t));

cta(sizet_voidptr_same_size, sizeof(size_t) == sizeof(void *));

cta(sizet_funcptr_same_size, sizeof(size_t) == sizeof(void (*)(void)));

/* our formatting routines assume this */

cta(ptr_fits_in_long, sizeof(size_t) <= sizeof(long));

cta(ari_fits_in_long, sizeof(mksh_ari_t) <= sizeof(long));

static mksh_uari_t

rndsetup(void)

{

	register uint32_t h;

	struct {

		ALLOC_ITEM alloc_INT;

		void *dataptr, *stkptr, *mallocptr;

#if defined(__GLIBC__) && (__GLIBC__ >= 2)

		sigjmp_buf jbuf;

#endif

		struct timeval tv;

	} *bufptr;

	char *cp;

	cp = alloc(sizeof(*bufptr) - sizeof(ALLOC_ITEM), APERM);

	/* clear the allocated space, for valgrind and to avoid UB */

	memset(cp, 0, sizeof(*bufptr) - sizeof(ALLOC_ITEM));

	/* undo what alloc() did to the malloc result address */

	bufptr = (void *)(cp - sizeof(ALLOC_ITEM));

	/* PIE or something similar provides us with deltas here */

	bufptr->dataptr = &rndsetupstate;

	/* ASLR in at least Windows, Linux, some BSDs */

	bufptr->stkptr = &bufptr;

	/* randomised malloc in BSD (and possibly others) */

	bufptr->mallocptr = bufptr;

#if defined(__GLIBC__) && (__GLIBC__ >= 2)

	/* glibc pointer guard */

	sigsetjmp(bufptr->jbuf, 1);

#endif

	/* introduce variation (and yes, second arg MBZ for portability) */

	mksh_TIME(bufptr->tv);

#ifdef MKSH_ALLOC_CATCH_UNDERRUNS

	mprotect(((char *)bufptr) + 4096, 4096, PROT_READ | PROT_WRITE);

#endif

	h = chvt_rndsetup(bufptr, sizeof(*bufptr));

	afree(cp, APERM);

	return ((mksh_uari_t)h);

}

void

chvt_reinit(void)

{

	kshpid = procpid = getpid();

	ksheuid = geteuid();

	kshpgrp = getpgrp();

	kshppid = getppid();

}

static const char *empty_argv[] = {

	Tmksh, NULL

};

static uint8_t

isuc(const char *cx) {

	char *cp, *x;

	uint8_t rv = 0;

	if (!cx || !*cx)

		return (0);

	/* uppercase a string duplicate */

	strdupx(x, cx, ATEMP);

	cp = x;

	while ((*cp = ksh_toupper(*cp)))

		++cp;

	/* check for UTF-8 */

	if (strstr(x, "UTF-8") || strstr(x, "UTF8"))

		rv = 1;

	/* free copy and out */

	afree(x, ATEMP);

	return (rv);

}

static int

main_init(int argc, const char *argv[], Source **sp, struct block **lp)

{

	int argi, i;

	Source *s = NULL;

	struct block *l;

	unsigned char restricted_shell, errexit, utf_flag;

	char *cp;

	const char *ccp, **wp;

	struct tbl *vp;

	struct stat s_stdin;

#if !defined(_PATH_DEFPATH) && defined(_CS_PATH)

	ssize_t k;

#endif

#if defined(MKSH_EBCDIC) || defined(MKSH_FAUX_EBCDIC)

	ebcdic_init();

#endif

	set_ifs(TC_IFSWS);

#ifdef __OS2__

	os2_init(&argc, &argv);

#endif

	/* do things like getpgrp() et al. */

	chvt_reinit();

	/* make sure argv[] is sane, for weird OSes */

	if (!*argv) {

		argv = empty_argv;

		argc = 1;

	}

	kshname = argv[0];

	/* initialise permanent Area */

	ainit(&aperm);

	/* max. name length: -2147483648 = 11 (+ NUL) */

	vtemp = alloc(offsetof(struct tbl, name[0]) + 12, APERM);

	/* set up base environment */

	env.type = E_NONE;

	ainit(&env.area);

	/* set up global l->vars and l->funs */

	newblock();

	/* Do this first so output routines (eg, errorf, shellf) can work */

	initio();

	/* determine the basename (without '-' or path) of the executable */

	ccp = kshname;

	goto begin_parsing_kshname;

	while ((i = ccp[argi++])) {

		if (mksh_cdirsep(i)) {

			ccp += argi;

 begin_parsing_kshname:

			argi = 0;

			if (*ccp == '-')

				++ccp;

		}

	}

	if (!*ccp)

		ccp = empty_argv[0];

	/*

	 * Turn on nohup by default. (AT&T ksh does not have a nohup

	 * option - it always sends the hup).

	 */

	Flag(FNOHUP) = 1;

	/*

	 * Turn on brace expansion by default. AT&T kshs that have

	 * alternation always have it on.

	 */

	Flag(FBRACEEXPAND) = 1;

	/*

	 * Turn on "set -x" inheritance by default.

	 */

	Flag(FXTRACEREC) = 1;

	/* define built-in commands and see if we were called as one */

	ktinit(APERM, &builtins,

	    /* currently up to 54 builtins: 75% of 128 = 2^7 */

	    7);

	for (i = 0; mkshbuiltins[i].name != NULL; i++)

		if (!strcmp(ccp, builtin(mkshbuiltins[i].name,

		    mkshbuiltins[i].func)))

			Flag(FAS_BUILTIN) = 1;

	if (!Flag(FAS_BUILTIN)) {

		/* check for -T option early */

		argi = parse_args(argv, OF_FIRSTTIME, NULL);

		if (argi < 0)

			return (1);

#if defined(MKSH_BINSHPOSIX) || defined(MKSH_BINSHREDUCED)

		/* are we called as -sh or /bin/sh or so? */

		if (!strcmp(ccp, "sh" MKSH_EXE_EXT)) {

			/* either also turns off braceexpand */

#ifdef MKSH_BINSHPOSIX

			/* enable better POSIX conformance */

			change_flag(FPOSIX, OF_FIRSTTIME, true);

#endif

#ifdef MKSH_BINSHREDUCED

			/* enable kludge/compat mode */

			change_flag(FSH, OF_FIRSTTIME, true);

#endif

		}

#endif

	}

	initvar();

	inittraps();

	coproc_init();

	/* set up variable and command dictionaries */

	ktinit(APERM, &taliases, 0);

	ktinit(APERM, &aliases, 0);

#ifndef MKSH_NOPWNAM

	ktinit(APERM, &homedirs, 0);

#endif

	/* define shell keywords */

	initkeywords();

	init_histvec();

	/* initialise tty size before importing environment */

	change_winsz();

#ifdef _PATH_DEFPATH

	def_path = _PATH_DEFPATH;

#else

#ifdef _CS_PATH

	if ((k = confstr(_CS_PATH, NULL, 0)) > 0 &&

	    confstr(_CS_PATH, cp = alloc(k + 1, APERM), k + 1) == k + 1)

		def_path = cp;

	else

#endif

		/*

		 * this is uniform across all OSes unless it

		 * breaks somewhere hard; don't try to optimise,

		 * e.g. add stuff for Interix or remove /usr

		 * for HURD, because e.g. Debian GNU/HURD is

		 * "keeping a regular /usr"; this is supposed

		 * to be a sane 'basic' default PATH

		 */

		def_path = MKSH_UNIXROOT "/bin" MKSH_PATHSEPS

		    MKSH_UNIXROOT "/usr/bin" MKSH_PATHSEPS

		    MKSH_UNIXROOT "/sbin" MKSH_PATHSEPS

		    MKSH_UNIXROOT "/usr/sbin";

#endif

	/*

	 * Set PATH to def_path (will set the path global variable).

	 * (import of environment below will probably change this setting).

	 */

	vp = global(TPATH);

	/* setstr can't fail here */

	setstr(vp, def_path, KSH_RETURN_ERROR);

#ifndef MKSH_NO_CMDLINE_EDITING

	/*

	 * Set edit mode to emacs by default, may be overridden

	 * by the environment or the user. Also, we want tab completion

	 * on in vi by default.

	 */

	change_flag(FEMACS, OF_SPECIAL, true);

#if !MKSH_S_NOVI

	Flag(FVITABCOMPLETE) = 1;

#endif

#endif

	/* import environment */

	init_environ();

	/* for security */

	typeset(TinitIFS, 0, 0, 0, 0);

	/* assign default shell variable values */

	typeset("PATHSEP=" MKSH_PATHSEPS, 0, 0, 0, 0);

	substitute(initsubs, 0);

	/* Figure out the current working directory and set $PWD */

	vp = global(TPWD);

	cp = str_val(vp);

	/* Try to use existing $PWD if it is valid */

	set_current_wd((mksh_abspath(cp) && test_eval(NULL, TO_FILEQ, cp,

	    Tdot, true)) ? cp : NULL);

	if (current_wd[0])

		simplify_path(current_wd);

	/* Only set pwd if we know where we are or if it had a bogus value */

	if (current_wd[0] || *cp)

		/* setstr can't fail here */

		setstr(vp, current_wd, KSH_RETURN_ERROR);

	for (wp = initcoms; *wp != NULL; wp++) {

		c_builtin(wp);

		while (*wp != NULL)

			wp++;

	}

	setint_n(global("OPTIND"), 1, 10);

	kshuid = getuid();

	kshgid = getgid();

	kshegid = getegid();

	safe_prompt = ksheuid ? "$ " : "# ";

	vp = global("PS1");

	/* Set PS1 if unset or we are root and prompt doesn't contain a # */

	if (!(vp->flag & ISSET) ||

	    (!ksheuid && !strchr(str_val(vp), '#')))

		/* setstr can't fail here */

		setstr(vp, safe_prompt, KSH_RETURN_ERROR);

	setint_n((vp = global("BASHPID")), 0, 10);

	vp->flag |= INT_U;

	setint_n((vp = global("PGRP")), (mksh_uari_t)kshpgrp, 10);

	vp->flag |= INT_U;

	setint_n((vp = global("PPID")), (mksh_uari_t)kshppid, 10);

	vp->flag |= INT_U;

	setint_n((vp = global("USER_ID")), (mksh_uari_t)ksheuid, 10);

	vp->flag |= INT_U;

	setint_n((vp = global("KSHUID")), (mksh_uari_t)kshuid, 10);

	vp->flag |= INT_U;

	setint_n((vp = global("KSHEGID")), (mksh_uari_t)kshegid, 10);

	vp->flag |= INT_U;

	setint_n((vp = global("KSHGID")), (mksh_uari_t)kshgid, 10);

	vp->flag |= INT_U;

	setint_n((vp = global("RANDOM")), rndsetup(), 10);

	vp->flag |= INT_U;

	setint_n((vp_pipest = global("PIPESTATUS")), 0, 10);

	/* Set this before parsing arguments */

	Flag(FPRIVILEGED) = (kshuid != ksheuid || kshgid != kshegid) ? 2 : 0;

	/* this to note if monitor is set on command line (see below) */

#ifndef MKSH_UNEMPLOYED

	Flag(FMONITOR) = 127;

#endif

	/* this to note if utf-8 mode is set on command line (see below) */

	UTFMODE = 2;

	if (!Flag(FAS_BUILTIN)) {

		argi = parse_args(argv, OF_CMDLINE, NULL);

		if (argi < 0)

			return (1);

	}

	/* process this later only, default to off (hysterical raisins) */

	utf_flag = UTFMODE;

	UTFMODE = 0;

	if (Flag(FAS_BUILTIN)) {

		/* auto-detect from environment variables, always */

		utf_flag = 3;

	} else if (Flag(FCOMMAND)) {

		s = pushs(SSTRINGCMDLINE, ATEMP);

		if (!(s->start = s->str = argv[argi++]))

			errorf(Tf_optfoo, "", "", 'c', Treq_arg);

		while (*s->str) {

			if (ctype(*s->str, C_QUOTE))

				break;

			s->str++;

		}

		if (!*s->str)

			s->flags |= SF_MAYEXEC;

		s->str = s->start;

#ifdef MKSH_MIDNIGHTBSD01ASH_COMPAT

		/* compatibility to MidnightBSD 0.1 /bin/sh (kludge) */

		if (Flag(FSH) && argv[argi] && !strcmp(argv[argi], "--"))

			++argi;

#endif

		if (argv[argi])

			kshname = argv[argi++];

	} else if (argi < argc && !Flag(FSTDIN)) {

		s = pushs(SFILE, ATEMP);

#ifdef __OS2__

		/*

		 * A bug in OS/2 extproc (like shebang) handling makes

		 * it not pass the full pathname of a script, so we need

		 * to search for it. This changes the behaviour of a

		 * simple "mksh foo", but can't be helped.

		 */

		s->file = argv[argi++];

		if (search_access(s->file, X_OK) != 0)

			s->file = search_path(s->file, path, X_OK, NULL);

		if (!s->file || !*s->file)

			s->file = argv[argi - 1];

#else

		s->file = argv[argi++];

#endif

		s->u.shf = shf_open(s->file, O_RDONLY, 0,

		    SHF_MAPHI | SHF_CLEXEC);

		if (s->u.shf == NULL) {

			shl_stdout_ok = false;

			warningf(true, Tf_sD_s, s->file, cstrerror(errno));

			/* mandated by SUSv4 */

			exstat = 127;

			unwind(LERROR);

		}

		kshname = s->file;

	} else {

		Flag(FSTDIN) = 1;

		s = pushs(SSTDIN, ATEMP);

		s->file = "<stdin>";

		s->u.shf = shf_fdopen(0, SHF_RD | can_seek(0),

		    NULL);

		if (isatty(0) && isatty(2)) {

			Flag(FTALKING) = Flag(FTALKING_I) = 1;

			/* The following only if isatty(0) */

			s->flags |= SF_TTY;

			s->u.shf->flags |= SHF_INTERRUPT;

			s->file = NULL;

		}

	}

	/* this bizarreness is mandated by POSIX */

	if (fstat(0, &s_stdin) >= 0 && S_ISCHR(s_stdin.st_mode) &&

	    Flag(FTALKING))

		reset_nonblock(0);

	/* initialise job control */

	j_init();

	/* do this after j_init() which calls tty_init_state() */

	if (Flag(FTALKING)) {

		if (utf_flag == 2) {

#ifndef MKSH_ASSUME_UTF8

			/* auto-detect from locale or environment */

			utf_flag = 4;

#else /* this may not be an #elif */

#if MKSH_ASSUME_UTF8

			utf_flag = 1;

#else

			/* always disable UTF-8 (for interactive) */

			utf_flag = 0;

#endif

#endif

		}

#ifndef MKSH_NO_CMDLINE_EDITING

		x_init();

#endif

	}

#ifdef SIGWINCH

	sigtraps[SIGWINCH].flags |= TF_SHELL_USES;

	setsig(&sigtraps[SIGWINCH], x_sigwinch,

	    SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);

#endif

	l = e->loc;

	if (Flag(FAS_BUILTIN)) {

		l->argc = argc;

		l->argv = argv;

		l->argv[0] = ccp;

	} else {

		l->argc = argc - argi;

		/*

		 * allocate a new array because otherwise, when we modify

		 * it in-place, ps(1) output changes; the meaning of argc

		 * here is slightly different as it excludes kshname, and

		 * we add a trailing NULL sentinel as well

		 */

		l->argv = alloc2(l->argc + 2, sizeof(void *), APERM);

		l->argv[0] = kshname;

		memcpy(&l->argv[1], &argv[argi], l->argc * sizeof(void *));

		l->argv[l->argc + 1] = NULL;

		getopts_reset(1);

	}

	/* divine the initial state of the utf8-mode Flag */

	ccp = null;

	switch (utf_flag) {

	/* auto-detect from locale or environment */

	case 4:

#if HAVE_SETLOCALE_CTYPE

		ccp = setlocale(LC_CTYPE, "");

#if HAVE_LANGINFO_CODESET

		if (!isuc(ccp))

			ccp = nl_langinfo(CODESET);

#endif

		if (!isuc(ccp))

			ccp = null;

#endif

		/* FALLTHROUGH */

	/* auto-detect from environment */

	case 3:

		/* these were imported from environ earlier */

		if (ccp == null)

			ccp = str_val(global("LC_ALL"));

		if (ccp == null)

			ccp = str_val(global("LC_CTYPE"));

		if (ccp == null)

			ccp = str_val(global("LANG"));

		UTFMODE = isuc(ccp);

		break;

	/* not set on command line, not FTALKING */

	case 2:

	/* unknown values */

	default:

		utf_flag = 0;

		/* FALLTHROUGH */

	/* known values */

	case 1:

	case 0:

		UTFMODE = utf_flag;

		break;

	}

	/* Disable during .profile/ENV reading */

	restricted_shell = Flag(FRESTRICTED);

	Flag(FRESTRICTED) = 0;

	errexit = Flag(FERREXIT);

	Flag(FERREXIT) = 0;

	/*

	 * Do this before profile/$ENV so that if it causes problems in them,

	 * user will know why things broke.

	 */

	if (!current_wd[0] && Flag(FTALKING))

		warningf(false, "can't determine current directory");

	if (Flag(FLOGIN))

		include(MKSH_SYSTEM_PROFILE, 0, NULL, true);

	if (!Flag(FPRIVILEGED)) {

		if (Flag(FLOGIN))

			include(substitute("$HOME/.profile", 0), 0, NULL, true);

		if (Flag(FTALKING)) {

			cp = substitute("${ENV:-" MKSHRC_PATH "}", DOTILDE);

			if (cp[0] != '\0')

				include(cp, 0, NULL, true);

		}

	} else {

		include(MKSH_SUID_PROFILE, 0, NULL, true);

		/* turn off -p if not set explicitly */

		if (Flag(FPRIVILEGED) != 1)

			change_flag(FPRIVILEGED, OF_INTERNAL, false);

	}

	if (restricted_shell) {

		c_builtin(restr_com);

		/* After typeset command... */

		Flag(FRESTRICTED) = 1;

	}

	Flag(FERREXIT) = errexit;

	if (Flag(FTALKING) && s)

		hist_init(s);

	else

		/* set after ENV */

		Flag(FTRACKALL) = 1;

	alarm_init();

	*sp = s;

	*lp = l;

	return (0);

}

/* this indirection barrier reduces stack usage during normal operation */

int

main(int argc, const char *argv[])

{

	int rv;

	Source *s;

	struct block *l;

	if ((rv = main_init(argc, argv, &s, &l)) == 0) {

		if (Flag(FAS_BUILTIN)) {

			rv = c_builtin(l->argv);

		} else {

			shell(s, 0);

			/* NOTREACHED */

		}

	}

	return (rv);

}

int

include(const char *name, int argc, const char **argv, bool intr_ok)

{

	Source *volatile s = NULL;

	struct shf *shf;

	const char **volatile old_argv;

	volatile int old_argc;

	int i;

	shf = shf_open(name, O_RDONLY, 0, SHF_MAPHI | SHF_CLEXEC);

	if (shf == NULL)

		return (-1);

	if (argv) {

		old_argv = e->loc->argv;

		old_argc = e->loc->argc;

	} else {

		old_argv = NULL;

		old_argc = 0;

	}

	newenv(E_INCL);

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

		quitenv(s ? s->u.shf : NULL);

		if (old_argv) {

			e->loc->argv = old_argv;

			e->loc->argc = old_argc;

		}

		switch (i) {

		case LRETURN:

		case LERROR:

			/* see below */

			return (exstat & 0xFF);

		case LINTR:

			/*

			 * intr_ok is set if we are including .profile or $ENV.

			 * If user ^Cs out, we don't want to kill the shell...

			 */

			if (intr_ok && ((exstat & 0xFF) - 128) != SIGTERM)

				return (1);

			/* FALLTHROUGH */

		case LEXIT:

		case LLEAVE:

		case LSHELL:

			unwind(i);

			/* NOTREACHED */

		default:

			internal_errorf(Tunexpected_type, Tunwind, Tsource, i);

			/* NOTREACHED */

		}

	}

	if (argv) {

		e->loc->argv = argv;

		e->loc->argc = argc;

	}

	s = pushs(SFILE, ATEMP);

	s->u.shf = shf;

	strdupx(s->file, name, ATEMP);

	i = shell(s, 1);

	quitenv(s->u.shf);

	if (old_argv) {

		e->loc->argv = old_argv;

		e->loc->argc = old_argc;

	}

	/* & 0xff to ensure value not -1 */

	return (i & 0xFF);

}

/* spawn a command into a shell optionally keeping track of the line number */

int

command(const char *comm, int line)

{

	Source *s, *sold = source;

	int rv;

	s = pushs(SSTRING, ATEMP);

	s->start = s->str = comm;

	s->line = line;

	rv = shell(s, 1);

	source = sold;

	return (rv);

}

/*

 * run the commands from the input source, returning status.

 */

int

shell(Source * volatile s, volatile int level)

{

	struct op *t;

	volatile bool wastty = tobool(s->flags & SF_TTY);

	volatile uint8_t attempts = 13;

	volatile bool interactive = (level == 0) && Flag(FTALKING);

	volatile bool sfirst = true;

	Source *volatile old_source = source;

	int i;

	newenv(level == 2 ? E_EVAL : E_PARSE);

	if (interactive)

		really_exit = false;

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

	case 0:

		break;

	case LBREAK:

	case LCONTIN:

		if (level != 2) {

			source = old_source;

			quitenv(NULL);

			internal_errorf(Tf_cant_s, Tshell,

			    i == LBREAK ? Tbreak : Tcontinue);

			/* NOTREACHED */

		}

		/* assert: interactive == false */

		/* FALLTHROUGH */

	case LINTR:

		/* we get here if SIGINT not caught or ignored */

	case LERROR:

	case LSHELL:

		if (interactive) {

			if (i == LINTR)

				shellf("\n");

			/*

			 * Reset any eof that was read as part of a

			 * multiline command.

			 */

			if (Flag(FIGNOREEOF) && s->type == SEOF && wastty)

				s->type = SSTDIN;

			/*

			 * Used by exit command to get back to

			 * top level shell. Kind of strange since

			 * interactive is set if we are reading from

			 * a tty, but to have stopped jobs, one only

			 * needs FMONITOR set (not FTALKING/SF_TTY)...

			 */

			/* toss any input we have so far */

			yyrecursive_pop(true);

			s->start = s->str = null;

			retrace_info = NULL;

			herep = heres;

			break;

		}

		/* FALLTHROUGH */

	case LEXIT:

	case LLEAVE:

	case LRETURN:

		source = old_source;

		quitenv(NULL);

		/* keep on going */

		unwind(i);

		/* NOTREACHED */

	default:

		source = old_source;

		quitenv(NULL);

		internal_errorf(Tunexpected_type, Tunwind, Tshell, i);

		/* NOTREACHED */

	}

	while (/* CONSTCOND */ 1) {

		if (trap)

			runtraps(0);

		if (s->next == NULL) {

			if (Flag(FVERBOSE))

				s->flags |= SF_ECHO;

			else

				s->flags &= ~SF_ECHO;

		}

		if (interactive) {

			j_notify();

			set_prompt(PS1, s);

		}

		t = compile(s, sfirst, true);

		if (interactive)

			histsave(&s->line, NULL, HIST_FLUSH, true);

		sfirst = false;

		if (!t)