1/*	$OpenBSD: exec.c,v 1.50 2013/06/10 21:09:27 millert Exp $	*/
2
3/*-
4 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
5 *		 2011, 2012, 2013, 2014
6 *	Thorsten Glaser <tg@mirbsd.org>
7 *
8 * Provided that these terms and disclaimer and all copyright notices
9 * are retained or reproduced in an accompanying document, permission
10 * is granted to deal in this work without restriction, including un-
11 * limited rights to use, publicly perform, distribute, sell, modify,
12 * merge, give away, or sublicence.
13 *
14 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
15 * the utmost extent permitted by applicable law, neither express nor
16 * implied; without malicious intent or gross negligence. In no event
17 * may a licensor, author or contributor be held liable for indirect,
18 * direct, other damage, loss, or other issues arising in any way out
19 * of dealing in the work, even if advised of the possibility of such
20 * damage or existence of a defect, except proven that it results out
21 * of said person's immediate fault when using the work as intended.
22 */
23
24#include "sh.h"
25
26__RCSID("$MirOS: src/bin/mksh/exec.c,v 1.133 2014/10/03 17:32:11 tg Exp $");
27
28#ifndef MKSH_DEFAULT_EXECSHELL
29#define MKSH_DEFAULT_EXECSHELL	"/bin/sh"
30#endif
31
32static int comexec(struct op *, struct tbl * volatile, const char **,
33    int volatile, volatile int *);
34static void scriptexec(struct op *, const char **) MKSH_A_NORETURN;
35static int call_builtin(struct tbl *, const char **, const char *);
36static int iosetup(struct ioword *, struct tbl *);
37static int herein(struct ioword *, char **);
38static const char *do_selectargs(const char **, bool);
39static Test_op dbteste_isa(Test_env *, Test_meta);
40static const char *dbteste_getopnd(Test_env *, Test_op, bool);
41static void dbteste_error(Test_env *, int, const char *);
42static int search_access(const char *, int);
43/* XXX: horrible kludge to fit within the framework */
44static char *plain_fmt_entry(char *, size_t, unsigned int, const void *);
45static char *select_fmt_entry(char *, size_t, unsigned int, const void *);
46
47/*
48 * execute command tree
49 */
50int
51execute(struct op * volatile t,
52    /* if XEXEC don't fork */
53    volatile int flags,
54    volatile int * volatile xerrok)
55{
56	int i;
57	volatile int rv = 0, dummy = 0;
58	int pv[2];
59	const char ** volatile ap = NULL;
60	char ** volatile up;
61	const char *s, *ccp;
62	struct ioword **iowp;
63	struct tbl *tp = NULL;
64	char *cp;
65
66	if (t == NULL)
67		return (0);
68
69	/* Caller doesn't care if XERROK should propagate. */
70	if (xerrok == NULL)
71		xerrok = &dummy;
72
73	if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)
74		/* run in sub-process */
75		return (exchild(t, flags & ~XTIME, xerrok, -1));
76
77	newenv(E_EXEC);
78	if (trap)
79		runtraps(0);
80
81	/* we want to run an executable, do some variance checks */
82	if (t->type == TCOM) {
83		/* check if this is 'var=<<EOF' */
84		if (
85		    /* we have zero arguments, i.e. no programme to run */
86		    t->args[0] == NULL &&
87		    /* we have exactly one variable assignment */
88		    t->vars[0] != NULL && t->vars[1] == NULL &&
89		    /* we have exactly one I/O redirection */
90		    t->ioact != NULL && t->ioact[0] != NULL &&
91		    t->ioact[1] == NULL &&
92		    /* of type "here document" (or "here string") */
93		    (t->ioact[0]->flag & IOTYPE) == IOHERE &&
94		    /* the variable assignment begins with a valid varname */
95		    (ccp = skip_wdvarname(t->vars[0], true)) != t->vars[0] &&
96		    /* and has no right-hand side (i.e. "varname=") */
97		    ccp[0] == CHAR && ccp[1] == '=' && ccp[2] == EOS &&
98		    /* plus we can have a here document content */
99		    herein(t->ioact[0], &cp) == 0 && cp && *cp) {
100			char *sp = cp, *dp;
101			size_t n = ccp - t->vars[0] + 2, z;
102
103			/* drop redirection (will be garbage collected) */
104			t->ioact = NULL;
105
106			/* set variable to its expanded value */
107			z = strlen(cp) + 1;
108			if (notoktomul(z, 2) || notoktoadd(z * 2, n))
109				internal_errorf(Toomem, (size_t)-1);
110			dp = alloc(z * 2 + n, ATEMP);
111			memcpy(dp, t->vars[0], n);
112			t->vars[0] = dp;
113			dp += n;
114			while (*sp) {
115				*dp++ = QCHAR;
116				*dp++ = *sp++;
117			}
118			*dp = EOS;
119			/* free the expanded value */
120			afree(cp, APERM);
121		}
122
123		/*
124		 * Clear subst_exstat before argument expansion. Used by
125		 * null commands (see comexec() and c_eval()) and by c_set().
126		 */
127		subst_exstat = 0;
128
129		/* for $LINENO */
130		current_lineno = t->lineno;
131
132		/*
133		 * POSIX says expand command words first, then redirections,
134		 * and assignments last..
135		 */
136		up = eval(t->args, t->u.evalflags | DOBLANK | DOGLOB | DOTILDE);
137		if (flags & XTIME)
138			/* Allow option parsing (bizarre, but POSIX) */
139			timex_hook(t, &up);
140		ap = (const char **)up;
141		if (ap[0])
142			tp = findcom(ap[0], FC_BI|FC_FUNC);
143	}
144	flags &= ~XTIME;
145
146	if (t->ioact != NULL || t->type == TPIPE || t->type == TCOPROC) {
147		e->savefd = alloc2(NUFILE, sizeof(short), ATEMP);
148		/* initialise to not redirected */
149		memset(e->savefd, 0, NUFILE * sizeof(short));
150	}
151
152	/* mark for replacement later (unless TPIPE) */
153	vp_pipest->flag |= INT_L;
154
155	/* do redirection, to be restored in quitenv() */
156	if (t->ioact != NULL)
157		for (iowp = t->ioact; *iowp != NULL; iowp++) {
158			if (iosetup(*iowp, tp) < 0) {
159				exstat = rv = 1;
160				/*
161				 * Redirection failures for special commands
162				 * cause (non-interactive) shell to exit.
163				 */
164				if (tp && tp->type == CSHELL &&
165				    (tp->flag & SPEC_BI))
166					errorfz();
167				/* Deal with FERREXIT, quitenv(), etc. */
168				goto Break;
169			}
170		}
171
172	switch (t->type) {
173	case TCOM:
174		rv = comexec(t, tp, (const char **)ap, flags, xerrok);
175		break;
176
177	case TPAREN:
178		rv = execute(t->left, flags | XFORK, xerrok);
179		break;
180
181	case TPIPE:
182		flags |= XFORK;
183		flags &= ~XEXEC;
184		e->savefd[0] = savefd(0);
185		e->savefd[1] = savefd(1);
186		while (t->type == TPIPE) {
187			openpipe(pv);
188			/* stdout of curr */
189			ksh_dup2(pv[1], 1, false);
190			/**
191			 * Let exchild() close pv[0] in child
192			 * (if this isn't done, commands like
193			 *	(: ; cat /etc/termcap) | sleep 1
194			 * will hang forever).
195			 */
196			exchild(t->left, flags | XPIPEO | XCCLOSE,
197			    NULL, pv[0]);
198			/* stdin of next */
199			ksh_dup2(pv[0], 0, false);
200			closepipe(pv);
201			flags |= XPIPEI;
202			t = t->right;
203		}
204		/* stdout of last */
205		restfd(1, e->savefd[1]);
206		/* no need to re-restore this */
207		e->savefd[1] = 0;
208		/* Let exchild() close 0 in parent, after fork, before wait */
209		i = exchild(t, flags | XPCLOSE | XPIPEST, xerrok, 0);
210		if (!(flags&XBGND) && !(flags&XXCOM))
211			rv = i;
212		break;
213
214	case TLIST:
215		while (t->type == TLIST) {
216			execute(t->left, flags & XERROK, NULL);
217			t = t->right;
218		}
219		rv = execute(t, flags & XERROK, xerrok);
220		break;
221
222	case TCOPROC: {
223#ifndef MKSH_NOPROSPECTOFWORK
224		sigset_t omask;
225
226		/*
227		 * Block sigchild as we are using things changed in the
228		 * signal handler
229		 */
230		sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
231		e->type = E_ERRH;
232		if ((i = kshsetjmp(e->jbuf))) {
233			sigprocmask(SIG_SETMASK, &omask, NULL);
234			quitenv(NULL);
235			unwind(i);
236			/* NOTREACHED */
237		}
238#endif
239		/* Already have a (live) co-process? */
240		if (coproc.job && coproc.write >= 0)
241			errorf("coprocess already exists");
242
243		/* Can we re-use the existing co-process pipe? */
244		coproc_cleanup(true);
245
246		/* do this before opening pipes, in case these fail */
247		e->savefd[0] = savefd(0);
248		e->savefd[1] = savefd(1);
249
250		openpipe(pv);
251		if (pv[0] != 0) {
252			ksh_dup2(pv[0], 0, false);
253			close(pv[0]);
254		}
255		coproc.write = pv[1];
256		coproc.job = NULL;
257
258		if (coproc.readw >= 0)
259			ksh_dup2(coproc.readw, 1, false);
260		else {
261			openpipe(pv);
262			coproc.read = pv[0];
263			ksh_dup2(pv[1], 1, false);
264			/* closed before first read */
265			coproc.readw = pv[1];
266			coproc.njobs = 0;
267			/* create new coprocess id */
268			++coproc.id;
269		}
270#ifndef MKSH_NOPROSPECTOFWORK
271		sigprocmask(SIG_SETMASK, &omask, NULL);
272		/* no more need for error handler */
273		e->type = E_EXEC;
274#endif
275
276		/*
277		 * exchild() closes coproc.* in child after fork,
278		 * will also increment coproc.njobs when the
279		 * job is actually created.
280		 */
281		flags &= ~XEXEC;
282		exchild(t->left, flags | XBGND | XFORK | XCOPROC | XCCLOSE,
283		    NULL, coproc.readw);
284		break;
285	}
286
287	case TASYNC:
288		/*
289		 * XXX non-optimal, I think - "(foo &)", forks for (),
290		 * forks again for async... parent should optimise
291		 * this to "foo &"...
292		 */
293		rv = execute(t->left, (flags&~XEXEC)|XBGND|XFORK, xerrok);
294		break;
295
296	case TOR:
297	case TAND:
298		rv = execute(t->left, XERROK, xerrok);
299		if ((rv == 0) == (t->type == TAND))
300			rv = execute(t->right, flags & XERROK, xerrok);
301		else {
302			flags |= XERROK;
303			if (xerrok)
304				*xerrok = 1;
305		}
306		break;
307
308	case TBANG:
309		rv = !execute(t->right, XERROK, xerrok);
310		flags |= XERROK;
311		if (xerrok)
312			*xerrok = 1;
313		break;
314
315	case TDBRACKET: {
316		Test_env te;
317
318		te.flags = TEF_DBRACKET;
319		te.pos.wp = t->args;
320		te.isa = dbteste_isa;
321		te.getopnd = dbteste_getopnd;
322		te.eval = test_eval;
323		te.error = dbteste_error;
324
325		rv = test_parse(&te);
326		break;
327	}
328
329	case TFOR:
330	case TSELECT: {
331		volatile bool is_first = true;
332
333		ap = (t->vars == NULL) ? e->loc->argv + 1 :
334		    (const char **)eval((const char **)t->vars,
335		    DOBLANK | DOGLOB | DOTILDE);
336		e->type = E_LOOP;
337		while ((i = kshsetjmp(e->jbuf))) {
338			if ((e->flags&EF_BRKCONT_PASS) ||
339			    (i != LBREAK && i != LCONTIN)) {
340				quitenv(NULL);
341				unwind(i);
342			} else if (i == LBREAK) {
343				rv = 0;
344				goto Break;
345			}
346		}
347		/* in case of a continue */
348		rv = 0;
349		if (t->type == TFOR) {
350			while (*ap != NULL) {
351				setstr(global(t->str), *ap++, KSH_UNWIND_ERROR);
352				rv = execute(t->left, flags & XERROK, xerrok);
353			}
354		} else {
355			/* TSELECT */
356			for (;;) {
357				if (!(ccp = do_selectargs(ap, is_first))) {
358					rv = 1;
359					break;
360				}
361				is_first = false;
362				setstr(global(t->str), ccp, KSH_UNWIND_ERROR);
363				execute(t->left, flags & XERROK, xerrok);
364			}
365		}
366		break;
367	}
368
369	case TWHILE:
370	case TUNTIL:
371		e->type = E_LOOP;
372		while ((i = kshsetjmp(e->jbuf))) {
373			if ((e->flags&EF_BRKCONT_PASS) ||
374			    (i != LBREAK && i != LCONTIN)) {
375				quitenv(NULL);
376				unwind(i);
377			} else if (i == LBREAK) {
378				rv = 0;
379				goto Break;
380			}
381		}
382		/* in case of a continue */
383		rv = 0;
384		while ((execute(t->left, XERROK, NULL) == 0) ==
385		    (t->type == TWHILE))
386			rv = execute(t->right, flags & XERROK, xerrok);
387		break;
388
389	case TIF:
390	case TELIF:
391		if (t->right == NULL)
392			/* should be error */
393			break;
394		rv = execute(t->left, XERROK, NULL) == 0 ?
395		    execute(t->right->left, flags & XERROK, xerrok) :
396		    execute(t->right->right, flags & XERROK, xerrok);
397		break;
398
399	case TCASE:
400		i = 0;
401		ccp = evalstr(t->str, DOTILDE);
402		for (t = t->left; t != NULL && t->type == TPAT; t = t->right) {
403			for (ap = (const char **)t->vars; *ap; ap++) {
404				if (i || ((s = evalstr(*ap, DOTILDE|DOPAT)) &&
405				    gmatchx(ccp, s, false))) {
406					rv = execute(t->left, flags & XERROK,
407					    xerrok);
408					i = 0;
409					switch (t->u.charflag) {
410					case '&':
411						i = 1;
412						/* FALLTHROUGH */
413					case '|':
414						goto TCASE_next;
415					}
416					goto TCASE_out;
417				}
418			}
419			i = 0;
420 TCASE_next:
421			/* empty */;
422		}
423 TCASE_out:
424		break;
425
426	case TBRACE:
427		rv = execute(t->left, flags & XERROK, xerrok);
428		break;
429
430	case TFUNCT:
431		rv = define(t->str, t);
432		break;
433
434	case TTIME:
435		/*
436		 * Clear XEXEC so nested execute() call doesn't exit
437		 * (allows "ls -l | time grep foo").
438		 */
439		rv = timex(t, flags & ~XEXEC, xerrok);
440		break;
441
442	case TEXEC:
443		/* an eval'd TCOM */
444		s = t->args[0];
445		up = makenv();
446		restoresigs();
447		cleanup_proc_env();
448		{
449			union mksh_ccphack cargs;
450
451			cargs.ro = t->args;
452			execve(t->str, cargs.rw, up);
453			rv = errno;
454		}
455		if (rv == ENOEXEC)
456			scriptexec(t, (const char **)up);
457		else
458			errorf("%s: %s", s, cstrerror(rv));
459	}
460 Break:
461	exstat = rv & 0xFF;
462	if (vp_pipest->flag & INT_L) {
463		unset(vp_pipest, 1);
464		vp_pipest->flag = DEFINED | ISSET | INTEGER | RDONLY |
465		    ARRAY | INT_U | INT_L;
466		vp_pipest->val.i = rv;
467	}
468
469	/* restores IO */
470	quitenv(NULL);
471	if ((flags&XEXEC))
472		/* exit child */
473		unwind(LEXIT);
474	if (rv != 0 && !(flags & XERROK) &&
475	    (xerrok == NULL || !*xerrok)) {
476		if (Flag(FERREXIT) & 0x80) {
477			/* inside eval */
478			Flag(FERREXIT) = 0;
479		} else {
480			trapsig(ksh_SIGERR);
481			if (Flag(FERREXIT))
482				unwind(LERROR);
483		}
484	}
485	return (rv);
486}
487
488/*
489 * execute simple command
490 */
491
492static int
493comexec(struct op *t, struct tbl * volatile tp, const char **ap,
494    volatile int flags, volatile int *xerrok)
495{
496	int i;
497	volatile int rv = 0;
498	const char *cp;
499	const char **lastp;
500	/* Must be static (XXX but why?) */
501	static struct op texec;
502	int type_flags;
503	bool keepasn_ok;
504	int fcflags = FC_BI|FC_FUNC|FC_PATH;
505	bool bourne_function_call = false;
506	struct block *l_expand, *l_assign;
507
508	/*
509	 * snag the last argument for $_ XXX not the same as AT&T ksh,
510	 * which only seems to set $_ after a newline (but not in
511	 * functions/dot scripts, but in interactive and script) -
512	 * perhaps save last arg here and set it in shell()?.
513	 */
514	if (Flag(FTALKING) && *(lastp = ap)) {
515		while (*++lastp)
516			;
517		/* setstr() can't fail here */
518		setstr(typeset("_", LOCAL, 0, INTEGER, 0), *--lastp,
519		    KSH_RETURN_ERROR);
520	}
521
522	/**
523	 * Deal with the shell builtins builtin, exec and command since
524	 * they can be followed by other commands. This must be done before
525	 * we know if we should create a local block which must be done
526	 * before we can do a path search (in case the assignments change
527	 * PATH).
528	 * Odd cases:
529	 *	FOO=bar exec >/dev/null		FOO is kept but not exported
530	 *	FOO=bar exec foobar		FOO is exported
531	 *	FOO=bar command exec >/dev/null	FOO is neither kept nor exported
532	 *	FOO=bar command			FOO is neither kept nor exported
533	 *	PATH=... foobar			use new PATH in foobar search
534	 */
535	keepasn_ok = true;
536	while (tp && tp->type == CSHELL) {
537		/* undo effects of command */
538		fcflags = FC_BI|FC_FUNC|FC_PATH;
539		if (tp->val.f == c_builtin) {
540			if ((cp = *++ap) == NULL ||
541			    (!strcmp(cp, "--") && (cp = *++ap) == NULL)) {
542				tp = NULL;
543				break;
544			}
545			if ((tp = findcom(cp, FC_BI)) == NULL)
546				errorf("%s: %s: %s", Tbuiltin, cp, "not a builtin");
547			continue;
548		} else if (tp->val.f == c_exec) {
549			if (ap[1] == NULL)
550				break;
551			ap++;
552			flags |= XEXEC;
553		} else if (tp->val.f == c_command) {
554			int optc, saw_p = 0;
555
556			/*
557			 * Ugly dealing with options in two places (here
558			 * and in c_command(), but such is life)
559			 */
560			ksh_getopt_reset(&builtin_opt, 0);
561			while ((optc = ksh_getopt(ap, &builtin_opt, ":p")) == 'p')
562				saw_p = 1;
563			if (optc != EOF)
564				/* command -vV or something */
565				break;
566			/* don't look for functions */
567			fcflags = FC_BI|FC_PATH;
568			if (saw_p) {
569				if (Flag(FRESTRICTED)) {
570					warningf(true, "%s: %s",
571					    "command -p", "restricted");
572					rv = 1;
573					goto Leave;
574				}
575				fcflags |= FC_DEFPATH;
576			}
577			ap += builtin_opt.optind;
578			/*
579			 * POSIX says special builtins lose their status
580			 * if accessed using command.
581			 */
582			keepasn_ok = false;
583			if (!ap[0]) {
584				/* ensure command with no args exits with 0 */
585				subst_exstat = 0;
586				break;
587			}
588#ifndef MKSH_NO_EXTERNAL_CAT
589		} else if (tp->val.f == c_cat) {
590			/*
591			 * if we have any flags, do not use the builtin
592			 * in theory, we could allow -u, but that would
593			 * mean to use ksh_getopt here and possibly ad-
594			 * ded complexity and more code and isn't worth
595			 * additional hassle (and the builtin must call
596			 * ksh_getopt already but can't come back here)
597			 */
598			if (ap[1] && ap[1][0] == '-' && ap[1][1] != '\0' &&
599			    /* argument, begins with -, is not - or -- */
600			    (ap[1][1] != '-' || ap[1][2] != '\0'))
601				/* don't look for builtins or functions */
602				fcflags = FC_PATH;
603			else
604				/* go on, use the builtin */
605				break;
606#endif
607		} else if (tp->val.f == c_trap) {
608			t->u.evalflags &= ~DOTCOMEXEC;
609			break;
610		} else
611			break;
612		tp = findcom(ap[0], fcflags & (FC_BI|FC_FUNC));
613	}
614	if (t->u.evalflags & DOTCOMEXEC)
615		flags |= XEXEC;
616	l_expand = e->loc;
617	if (keepasn_ok && (!ap[0] || (tp && (tp->flag & KEEPASN))))
618		type_flags = 0;
619	else {
620		/* create new variable/function block */
621		newblock();
622		/* ksh functions don't keep assignments, POSIX functions do. */
623		if (keepasn_ok && tp && tp->type == CFUNC &&
624		    !(tp->flag & FKSH)) {
625			bourne_function_call = true;
626			type_flags = EXPORT;
627		} else
628			type_flags = LOCAL|LOCAL_COPY|EXPORT;
629	}
630	l_assign = e->loc;
631	if (Flag(FEXPORT))
632		type_flags |= EXPORT;
633	if (Flag(FXTRACE))
634		change_xtrace(2, false);
635	for (i = 0; t->vars[i]; i++) {
636		/* do NOT lookup in the new var/fn block just created */
637		e->loc = l_expand;
638		cp = evalstr(t->vars[i], DOASNTILDE | DOASNFIELD);
639		e->loc = l_assign;
640		if (Flag(FXTRACE)) {
641			const char *ccp;
642
643			ccp = skip_varname(cp, true);
644			if (*ccp == '+')
645				++ccp;
646			if (*ccp == '=')
647				++ccp;
648			shf_write(cp, ccp - cp, shl_xtrace);
649			print_value_quoted(shl_xtrace, ccp);
650			shf_putc(' ', shl_xtrace);
651		}
652		/* but assign in there as usual */
653		typeset(cp, type_flags, 0, 0, 0);
654		if (bourne_function_call && !(type_flags & EXPORT))
655			typeset(cp, LOCAL | LOCAL_COPY | EXPORT, 0, 0, 0);
656	}
657
658	if (Flag(FXTRACE)) {
659		change_xtrace(2, false);
660		if (ap[rv = 0]) {
661 xtrace_ap_loop:
662			print_value_quoted(shl_xtrace, ap[rv]);
663			if (ap[++rv]) {
664				shf_putc(' ', shl_xtrace);
665				goto xtrace_ap_loop;
666			}
667		}
668		change_xtrace(1, false);
669	}
670
671	if ((cp = *ap) == NULL) {
672		rv = subst_exstat;
673		goto Leave;
674	} else if (!tp) {
675		if (Flag(FRESTRICTED) && vstrchr(cp, '/')) {
676			warningf(true, "%s: %s", cp, "restricted");
677			rv = 1;
678			goto Leave;
679		}
680		tp = findcom(cp, fcflags);
681	}
682
683	switch (tp->type) {
684
685	/* shell built-in */
686	case CSHELL:
687		rv = call_builtin(tp, (const char **)ap, null);
688		if (!keepasn_ok && tp->val.f == c_shift) {
689			l_expand->argc = l_assign->argc;
690			l_expand->argv = l_assign->argv;
691		}
692		break;
693
694	/* function call */
695	case CFUNC: {
696		volatile unsigned char old_xflag;
697		volatile uint32_t old_inuse;
698		const char * volatile old_kshname;
699
700		if (!(tp->flag & ISSET)) {
701			struct tbl *ftp;
702
703			if (!tp->u.fpath) {
704				rv = (tp->u2.errnov == ENOENT) ? 127 : 126;
705				warningf(true, "%s: %s %s: %s", cp,
706				    "can't find", "function definition file",
707				    cstrerror(tp->u2.errnov));
708				break;
709			}
710			if (include(tp->u.fpath, 0, NULL, false) < 0) {
711				warningf(true, "%s: %s %s %s: %s", cp,
712				    "can't open", "function definition file",
713				    tp->u.fpath, cstrerror(errno));
714				rv = 127;
715				break;
716			}
717			if (!(ftp = findfunc(cp, hash(cp), false)) ||
718			    !(ftp->flag & ISSET)) {
719				warningf(true, "%s: %s %s", cp,
720				    "function not defined by", tp->u.fpath);
721				rv = 127;
722				break;
723			}
724			tp = ftp;
725		}
726
727		/*
728		 * ksh functions set $0 to function name, POSIX
729		 * functions leave $0 unchanged.
730		 */
731		old_kshname = kshname;
732		if (tp->flag & FKSH)
733			kshname = ap[0];
734		else
735			ap[0] = kshname;
736		e->loc->argv = ap;
737		for (i = 0; *ap++ != NULL; i++)
738			;
739		e->loc->argc = i - 1;
740		/*
741		 * ksh-style functions handle getopts sanely,
742		 * Bourne/POSIX functions are insane...
743		 */
744		if (tp->flag & FKSH) {
745			e->loc->flags |= BF_DOGETOPTS;
746			e->loc->getopts_state = user_opt;
747			getopts_reset(1);
748		}
749
750		old_xflag = Flag(FXTRACE) ? 1 : 0;
751		change_xtrace((Flag(FXTRACEREC) ? old_xflag : 0) |
752		    ((tp->flag & TRACE) ? 1 : 0), false);
753		old_inuse = tp->flag & FINUSE;
754		tp->flag |= FINUSE;
755
756		e->type = E_FUNC;
757		if (!(i = kshsetjmp(e->jbuf))) {
758			execute(tp->val.t, flags & XERROK, NULL);
759			i = LRETURN;
760		}
761
762		kshname = old_kshname;
763		change_xtrace(old_xflag, false);
764		tp->flag = (tp->flag & ~FINUSE) | old_inuse;
765
766		/*
767		 * Were we deleted while executing? If so, free the
768		 * execution tree. TODO: Unfortunately, the table entry
769		 * is never re-used until the lookup table is expanded.
770		 */
771		if ((tp->flag & (FDELETE|FINUSE)) == FDELETE) {
772			if (tp->flag & ALLOC) {
773				tp->flag &= ~ALLOC;
774				tfree(tp->val.t, tp->areap);
775			}
776			tp->flag = 0;
777		}
778		switch (i) {
779		case LRETURN:
780		case LERROR:
781			rv = exstat & 0xFF;
782			break;
783		case LINTR:
784		case LEXIT:
785		case LLEAVE:
786		case LSHELL:
787			quitenv(NULL);
788			unwind(i);
789			/* NOTREACHED */
790		default:
791			quitenv(NULL);
792			internal_errorf("%s %d", "CFUNC", i);
793		}
794		break;
795	}
796
797	/* executable command */
798	case CEXEC:
799	/* tracked alias */
800	case CTALIAS:
801		if (!(tp->flag&ISSET)) {
802			if (tp->u2.errnov == ENOENT) {
803				rv = 127;
804				warningf(true, "%s: %s", cp, "not found");
805			} else {
806				rv = 126;
807				warningf(true, "%s: %s: %s", cp, "can't execute",
808				    cstrerror(tp->u2.errnov));
809			}
810			break;
811		}
812
813		/* set $_ to programme's full path */
814		/* setstr() can't fail here */
815		setstr(typeset("_", LOCAL | EXPORT, 0, INTEGER, 0),
816		    tp->val.s, KSH_RETURN_ERROR);
817
818		if (flags&XEXEC) {
819			j_exit();
820			if (!(flags&XBGND)
821#ifndef MKSH_UNEMPLOYED
822			    || Flag(FMONITOR)
823#endif
824			    ) {
825				setexecsig(&sigtraps[SIGINT], SS_RESTORE_ORIG);
826				setexecsig(&sigtraps[SIGQUIT], SS_RESTORE_ORIG);
827			}
828		}
829
830		/* to fork we set up a TEXEC node and call execute */
831		texec.type = TEXEC;
832		/* for tprint */
833		texec.left = t;
834		texec.str = tp->val.s;
835		texec.args = ap;
836		rv = exchild(&texec, flags, xerrok, -1);
837		break;
838	}
839 Leave:
840	if (flags & XEXEC) {
841		exstat = rv & 0xFF;
842		unwind(LLEAVE);
843	}
844	return (rv);
845}
846
847static void
848scriptexec(struct op *tp, const char **ap)
849{
850	const char *sh;
851#ifndef MKSH_SMALL
852	unsigned char *cp;
853	/* 64 == MAXINTERP in MirBSD <sys/param.h> */
854	char buf[64];
855	int fd;
856#endif
857	union mksh_ccphack args, cap;
858
859	sh = str_val(global("EXECSHELL"));
860	if (sh && *sh)
861		sh = search_path(sh, path, X_OK, NULL);
862	if (!sh || !*sh)
863		sh = MKSH_DEFAULT_EXECSHELL;
864
865	*tp->args-- = tp->str;
866
867#ifndef MKSH_SMALL
868	if ((fd = open(tp->str, O_RDONLY | O_BINARY)) >= 0) {
869		/* read first MAXINTERP octets from file */
870		if (read(fd, buf, sizeof(buf)) <= 0)
871			/* read error -> no good */
872			buf[0] = '\0';
873		close(fd);
874
875		/* skip UTF-8 Byte Order Mark, if present */
876		cp = (unsigned char *)buf;
877		if ((cp[0] == 0xEF) && (cp[1] == 0xBB) && (cp[2] == 0xBF))
878			cp += 3;
879		/* save begin of shebang for later */
880		fd = (char *)cp - buf;		/* either 0 or (if BOM) 3 */
881
882		/* scan for newline (or CR) or NUL _before_ end of buffer */
883		while ((size_t)((char *)cp - buf) < sizeof(buf))
884			if (*cp == '\0' || *cp == '\n' || *cp == '\r') {
885				*cp = '\0';
886				break;
887			} else
888				++cp;
889		/* if the shebang line is longer than MAXINTERP, bail out */
890		if ((size_t)((char *)cp - buf) >= sizeof(buf))
891			goto noshebang;
892
893		/* restore begin of shebang position (buf+0 or buf+3) */
894		cp = (unsigned char *)(buf + fd);
895		/* bail out if read error (above) or no shebang */
896		if ((cp[0] != '#') || (cp[1] != '!'))
897			goto noshebang;
898
899		cp += 2;
900		/* skip whitespace before shell name */
901		while (*cp == ' ' || *cp == '\t')
902			++cp;
903		/* just whitespace on the line? */
904		if (*cp == '\0')
905			goto noshebang;
906		/* no, we actually found an interpreter name */
907		sh = (char *)cp;
908		/* look for end of shell/interpreter name */
909		while (*cp != ' ' && *cp != '\t' && *cp != '\0')
910			++cp;
911		/* any arguments? */
912		if (*cp) {
913			*cp++ = '\0';
914			/* skip spaces before arguments */
915			while (*cp == ' ' || *cp == '\t')
916				++cp;
917			/* pass it all in ONE argument (historic reasons) */
918			if (*cp)
919				*tp->args-- = (char *)cp;
920		}
921 noshebang:
922		if (buf[0] == 0x7F && buf[1] == 'E' && buf[2] == 'L' &&
923		    buf[3] == 'F')
924			errorf("%s: not executable: %d-bit ELF file", tp->str,
925			    32 * ((uint8_t)buf[4]));
926		fd = buf[0] << 8 | buf[1];
927		if ((fd == /* OMAGIC */ 0407) ||
928		    (fd == /* NMAGIC */ 0410) ||
929		    (fd == /* ZMAGIC */ 0413) ||
930		    (fd == /* QMAGIC */ 0314) ||
931		    (fd == /* ECOFF_I386 */ 0x4C01) ||
932		    (fd == /* ECOFF_M68K */ 0x0150 || fd == 0x5001) ||
933		    (fd == /* ECOFF_SH */   0x0500 || fd == 0x0005) ||
934		    (fd == /* "MZ" */ 0x4D5A) ||
935		    (fd == /* gzip */ 0x1F8B))
936			errorf("%s: not executable: magic %04X", tp->str, fd);
937	}
938#endif
939	args.ro = tp->args;
940	*args.ro = sh;
941
942	cap.ro = ap;
943	execve(args.rw[0], args.rw, cap.rw);
944
945	/* report both the programme that was run and the bogus interpreter */
946	errorf("%s: %s: %s", tp->str, sh, cstrerror(errno));
947}
948
949int
950shcomexec(const char **wp)
951{
952	struct tbl *tp;
953
954	tp = ktsearch(&builtins, *wp, hash(*wp));
955	return (call_builtin(tp, wp, "shcomexec"));
956}
957
958/*
959 * Search function tables for a function. If create set, a table entry
960 * is created if none is found.
961 */
962struct tbl *
963findfunc(const char *name, uint32_t h, bool create)
964{
965	struct block *l;
966	struct tbl *tp = NULL;
967
968	for (l = e->loc; l; l = l->next) {
969		tp = ktsearch(&l->funs, name, h);
970		if (tp)
971			break;
972		if (!l->next && create) {
973			tp = ktenter(&l->funs, name, h);
974			tp->flag = DEFINED;
975			tp->type = CFUNC;
976			tp->val.t = NULL;
977			break;
978		}
979	}
980	return (tp);
981}
982
983/*
984 * define function. Returns 1 if function is being undefined (t == 0) and
985 * function did not exist, returns 0 otherwise.
986 */
987int
988define(const char *name, struct op *t)
989{
990	uint32_t nhash;
991	struct tbl *tp;
992	bool was_set = false;
993
994	nhash = hash(name);
995
996	if (t != NULL && !tobool(t->u.ksh_func)) {
997		/* drop same-name aliases for POSIX functions */
998		if ((tp = ktsearch(&aliases, name, nhash)))
999			ktdelete(tp);
1000	}
1001
1002	while (/* CONSTCOND */ 1) {
1003		tp = findfunc(name, nhash, true);
1004		/* because findfunc:create=true */
1005		mkssert(tp != NULL);
1006
1007		if (tp->flag & ISSET)
1008			was_set = true;
1009		/*
1010		 * If this function is currently being executed, we zap
1011		 * this table entry so findfunc() won't see it
1012		 */
1013		if (tp->flag & FINUSE) {
1014			tp->name[0] = '\0';
1015			/* ensure it won't be found */
1016			tp->flag &= ~DEFINED;
1017			tp->flag |= FDELETE;
1018		} else
1019			break;
1020	}
1021
1022	if (tp->flag & ALLOC) {
1023		tp->flag &= ~(ISSET|ALLOC);
1024		tfree(tp->val.t, tp->areap);
1025	}
1026
1027	if (t == NULL) {
1028		/* undefine */
1029		ktdelete(tp);
1030		return (was_set ? 0 : 1);
1031	}
1032
1033	tp->val.t = tcopy(t->left, tp->areap);
1034	tp->flag |= (ISSET|ALLOC);
1035	if (t->u.ksh_func)
1036		tp->flag |= FKSH;
1037
1038	return (0);
1039}
1040
1041/*
1042 * add builtin
1043 */
1044const char *
1045builtin(const char *name, int (*func) (const char **))
1046{
1047	struct tbl *tp;
1048	uint32_t flag = DEFINED;
1049
1050	/* see if any flags should be set for this builtin */
1051	while (1) {
1052		if (*name == '=')
1053			/* command does variable assignment */
1054			flag |= KEEPASN;
1055		else if (*name == '*')
1056			/* POSIX special builtin */
1057			flag |= SPEC_BI;
1058		else
1059			break;
1060		name++;
1061	}
1062
1063	tp = ktenter(&builtins, name, hash(name));
1064	tp->flag = flag;
1065	tp->type = CSHELL;
1066	tp->val.f = func;
1067
1068	return (name);
1069}
1070
1071/*
1072 * find command
1073 * either function, hashed command, or built-in (in that order)
1074 */
1075struct tbl *
1076findcom(const char *name, int flags)
1077{
1078	static struct tbl temp;
1079	uint32_t h = hash(name);
1080	struct tbl *tp = NULL, *tbi;
1081	/* insert if not found */
1082	unsigned char insert = Flag(FTRACKALL);
1083	/* for function autoloading */
1084	char *fpath;
1085	union mksh_cchack npath;
1086
1087	if (vstrchr(name, '/')) {
1088		insert = 0;
1089		/* prevent FPATH search below */
1090		flags &= ~FC_FUNC;
1091		goto Search;
1092	}
1093	tbi = (flags & FC_BI) ? ktsearch(&builtins, name, h) : NULL;
1094	/*
1095	 * POSIX says special builtins first, then functions, then
1096	 * regular builtins, then search path...
1097	 */
1098	if ((flags & FC_SPECBI) && tbi && (tbi->flag & SPEC_BI))
1099		tp = tbi;
1100	if (!tp && (flags & FC_FUNC)) {
1101		tp = findfunc(name, h, false);
1102		if (tp && !(tp->flag & ISSET)) {
1103			if ((fpath = str_val(global("FPATH"))) == null) {
1104				tp->u.fpath = NULL;
1105				tp->u2.errnov = ENOENT;
1106			} else
1107				tp->u.fpath = search_path(name, fpath, R_OK,
1108				    &tp->u2.errnov);
1109		}
1110	}
1111	if (!tp && (flags & FC_NORMBI) && tbi)
1112		tp = tbi;
1113	if (!tp && (flags & FC_PATH) && !(flags & FC_DEFPATH)) {
1114		tp = ktsearch(&taliases, name, h);
1115		if (tp && (tp->flag & ISSET) &&
1116		    ksh_access(tp->val.s, X_OK) != 0) {
1117			if (tp->flag & ALLOC) {
1118				tp->flag &= ~ALLOC;
1119				afree(tp->val.s, APERM);
1120			}
1121			tp->flag &= ~ISSET;
1122		}
1123	}
1124
1125 Search:
1126	if ((!tp || (tp->type == CTALIAS && !(tp->flag&ISSET))) &&
1127	    (flags & FC_PATH)) {
1128		if (!tp) {
1129			if (insert && !(flags & FC_DEFPATH)) {
1130				tp = ktenter(&taliases, name, h);
1131				tp->type = CTALIAS;
1132			} else {
1133				tp = &temp;
1134				tp->type = CEXEC;
1135			}
1136			/* make ~ISSET */
1137			tp->flag = DEFINED;
1138		}
1139		npath.ro = search_path(name,
1140		    (flags & FC_DEFPATH) ? def_path : path,
1141		    X_OK, &tp->u2.errnov);
1142		if (npath.ro) {
1143			strdupx(tp->val.s, npath.ro, APERM);
1144			if (npath.ro != name)
1145				afree(npath.rw, ATEMP);
1146			tp->flag |= ISSET|ALLOC;
1147		} else if ((flags & FC_FUNC) &&
1148		    (fpath = str_val(global("FPATH"))) != null &&
1149		    (npath.ro = search_path(name, fpath, R_OK,
1150		    &tp->u2.errnov)) != NULL) {
1151			/*
1152			 * An undocumented feature of AT&T ksh is that
1153			 * it searches FPATH if a command is not found,
1154			 * even if the command hasn't been set up as an
1155			 * autoloaded function (ie, no typeset -uf).
1156			 */
1157			tp = &temp;
1158			tp->type = CFUNC;
1159			/* make ~ISSET */
1160			tp->flag = DEFINED;
1161			tp->u.fpath = npath.ro;
1162		}
1163	}
1164	return (tp);
1165}
1166
1167/*
1168 * flush executable commands with relative paths
1169 * (just relative or all?)
1170 */
1171void
1172flushcom(bool all)
1173{
1174	struct tbl *tp;
1175	struct tstate ts;
1176
1177	for (ktwalk(&ts, &taliases); (tp = ktnext(&ts)) != NULL; )
1178		if ((tp->flag&ISSET) && (all || tp->val.s[0] != '/')) {
1179			if (tp->flag&ALLOC) {
1180				tp->flag &= ~(ALLOC|ISSET);
1181				afree(tp->val.s, APERM);
1182			}
1183			tp->flag &= ~ISSET;
1184		}
1185}
1186
1187/* check if path is something we want to find */
1188static int
1189search_access(const char *fn, int mode)
1190{
1191	struct stat sb;
1192
1193	if (stat(fn, &sb) < 0)
1194		/* file does not exist */
1195		return (ENOENT);
1196	/* LINTED use of access */
1197	if (access(fn, mode) < 0)
1198		/* file exists, but we can't access it */
1199		return (errno);
1200	if (mode == X_OK && (!S_ISREG(sb.st_mode) ||
1201	    !(sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))))
1202		/* access(2) may say root can execute everything */
1203		return (S_ISDIR(sb.st_mode) ? EISDIR : EACCES);
1204	return (0);
1205}
1206
1207/*
1208 * search for command with PATH
1209 */
1210const char *
1211search_path(const char *name, const char *lpath,
1212    /* R_OK or X_OK */
1213    int mode,
1214    /* set if candidate found, but not suitable */
1215    int *errnop)
1216{
1217	const char *sp, *p;
1218	char *xp;
1219	XString xs;
1220	size_t namelen;
1221	int ec = 0, ev;
1222
1223	if (vstrchr(name, '/')) {
1224		if ((ec = search_access(name, mode)) == 0) {
1225 search_path_ok:
1226			if (errnop)
1227				*errnop = 0;
1228			return (name);
1229		}
1230		goto search_path_err;
1231	}
1232
1233	namelen = strlen(name) + 1;
1234	Xinit(xs, xp, 128, ATEMP);
1235
1236	sp = lpath;
1237	while (sp != NULL) {
1238		xp = Xstring(xs, xp);
1239		if (!(p = cstrchr(sp, ':')))
1240			p = sp + strlen(sp);
1241		if (p != sp) {
1242			XcheckN(xs, xp, p - sp);
1243			memcpy(xp, sp, p - sp);
1244			xp += p - sp;
1245			*xp++ = '/';
1246		}
1247		sp = p;
1248		XcheckN(xs, xp, namelen);
1249		memcpy(xp, name, namelen);
1250		if ((ev = search_access(Xstring(xs, xp), mode)) == 0) {
1251			name = Xclose(xs, xp + namelen);
1252			goto search_path_ok;
1253		}
1254		/* accumulate non-ENOENT errors only */
1255		if (ev != ENOENT && ec == 0)
1256			ec = ev;
1257		if (*sp++ == '\0')
1258			sp = NULL;
1259	}
1260	Xfree(xs, xp);
1261 search_path_err:
1262	if (errnop)
1263		*errnop = ec ? ec : ENOENT;
1264	return (NULL);
1265}
1266
1267static int
1268call_builtin(struct tbl *tp, const char **wp, const char *where)
1269{
1270	int rv;
1271
1272	if (!tp)
1273		internal_errorf("%s: %s", where, wp[0]);
1274	builtin_argv0 = wp[0];
1275	builtin_flag = tp->flag;
1276	shf_reopen(1, SHF_WR, shl_stdout);
1277	shl_stdout_ok = true;
1278	ksh_getopt_reset(&builtin_opt, GF_ERROR);
1279	rv = (*tp->val.f)(wp);
1280	shf_flush(shl_stdout);
1281	shl_stdout_ok = false;
1282	builtin_flag = 0;
1283	builtin_argv0 = NULL;
1284	return (rv);
1285}
1286
1287/*
1288 * set up redirection, saving old fds in e->savefd
1289 */
1290static int
1291iosetup(struct ioword *iop, struct tbl *tp)
1292{
1293	int u = -1;
1294	char *cp = iop->name;
1295	int iotype = iop->flag & IOTYPE;
1296	bool do_open = true, do_close = false;
1297	int flags = 0;
1298	struct ioword iotmp;
1299	struct stat statb;
1300
1301	if (iotype != IOHERE)
1302		cp = evalonestr(cp, DOTILDE|(Flag(FTALKING_I) ? DOGLOB : 0));
1303
1304	/* Used for tracing and error messages to print expanded cp */
1305	iotmp = *iop;
1306	iotmp.name = (iotype == IOHERE) ? NULL : cp;
1307	iotmp.flag |= IONAMEXP;
1308
1309	if (Flag(FXTRACE)) {
1310		change_xtrace(2, false);
1311		fptreef(shl_xtrace, 0, "%R", &iotmp);
1312		change_xtrace(1, false);
1313	}
1314
1315	switch (iotype) {
1316	case IOREAD:
1317		flags = O_RDONLY;
1318		break;
1319
1320	case IOCAT:
1321		flags = O_WRONLY | O_APPEND | O_CREAT;
1322		break;
1323
1324	case IOWRITE:
1325		flags = O_WRONLY | O_CREAT | O_TRUNC;
1326		/*
1327		 * The stat() is here to allow redirections to
1328		 * things like /dev/null without error.
1329		 */
1330		if (Flag(FNOCLOBBER) && !(iop->flag & IOCLOB) &&
1331		    (stat(cp, &statb) < 0 || S_ISREG(statb.st_mode)))
1332			flags |= O_EXCL;
1333		break;
1334
1335	case IORDWR:
1336		flags = O_RDWR | O_CREAT;
1337		break;
1338
1339	case IOHERE:
1340		do_open = false;
1341		/* herein() returns -2 if error has been printed */
1342		u = herein(iop, NULL);
1343		/* cp may have wrong name */
1344		break;
1345
1346	case IODUP: {
1347		const char *emsg;
1348
1349		do_open = false;
1350		if (*cp == '-' && !cp[1]) {
1351			/* prevent error return below */
1352			u = 1009;
1353			do_close = true;
1354		} else if ((u = check_fd(cp,
1355		    X_OK | ((iop->flag & IORDUP) ? R_OK : W_OK),
1356		    &emsg)) < 0) {
1357			char *sp;
1358
1359			warningf(true, "%s: %s",
1360			    (sp = snptreef(NULL, 32, "%R", &iotmp)), emsg);
1361			afree(sp, ATEMP);
1362			return (-1);
1363		}
1364		if (u == iop->unit)
1365			/* "dup from" == "dup to" */
1366			return (0);
1367		break;
1368	    }
1369	}
1370
1371	if (do_open) {
1372		if (Flag(FRESTRICTED) && (flags & O_CREAT)) {
1373			warningf(true, "%s: %s", cp, "restricted");
1374			return (-1);
1375		}
1376		u = open(cp, flags | O_BINARY, 0666);
1377	}
1378	if (u < 0) {
1379		/* herein() may already have printed message */
1380		if (u == -1) {
1381			u = errno;
1382			warningf(true, "can't %s %s: %s",
1383			    iotype == IODUP ? "dup" :
1384			    (iotype == IOREAD || iotype == IOHERE) ?
1385			    "open" : "create", cp, cstrerror(u));
1386		}
1387		return (-1);
1388	}
1389	/* Do not save if it has already been redirected (i.e. "cat >x >y"). */
1390	if (e->savefd[iop->unit] == 0) {
1391		/* If these are the same, it means unit was previously closed */
1392		if (u == iop->unit)
1393			e->savefd[iop->unit] = -1;
1394		else
1395			/*
1396			 * c_exec() assumes e->savefd[fd] set for any
1397			 * redirections. Ask savefd() not to close iop->unit;
1398			 * this allows error messages to be seen if iop->unit
1399			 * is 2; also means we can't lose the fd (eg, both
1400			 * dup2 below and dup2 in restfd() failing).
1401			 */
1402			e->savefd[iop->unit] = savefd(iop->unit);
1403	}
1404
1405	if (do_close)
1406		close(iop->unit);
1407	else if (u != iop->unit) {
1408		if (ksh_dup2(u, iop->unit, true) < 0) {
1409			int eno;
1410			char *sp;
1411
1412			eno = errno;
1413			warningf(true, "%s %s %s",
1414			    "can't finish (dup) redirection",
1415			    (sp = snptreef(NULL, 32, "%R", &iotmp)),
1416			    cstrerror(eno));
1417			afree(sp, ATEMP);
1418			if (iotype != IODUP)
1419				close(u);
1420			return (-1);
1421		}
1422		if (iotype != IODUP)
1423			close(u);
1424		/*
1425		 * Touching any co-process fd in an empty exec
1426		 * causes the shell to close its copies
1427		 */
1428		else if (tp && tp->type == CSHELL && tp->val.f == c_exec) {
1429			if (iop->flag & IORDUP)
1430				/* possible exec <&p */
1431				coproc_read_close(u);
1432			else
1433				/* possible exec >&p */
1434				coproc_write_close(u);
1435		}
1436	}
1437	if (u == 2)
1438		/* Clear any write errors */
1439		shf_reopen(2, SHF_WR, shl_out);
1440	return (0);
1441}
1442
1443/*
1444 * Process here documents by providing the content, either as
1445 * result (globally allocated) string or in a temp file; if
1446 * unquoted, the string is expanded first.
1447 */
1448static int
1449hereinval(const char *content, int sub, char **resbuf, struct shf *shf)
1450{
1451	const char * volatile ccp = content;
1452	struct source *s, *osource;
1453
1454	osource = source;
1455	newenv(E_ERRH);
1456	if (kshsetjmp(e->jbuf)) {
1457		source = osource;
1458		quitenv(shf);
1459		/* special to iosetup(): don't print error */
1460		return (-2);
1461	}
1462	if (sub) {
1463		/* do substitutions on the content of heredoc */
1464		s = pushs(SSTRING, ATEMP);
1465		s->start = s->str = ccp;
1466		source = s;
1467		if (yylex(sub) != LWORD)
1468			internal_errorf("%s: %s", "herein", "yylex");
1469		source = osource;
1470		ccp = evalstr(yylval.cp, 0);
1471	}
1472
1473	if (resbuf == NULL)
1474		shf_puts(ccp, shf);
1475	else
1476		strdupx(*resbuf, ccp, APERM);
1477
1478	quitenv(NULL);
1479	return (0);
1480}
1481
1482static int
1483herein(struct ioword *iop, char **resbuf)
1484{
1485	int fd = -1;
1486	struct shf *shf;
1487	struct temp *h;
1488	int i;
1489
1490	/* ksh -c 'cat << EOF' can cause this... */
1491	if (iop->heredoc == NULL) {
1492		warningf(true, "%s missing", "here document");
1493		/* special to iosetup(): don't print error */
1494		return (-2);
1495	}
1496
1497	/* lexer substitution flags */
1498	i = (iop->flag & IOEVAL) ? (ONEWORD | HEREDOC) : 0;
1499
1500	/* skip all the fd setup if we just want the value */
1501	if (resbuf != NULL)
1502		return (hereinval(iop->heredoc, i, resbuf, NULL));
1503
1504	/*
1505	 * Create temp file to hold content (done before newenv
1506	 * so temp doesn't get removed too soon).
1507	 */
1508	h = maketemp(ATEMP, TT_HEREDOC_EXP, &e->temps);
1509	if (!(shf = h->shf) || (fd = open(h->tffn, O_RDONLY | O_BINARY, 0)) < 0) {
1510		i = errno;
1511		warningf(true, "can't %s temporary file %s: %s",
1512		    !shf ? "create" : "open", h->tffn, cstrerror(i));
1513		if (shf)
1514			shf_close(shf);
1515		/* special to iosetup(): don't print error */
1516		return (-2);
1517	}
1518
1519	if (hereinval(iop->heredoc, i, NULL, shf) == -2) {
1520		close(fd);
1521		/* special to iosetup(): don't print error */
1522		return (-2);
1523	}
1524
1525	if (shf_close(shf) == EOF) {
1526		i = errno;
1527		close(fd);
1528		warningf(true, "can't %s temporary file %s: %s",
1529		    "write", h->tffn, cstrerror(i));
1530		/* special to iosetup(): don't print error */
1531		return (-2);
1532	}
1533
1534	return (fd);
1535}
1536
1537/*
1538 *	ksh special - the select command processing section
1539 *	print the args in column form - assuming that we can
1540 */
1541static const char *
1542do_selectargs(const char **ap, bool print_menu)
1543{
1544	static const char *read_args[] = {
1545		"read", "-r", "REPLY", NULL
1546	};
1547	char *s;
1548	int i, argct;
1549
1550	for (argct = 0; ap[argct]; argct++)
1551		;
1552	while (/* CONSTCOND */ 1) {
1553		/*-
1554		 * Menu is printed if
1555		 *	- this is the first time around the select loop
1556		 *	- the user enters a blank line
1557		 *	- the REPLY parameter is empty
1558		 */
1559		if (print_menu || !*str_val(global("REPLY")))
1560			pr_menu(ap);
1561		shellf("%s", str_val(global("PS3")));
1562		if (call_builtin(findcom("read", FC_BI), read_args, Tselect))
1563			return (NULL);
1564		s = str_val(global("REPLY"));
1565		if (*s && getn(s, &i))
1566			return ((i >= 1 && i <= argct) ? ap[i - 1] : null);
1567		print_menu = true;
1568	}
1569}
1570
1571struct select_menu_info {
1572	const char * const *args;
1573	int num_width;
1574};
1575
1576/* format a single select menu item */
1577static char *
1578select_fmt_entry(char *buf, size_t buflen, unsigned int i, const void *arg)
1579{
1580	const struct select_menu_info *smi =
1581	    (const struct select_menu_info *)arg;
1582
1583	shf_snprintf(buf, buflen, "%*u) %s",
1584	    smi->num_width, i + 1, smi->args[i]);
1585	return (buf);
1586}
1587
1588/*
1589 *	print a select style menu
1590 */
1591void
1592pr_menu(const char * const *ap)
1593{
1594	struct select_menu_info smi;
1595	const char * const *pp;
1596	size_t acols = 0, aocts = 0, i;
1597	unsigned int n;
1598
1599	/*
1600	 * width/column calculations were done once and saved, but this
1601	 * means select can't be used recursively so we re-calculate
1602	 * each time (could save in a structure that is returned, but
1603	 * it's probably not worth the bother)
1604	 */
1605
1606	/*
1607	 * get dimensions of the list
1608	 */
1609	for (n = 0, pp = ap; *pp; n++, pp++) {
1610		i = strlen(*pp);
1611		if (i > aocts)
1612			aocts = i;
1613		i = utf_mbswidth(*pp);
1614		if (i > acols)
1615			acols = i;
1616	}
1617
1618	/*
1619	 * we will print an index of the form "%d) " in front of
1620	 * each entry, so get the maximum width of this
1621	 */
1622	for (i = n, smi.num_width = 1; i >= 10; i /= 10)
1623		smi.num_width++;
1624
1625	smi.args = ap;
1626	print_columns(shl_out, n, select_fmt_entry, (void *)&smi,
1627	    smi.num_width + 2 + aocts, smi.num_width + 2 + acols,
1628	    true);
1629}
1630
1631static char *
1632plain_fmt_entry(char *buf, size_t buflen, unsigned int i, const void *arg)
1633{
1634	strlcpy(buf, ((const char * const *)arg)[i], buflen);
1635	return (buf);
1636}
1637
1638void
1639pr_list(char * const *ap)
1640{
1641	size_t acols = 0, aocts = 0, i;
1642	unsigned int n;
1643	char * const *pp;
1644
1645	for (n = 0, pp = ap; *pp; n++, pp++) {
1646		i = strlen(*pp);
1647		if (i > aocts)
1648			aocts = i;
1649		i = utf_mbswidth(*pp);
1650		if (i > acols)
1651			acols = i;
1652	}
1653
1654	print_columns(shl_out, n, plain_fmt_entry, (const void *)ap,
1655	    aocts, acols, false);
1656}
1657
1658/*
1659 *	[[ ... ]] evaluation routines
1660 */
1661
1662/*
1663 * Test if the current token is a whatever. Accepts the current token if
1664 * it is. Returns 0 if it is not, non-zero if it is (in the case of
1665 * TM_UNOP and TM_BINOP, the returned value is a Test_op).
1666 */
1667static Test_op
1668dbteste_isa(Test_env *te, Test_meta meta)
1669{
1670	Test_op ret = TO_NONOP;
1671	bool uqword;
1672	const char *p;
1673
1674	if (!*te->pos.wp)
1675		return (meta == TM_END ? TO_NONNULL : TO_NONOP);
1676
1677	/* unquoted word? */
1678	for (p = *te->pos.wp; *p == CHAR; p += 2)
1679		;
1680	uqword = *p == EOS;
1681
1682	if (meta == TM_UNOP || meta == TM_BINOP) {
1683		if (uqword) {
1684			/* longer than the longest operator */
1685			char buf[8];
1686			char *q = buf;
1687
1688			p = *te->pos.wp;
1689			while (*p++ == CHAR &&
1690			    (size_t)(q - buf) < sizeof(buf) - 1)
1691				*q++ = *p++;
1692			*q = '\0';
1693			ret = test_isop(meta, buf);
1694		}
1695	} else if (meta == TM_END)
1696		ret = TO_NONOP;
1697	else
1698		ret = (uqword && !strcmp(*te->pos.wp,
1699		    dbtest_tokens[(int)meta])) ? TO_NONNULL : TO_NONOP;
1700
1701	/* Accept the token? */
1702	if (ret != TO_NONOP)
1703		te->pos.wp++;
1704
1705	return (ret);
1706}
1707
1708static const char *
1709dbteste_getopnd(Test_env *te, Test_op op, bool do_eval)
1710{
1711	const char *s = *te->pos.wp;
1712
1713	if (!s)
1714		return (NULL);
1715
1716	te->pos.wp++;
1717
1718	if (!do_eval)
1719		return (null);
1720
1721	if (op == TO_STEQL || op == TO_STNEQ)
1722		s = evalstr(s, DOTILDE | DOPAT);
1723	else
1724		s = evalstr(s, DOTILDE);
1725
1726	return (s);
1727}
1728
1729static void
1730dbteste_error(Test_env *te, int offset, const char *msg)
1731{
1732	te->flags |= TEF_ERROR;
1733	internal_warningf("dbteste_error: %s (offset %d)", msg, offset);
1734}
1735