Home | History | Annotate | Download | only in sh
      1 /*	$NetBSD: eval.c,v 1.81.2.1 2005/06/13 22:03:51 tron Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * This code is derived from software contributed to Berkeley by
      8  * Kenneth Almquist.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. Neither the name of the University nor the names of its contributors
     19  *    may be used to endorse or promote products derived from this software
     20  *    without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  */
     34 
     35 #include <sys/cdefs.h>
     36 #ifndef lint
     37 #if 0
     38 static char sccsid[] = "@(#)eval.c	8.9 (Berkeley) 6/8/95";
     39 #else
     40 __RCSID("$NetBSD: eval.c,v 1.81.2.1 2005/06/13 22:03:51 tron Exp $");
     41 #endif
     42 #endif /* not lint */
     43 
     44 #include <stdlib.h>
     45 #include <signal.h>
     46 #include <stdio.h>
     47 #include <unistd.h>
     48 #ifdef __linux__
     49 #include <fcntl.h>
     50 #else
     51 #include <sys/fcntl.h>
     52 #endif
     53 #include <sys/times.h>
     54 #include <sys/param.h>
     55 #include <sys/types.h>
     56 #include <sys/wait.h>
     57 
     58 /*
     59  * Evaluate a command.
     60  */
     61 
     62 #include "shell.h"
     63 #include "nodes.h"
     64 #include "syntax.h"
     65 #include "expand.h"
     66 #include "parser.h"
     67 #include "jobs.h"
     68 #include "eval.h"
     69 #include "builtins.h"
     70 #include "options.h"
     71 #include "exec.h"
     72 #include "redir.h"
     73 #include "input.h"
     74 #include "output.h"
     75 #include "trap.h"
     76 #include "var.h"
     77 #include "memalloc.h"
     78 #include "error.h"
     79 #include "show.h"
     80 #include "mystring.h"
     81 #include "main.h"
     82 #ifndef SMALL
     83 #include "myhistedit.h"
     84 #endif
     85 
     86 
     87 /* flags in argument to evaltree */
     88 #define EV_EXIT 01		/* exit after evaluating tree */
     89 #define EV_TESTED 02		/* exit status is checked; ignore -e flag */
     90 #define EV_BACKCMD 04		/* command executing within back quotes */
     91 
     92 int evalskip;			/* set if we are skipping commands */
     93 STATIC int skipcount;		/* number of levels to skip */
     94 MKINIT int loopnest;		/* current loop nesting level */
     95 int funcnest;			/* depth of function calls */
     96 
     97 
     98 char *commandname;
     99 struct strlist *cmdenviron;
    100 int exitstatus;			/* exit status of last command */
    101 int back_exitstatus;		/* exit status of backquoted command */
    102 
    103 
    104 STATIC void evalloop(union node *, int);
    105 STATIC void evalfor(union node *, int);
    106 STATIC void evalcase(union node *, int);
    107 STATIC void evalsubshell(union node *, int);
    108 STATIC void expredir(union node *);
    109 STATIC void evalpipe(union node *);
    110 STATIC void evalcommand(union node *, int, struct backcmd *);
    111 STATIC void prehash(union node *);
    112 
    113 
    114 /*
    115  * Called to reset things after an exception.
    116  */
    117 
    118 #ifdef mkinit
    119 INCLUDE "eval.h"
    120 
    121 RESET {
    122 	evalskip = 0;
    123 	loopnest = 0;
    124 	funcnest = 0;
    125 }
    126 
    127 SHELLPROC {
    128 	exitstatus = 0;
    129 }
    130 #endif
    131 
    132 static int
    133 sh_pipe(int fds[2])
    134 {
    135 	int nfd;
    136 
    137 	if (pipe(fds))
    138 		return -1;
    139 
    140 	if (fds[0] < 3) {
    141 		nfd = fcntl(fds[0], F_DUPFD, 3);
    142 		if (nfd != -1) {
    143 			close(fds[0]);
    144 			fds[0] = nfd;
    145 		}
    146 	}
    147 
    148 	if (fds[1] < 3) {
    149 		nfd = fcntl(fds[1], F_DUPFD, 3);
    150 		if (nfd != -1) {
    151 			close(fds[1]);
    152 			fds[1] = nfd;
    153 		}
    154 	}
    155 	return 0;
    156 }
    157 
    158 
    159 /*
    160  * The eval commmand.
    161  */
    162 
    163 int
    164 evalcmd(int argc, char **argv)
    165 {
    166         char *p;
    167         char *concat;
    168         char **ap;
    169 
    170         if (argc > 1) {
    171                 p = argv[1];
    172                 if (argc > 2) {
    173                         STARTSTACKSTR(concat);
    174                         ap = argv + 2;
    175                         for (;;) {
    176                                 while (*p)
    177                                         STPUTC(*p++, concat);
    178                                 if ((p = *ap++) == NULL)
    179                                         break;
    180                                 STPUTC(' ', concat);
    181                         }
    182                         STPUTC('\0', concat);
    183                         p = grabstackstr(concat);
    184                 }
    185                 evalstring(p, EV_TESTED);
    186         }
    187         return exitstatus;
    188 }
    189 
    190 
    191 /*
    192  * Execute a command or commands contained in a string.
    193  */
    194 
    195 void
    196 evalstring(char *s, int flag)
    197 {
    198 	union node *n;
    199 	struct stackmark smark;
    200 
    201 	setstackmark(&smark);
    202 	setinputstring(s, 1);
    203 
    204 	while ((n = parsecmd(0)) != NEOF) {
    205 		evaltree(n, flag);
    206 		popstackmark(&smark);
    207 	}
    208 	popfile();
    209 	popstackmark(&smark);
    210 }
    211 
    212 
    213 
    214 /*
    215  * Evaluate a parse tree.  The value is left in the global variable
    216  * exitstatus.
    217  */
    218 
    219 void
    220 evaltree(union node *n, int flags)
    221 {
    222 	if (n == NULL) {
    223 		TRACE(("evaltree(NULL) called\n"));
    224 		exitstatus = 0;
    225 		goto out;
    226 	}
    227 #ifdef WITH_HISTORY
    228 	displayhist = 1;	/* show history substitutions done with fc */
    229 #endif
    230 	TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
    231 	    getpid(), n, n->type, flags));
    232 	switch (n->type) {
    233 	case NSEMI:
    234 		evaltree(n->nbinary.ch1, flags & EV_TESTED);
    235 		if (evalskip)
    236 			goto out;
    237 		evaltree(n->nbinary.ch2, flags);
    238 		break;
    239 	case NAND:
    240 		evaltree(n->nbinary.ch1, EV_TESTED);
    241 		if (evalskip || exitstatus != 0)
    242 			goto out;
    243 		evaltree(n->nbinary.ch2, flags);
    244 		break;
    245 	case NOR:
    246 		evaltree(n->nbinary.ch1, EV_TESTED);
    247 		if (evalskip || exitstatus == 0)
    248 			goto out;
    249 		evaltree(n->nbinary.ch2, flags);
    250 		break;
    251 	case NREDIR:
    252 		expredir(n->nredir.redirect);
    253 		redirect(n->nredir.redirect, REDIR_PUSH);
    254 		evaltree(n->nredir.n, flags);
    255 		popredir();
    256 		break;
    257 	case NSUBSHELL:
    258 		evalsubshell(n, flags);
    259 		break;
    260 	case NBACKGND:
    261 		evalsubshell(n, flags);
    262 		break;
    263 	case NIF: {
    264 		evaltree(n->nif.test, EV_TESTED);
    265 		if (evalskip)
    266 			goto out;
    267 		if (exitstatus == 0)
    268 			evaltree(n->nif.ifpart, flags);
    269 		else if (n->nif.elsepart)
    270 			evaltree(n->nif.elsepart, flags);
    271 		else
    272 			exitstatus = 0;
    273 		break;
    274 	}
    275 	case NWHILE:
    276 	case NUNTIL:
    277 		evalloop(n, flags);
    278 		break;
    279 	case NFOR:
    280 		evalfor(n, flags);
    281 		break;
    282 	case NCASE:
    283 		evalcase(n, flags);
    284 		break;
    285 	case NDEFUN:
    286 		defun(n->narg.text, n->narg.next);
    287 		exitstatus = 0;
    288 		break;
    289 	case NNOT:
    290 		evaltree(n->nnot.com, EV_TESTED);
    291 		exitstatus = !exitstatus;
    292 		break;
    293 	case NPIPE:
    294 		evalpipe(n);
    295 		break;
    296 	case NCMD:
    297 		evalcommand(n, flags, (struct backcmd *)NULL);
    298 		break;
    299 	default:
    300 		out1fmt("Node type = %d\n", n->type);
    301 		flushout(&output);
    302 		break;
    303 	}
    304 out:
    305 	if (pendingsigs)
    306 		dotrap();
    307 	if ((flags & EV_EXIT) != 0)
    308 		exitshell(exitstatus);
    309 }
    310 
    311 
    312 STATIC void
    313 evalloop(union node *n, int flags)
    314 {
    315 	int status;
    316 
    317 	loopnest++;
    318 	status = 0;
    319 	for (;;) {
    320 		evaltree(n->nbinary.ch1, EV_TESTED);
    321 		if (evalskip) {
    322 skipping:	  if (evalskip == SKIPCONT && --skipcount <= 0) {
    323 				evalskip = 0;
    324 				continue;
    325 			}
    326 			if (evalskip == SKIPBREAK && --skipcount <= 0)
    327 				evalskip = 0;
    328 			break;
    329 		}
    330 		if (n->type == NWHILE) {
    331 			if (exitstatus != 0)
    332 				break;
    333 		} else {
    334 			if (exitstatus == 0)
    335 				break;
    336 		}
    337 		evaltree(n->nbinary.ch2, flags & EV_TESTED);
    338 		status = exitstatus;
    339 		if (evalskip)
    340 			goto skipping;
    341 	}
    342 	loopnest--;
    343 	exitstatus = status;
    344 }
    345 
    346 
    347 
    348 STATIC void
    349 evalfor(union node *n, int flags)
    350 {
    351 	struct arglist arglist;
    352 	union node *argp;
    353 	struct strlist *sp;
    354 	struct stackmark smark;
    355 	int status = 0;
    356 
    357 	setstackmark(&smark);
    358 	arglist.lastp = &arglist.list;
    359 	for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
    360 		expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
    361 		if (evalskip)
    362 			goto out;
    363 	}
    364 	*arglist.lastp = NULL;
    365 
    366 	loopnest++;
    367 	for (sp = arglist.list ; sp ; sp = sp->next) {
    368 		setvar(n->nfor.var, sp->text, 0);
    369 		evaltree(n->nfor.body, flags & EV_TESTED);
    370 		status = exitstatus;
    371 		if (evalskip) {
    372 			if (evalskip == SKIPCONT && --skipcount <= 0) {
    373 				evalskip = 0;
    374 				continue;
    375 			}
    376 			if (evalskip == SKIPBREAK && --skipcount <= 0)
    377 				evalskip = 0;
    378 			break;
    379 		}
    380 	}
    381 	loopnest--;
    382 	exitstatus = status;
    383 out:
    384 	popstackmark(&smark);
    385 }
    386 
    387 
    388 
    389 STATIC void
    390 evalcase(union node *n, int flags)
    391 {
    392 	union node *cp;
    393 	union node *patp;
    394 	struct arglist arglist;
    395 	struct stackmark smark;
    396 	int status = 0;
    397 
    398 	setstackmark(&smark);
    399 	arglist.lastp = &arglist.list;
    400 	expandarg(n->ncase.expr, &arglist, EXP_TILDE);
    401 	for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
    402 		for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
    403 			if (casematch(patp, arglist.list->text)) {
    404 				if (evalskip == 0) {
    405 					evaltree(cp->nclist.body, flags);
    406 					status = exitstatus;
    407 				}
    408 				goto out;
    409 			}
    410 		}
    411 	}
    412 out:
    413 	exitstatus = status;
    414 	popstackmark(&smark);
    415 }
    416 
    417 
    418 
    419 /*
    420  * Kick off a subshell to evaluate a tree.
    421  */
    422 
    423 STATIC void
    424 evalsubshell(union node *n, int flags)
    425 {
    426 	struct job *jp;
    427 	int backgnd = (n->type == NBACKGND);
    428 
    429 	expredir(n->nredir.redirect);
    430 	INTOFF;
    431 	jp = makejob(n, 1);
    432 	if (forkshell(jp, n, backgnd) == 0) {
    433 		INTON;
    434 		if (backgnd)
    435 			flags &=~ EV_TESTED;
    436 		redirect(n->nredir.redirect, 0);
    437 		/* never returns */
    438 		evaltree(n->nredir.n, flags | EV_EXIT);
    439 	}
    440 	if (! backgnd)
    441 		exitstatus = waitforjob(jp);
    442 	INTON;
    443 }
    444 
    445 
    446 
    447 /*
    448  * Compute the names of the files in a redirection list.
    449  */
    450 
    451 STATIC void
    452 expredir(union node *n)
    453 {
    454 	union node *redir;
    455 
    456 	for (redir = n ; redir ; redir = redir->nfile.next) {
    457 		struct arglist fn;
    458 		fn.lastp = &fn.list;
    459 		switch (redir->type) {
    460 		case NFROMTO:
    461 		case NFROM:
    462 		case NTO:
    463 		case NCLOBBER:
    464 		case NAPPEND:
    465 			expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
    466 			redir->nfile.expfname = fn.list->text;
    467 			break;
    468 		case NFROMFD:
    469 		case NTOFD:
    470 			if (redir->ndup.vname) {
    471 				expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
    472 				fixredir(redir, fn.list->text, 1);
    473 			}
    474 			break;
    475 		}
    476 	}
    477 }
    478 
    479 
    480 
    481 /*
    482  * Evaluate a pipeline.  All the processes in the pipeline are children
    483  * of the process creating the pipeline.  (This differs from some versions
    484  * of the shell, which make the last process in a pipeline the parent
    485  * of all the rest.)
    486  */
    487 
    488 STATIC void
    489 evalpipe(union node *n)
    490 {
    491 	struct job *jp;
    492 	struct nodelist *lp;
    493 	int pipelen;
    494 	int prevfd;
    495 	int pip[2];
    496 
    497 	TRACE(("evalpipe(0x%lx) called\n", (long)n));
    498 	pipelen = 0;
    499 	for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
    500 		pipelen++;
    501 	INTOFF;
    502 	jp = makejob(n, pipelen);
    503 	prevfd = -1;
    504 	for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
    505 		prehash(lp->n);
    506 		pip[1] = -1;
    507 		if (lp->next) {
    508 			if (sh_pipe(pip) < 0) {
    509 				close(prevfd);
    510 				error("Pipe call failed");
    511 			}
    512 		}
    513 		if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
    514 			INTON;
    515 			if (prevfd > 0) {
    516 				close(0);
    517 				copyfd(prevfd, 0);
    518 				close(prevfd);
    519 			}
    520 			if (pip[1] >= 0) {
    521 				close(pip[0]);
    522 				if (pip[1] != 1) {
    523 					close(1);
    524 					copyfd(pip[1], 1);
    525 					close(pip[1]);
    526 				}
    527 			}
    528 			evaltree(lp->n, EV_EXIT);
    529 		}
    530 		if (prevfd >= 0)
    531 			close(prevfd);
    532 		prevfd = pip[0];
    533 		close(pip[1]);
    534 	}
    535 	if (n->npipe.backgnd == 0) {
    536 		exitstatus = waitforjob(jp);
    537 		TRACE(("evalpipe:  job done exit status %d\n", exitstatus));
    538 	}
    539 	INTON;
    540 }
    541 
    542 
    543 
    544 /*
    545  * Execute a command inside back quotes.  If it's a builtin command, we
    546  * want to save its output in a block obtained from malloc.  Otherwise
    547  * we fork off a subprocess and get the output of the command via a pipe.
    548  * Should be called with interrupts off.
    549  */
    550 
    551 void
    552 evalbackcmd(union node *n, struct backcmd *result)
    553 {
    554 	int pip[2];
    555 	struct job *jp;
    556 	struct stackmark smark;		/* unnecessary */
    557 
    558 	setstackmark(&smark);
    559 	result->fd = -1;
    560 	result->buf = NULL;
    561 	result->nleft = 0;
    562 	result->jp = NULL;
    563 	if (n == NULL) {
    564 		goto out;
    565 	}
    566 #ifdef notyet
    567 	/*
    568 	 * For now we disable executing builtins in the same
    569 	 * context as the shell, because we are not keeping
    570 	 * enough state to recover from changes that are
    571 	 * supposed only to affect subshells. eg. echo "`cd /`"
    572 	 */
    573 	if (n->type == NCMD) {
    574 		exitstatus = oexitstatus;
    575 		evalcommand(n, EV_BACKCMD, result);
    576 	} else
    577 #endif
    578 	{
    579 		INTOFF;
    580 		if (sh_pipe(pip) < 0)
    581 			error("Pipe call failed");
    582 		jp = makejob(n, 1);
    583 		if (forkshell(jp, n, FORK_NOJOB) == 0) {
    584 			FORCEINTON;
    585 			close(pip[0]);
    586 			if (pip[1] != 1) {
    587 				close(1);
    588 				copyfd(pip[1], 1);
    589 				close(pip[1]);
    590 			}
    591 			eflag = 0;
    592 			evaltree(n, EV_EXIT);
    593 			/* NOTREACHED */
    594 		}
    595 		close(pip[1]);
    596 		result->fd = pip[0];
    597 		result->jp = jp;
    598 		INTON;
    599 	}
    600 out:
    601 	popstackmark(&smark);
    602 	TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
    603 		result->fd, result->buf, result->nleft, result->jp));
    604 }
    605 
    606 static const char *
    607 syspath(void)
    608 {
    609 	static char *sys_path = NULL;
    610 #ifndef __linux__
    611 	static int mib[] = {CTL_USER, USER_CS_PATH};
    612 #endif
    613 	static char def_path[] = "PATH=/usr/bin:/bin:/usr/sbin:/sbin";
    614 
    615 	if (sys_path == NULL) {
    616 #ifndef __linux__
    617 		size_t len;
    618 		if (sysctl(mib, 2, 0, &len, 0, 0) != -1 &&
    619 		    (sys_path = ckmalloc(len + 5)) != NULL &&
    620 		    sysctl(mib, 2, sys_path + 5, &len, 0, 0) != -1) {
    621 			memcpy(sys_path, "PATH=", 5);
    622 		} else
    623 #endif
    624 		{
    625 			ckfree(sys_path);
    626 			/* something to keep things happy */
    627 			sys_path = def_path;
    628 		}
    629 	}
    630 	return sys_path;
    631 }
    632 
    633 static int
    634 parse_command_args(int argc, char **argv, int *use_syspath)
    635 {
    636 	int sv_argc = argc;
    637 	char *cp, c;
    638 
    639 	*use_syspath = 0;
    640 
    641 	for (;;) {
    642 		argv++;
    643 		if (--argc == 0)
    644 			break;
    645 		cp = *argv;
    646 		if (*cp++ != '-')
    647 			break;
    648 		if (*cp == '-' && cp[1] == 0) {
    649 			argv++;
    650 			argc--;
    651 			break;
    652 		}
    653 		while ((c = *cp++)) {
    654 			switch (c) {
    655 			case 'p':
    656 				*use_syspath = 1;
    657 				break;
    658 			default:
    659 				/* run 'typecmd' for other options */
    660 				return 0;
    661 			}
    662 		}
    663 	}
    664 	return sv_argc - argc;
    665 }
    666 
    667 int vforked = 0;
    668 
    669 /*
    670  * Execute a simple command.
    671  */
    672 
    673 STATIC void
    674 evalcommand(union node *cmd, int flags, struct backcmd *backcmd)
    675 {
    676 	struct stackmark smark;
    677 	union node *argp;
    678 	struct arglist arglist;
    679 	struct arglist varlist;
    680 	char **argv;
    681 	int argc;
    682 	char **envp;
    683 	int varflag;
    684 	struct strlist *sp;
    685 	int mode;
    686 	int pip[2];
    687 	struct cmdentry cmdentry;
    688 	struct job *jp;
    689 	struct jmploc jmploc;
    690 	struct jmploc *volatile savehandler;
    691 	char *volatile savecmdname;
    692 	volatile struct shparam saveparam;
    693 	struct localvar *volatile savelocalvars;
    694 	volatile int e;
    695 	char *lastarg;
    696 	const char *path = pathval();
    697 	volatile int temp_path;
    698 #if __GNUC__
    699 	/* Avoid longjmp clobbering */
    700 	(void) &argv;
    701 	(void) &argc;
    702 	(void) &lastarg;
    703 	(void) &flags;
    704 #endif
    705 
    706 	vforked = 0;
    707 	/* First expand the arguments. */
    708 	TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
    709 	setstackmark(&smark);
    710 	back_exitstatus = 0;
    711 
    712 	arglist.lastp = &arglist.list;
    713 	varflag = 1;
    714 	/* Expand arguments, ignoring the initial 'name=value' ones */
    715 	for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
    716 		char *p = argp->narg.text;
    717 		if (varflag && is_name(*p)) {
    718 			do {
    719 				p++;
    720 			} while (is_in_name(*p));
    721 			if (*p == '=')
    722 				continue;
    723 		}
    724 		expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
    725 		varflag = 0;
    726 	}
    727 	*arglist.lastp = NULL;
    728 
    729 	expredir(cmd->ncmd.redirect);
    730 
    731 	/* Now do the initial 'name=value' ones we skipped above */
    732 	varlist.lastp = &varlist.list;
    733 	for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
    734 		char *p = argp->narg.text;
    735 		if (!is_name(*p))
    736 			break;
    737 		do
    738 			p++;
    739 		while (is_in_name(*p));
    740 		if (*p != '=')
    741 			break;
    742 		expandarg(argp, &varlist, EXP_VARTILDE);
    743 	}
    744 	*varlist.lastp = NULL;
    745 
    746 	argc = 0;
    747 	for (sp = arglist.list ; sp ; sp = sp->next)
    748 		argc++;
    749 	argv = stalloc(sizeof (char *) * (argc + 1));
    750 
    751 	for (sp = arglist.list ; sp ; sp = sp->next) {
    752 		TRACE(("evalcommand arg: %s\n", sp->text));
    753 		*argv++ = sp->text;
    754 	}
    755 	*argv = NULL;
    756 	lastarg = NULL;
    757 	if (iflag && funcnest == 0 && argc > 0)
    758 		lastarg = argv[-1];
    759 	argv -= argc;
    760 
    761 	/* Print the command if xflag is set. */
    762 	if (xflag) {
    763 		char sep = 0;
    764 		out2str(ps4val());
    765 		for (sp = varlist.list ; sp ; sp = sp->next) {
    766 			if (sep != 0)
    767 				outc(sep, &errout);
    768 			out2str(sp->text);
    769 			sep = ' ';
    770 		}
    771 		for (sp = arglist.list ; sp ; sp = sp->next) {
    772 			if (sep != 0)
    773 				outc(sep, &errout);
    774 			out2str(sp->text);
    775 			sep = ' ';
    776 		}
    777 		outc('\n', &errout);
    778 		flushout(&errout);
    779 	}
    780 
    781 	/* Now locate the command. */
    782 	if (argc == 0) {
    783 		cmdentry.cmdtype = CMDSPLBLTIN;
    784 		cmdentry.u.bltin = bltincmd;
    785 	} else {
    786 		static const char PATH[] = "PATH=";
    787 		int cmd_flags = DO_ERR;
    788 
    789 		/*
    790 		 * Modify the command lookup path, if a PATH= assignment
    791 		 * is present
    792 		 */
    793 		for (sp = varlist.list; sp; sp = sp->next)
    794 			if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0)
    795 				path = sp->text + sizeof(PATH) - 1;
    796 
    797 		do {
    798 			int argsused, use_syspath;
    799 			find_command(argv[0], &cmdentry, cmd_flags, path);
    800 			if (cmdentry.cmdtype == CMDUNKNOWN) {
    801 				exitstatus = 127;
    802 				flushout(&errout);
    803 				goto out;
    804 			}
    805 
    806 			/* implement the 'command' builtin here */
    807 			if (cmdentry.cmdtype != CMDBUILTIN ||
    808 			    cmdentry.u.bltin != bltincmd)
    809 				break;
    810 			cmd_flags |= DO_NOFUNC;
    811 			argsused = parse_command_args(argc, argv, &use_syspath);
    812 			if (argsused == 0) {
    813 				/* use 'type' builting to display info */
    814 				cmdentry.u.bltin = typecmd;
    815 				break;
    816 			}
    817 			argc -= argsused;
    818 			argv += argsused;
    819 			if (use_syspath)
    820 				path = syspath() + 5;
    821 		} while (argc != 0);
    822 		if (cmdentry.cmdtype == CMDSPLBLTIN && cmd_flags & DO_NOFUNC)
    823 			/* posix mandates that 'command <splbltin>' act as if
    824 			   <splbltin> was a normal builtin */
    825 			cmdentry.cmdtype = CMDBUILTIN;
    826 	}
    827 
    828 	/* Fork off a child process if necessary. */
    829 	if (cmd->ncmd.backgnd
    830 	 || (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)
    831 	 || ((flags & EV_BACKCMD) != 0
    832 	    && ((cmdentry.cmdtype != CMDBUILTIN && cmdentry.cmdtype != CMDSPLBLTIN)
    833 		 || cmdentry.u.bltin == dotcmd
    834 		 || cmdentry.u.bltin == evalcmd))) {
    835 		INTOFF;
    836 		jp = makejob(cmd, 1);
    837 		mode = cmd->ncmd.backgnd;
    838 		if (flags & EV_BACKCMD) {
    839 			mode = FORK_NOJOB;
    840 			if (sh_pipe(pip) < 0)
    841 				error("Pipe call failed");
    842 		}
    843 #ifdef DO_SHAREDVFORK
    844 		/* It is essential that if DO_SHAREDVFORK is defined that the
    845 		 * child's address space is actually shared with the parent as
    846 		 * we rely on this.
    847 		 */
    848 		if (cmdentry.cmdtype == CMDNORMAL) {
    849 			pid_t	pid;
    850 
    851 			savelocalvars = localvars;
    852 			localvars = NULL;
    853 			vforked = 1;
    854 			switch (pid = vfork()) {
    855 			case -1:
    856 				TRACE(("Vfork failed, errno=%d\n", errno));
    857 				INTON;
    858 				error("Cannot vfork");
    859 				break;
    860 			case 0:
    861 				/* Make sure that exceptions only unwind to
    862 				 * after the vfork(2)
    863 				 */
    864 				if (setjmp(jmploc.loc)) {
    865 					if (exception == EXSHELLPROC) {
    866 						/* We can't progress with the vfork,
    867 						 * so, set vforked = 2 so the parent
    868 						 * knows, and _exit();
    869 						 */
    870 						vforked = 2;
    871 						_exit(0);
    872 					} else {
    873 						_exit(exerrno);
    874 					}
    875 				}
    876 				savehandler = handler;
    877 				handler = &jmploc;
    878 				listmklocal(varlist.list, VEXPORT | VNOFUNC);
    879 				forkchild(jp, cmd, mode, vforked);
    880 				break;
    881 			default:
    882 				handler = savehandler;	/* restore from vfork(2) */
    883 				poplocalvars();
    884 				localvars = savelocalvars;
    885 				if (vforked == 2) {
    886 					vforked = 0;
    887 
    888 					(void)waitpid(pid, NULL, 0);
    889 					/* We need to progress in a normal fork fashion */
    890 					goto normal_fork;
    891 				}
    892 				vforked = 0;
    893 				forkparent(jp, cmd, mode, pid);
    894 				goto parent;
    895 			}
    896 		} else {
    897 normal_fork:
    898 #endif
    899 			if (forkshell(jp, cmd, mode) != 0)
    900 				goto parent;	/* at end of routine */
    901 			FORCEINTON;
    902 #ifdef DO_SHAREDVFORK
    903 		}
    904 #endif
    905 		if (flags & EV_BACKCMD) {
    906 			if (!vforked) {
    907 				FORCEINTON;
    908 			}
    909 			close(pip[0]);
    910 			if (pip[1] != 1) {
    911 				close(1);
    912 				copyfd(pip[1], 1);
    913 				close(pip[1]);
    914 			}
    915 		}
    916 		flags |= EV_EXIT;
    917 	}
    918 
    919 	/* This is the child process if a fork occurred. */
    920 	/* Execute the command. */
    921 	switch (cmdentry.cmdtype) {
    922 	case CMDFUNCTION:
    923 #ifdef DEBUG
    924 		trputs("Shell function:  ");  trargs(argv);
    925 #endif
    926 		redirect(cmd->ncmd.redirect, REDIR_PUSH);
    927 		saveparam = shellparam;
    928 		shellparam.malloc = 0;
    929 		shellparam.reset = 1;
    930 		shellparam.nparam = argc - 1;
    931 		shellparam.p = argv + 1;
    932 		shellparam.optnext = NULL;
    933 		INTOFF;
    934 		savelocalvars = localvars;
    935 		localvars = NULL;
    936 		INTON;
    937 		if (setjmp(jmploc.loc)) {
    938 			if (exception == EXSHELLPROC) {
    939 				freeparam((volatile struct shparam *)
    940 				    &saveparam);
    941 			} else {
    942 				freeparam(&shellparam);
    943 				shellparam = saveparam;
    944 			}
    945 			poplocalvars();
    946 			localvars = savelocalvars;
    947 			handler = savehandler;
    948 			longjmp(handler->loc, 1);
    949 		}
    950 		savehandler = handler;
    951 		handler = &jmploc;
    952 		listmklocal(varlist.list, 0);
    953 		/* stop shell blowing its stack */
    954 		if (++funcnest > 1000)
    955 			error("too many nested function calls");
    956 		evaltree(cmdentry.u.func, flags & EV_TESTED);
    957 		funcnest--;
    958 		INTOFF;
    959 		poplocalvars();
    960 		localvars = savelocalvars;
    961 		freeparam(&shellparam);
    962 		shellparam = saveparam;
    963 		handler = savehandler;
    964 		popredir();
    965 		INTON;
    966 		if (evalskip == SKIPFUNC) {
    967 			evalskip = 0;
    968 			skipcount = 0;
    969 		}
    970 		if (flags & EV_EXIT)
    971 			exitshell(exitstatus);
    972 		break;
    973 
    974 	case CMDBUILTIN:
    975 	case CMDSPLBLTIN:
    976 #ifdef DEBUG
    977 		trputs("builtin command:  ");  trargs(argv);
    978 #endif
    979 		mode = (cmdentry.u.bltin == execcmd) ? 0 : REDIR_PUSH;
    980 		if (flags == EV_BACKCMD) {
    981 			memout.nleft = 0;
    982 			memout.nextc = memout.buf;
    983 			memout.bufsize = 64;
    984 			mode |= REDIR_BACKQ;
    985 		}
    986 		e = -1;
    987 		savehandler = handler;
    988 		savecmdname = commandname;
    989 		handler = &jmploc;
    990 		if (!setjmp(jmploc.loc)) {
    991 			/* We need to ensure the command hash table isn't
    992 			 * corruped by temporary PATH assignments.
    993 			 * However we must ensure the 'local' command works!
    994 			 */
    995 			if (path != pathval() && (cmdentry.u.bltin == hashcmd ||
    996 			    cmdentry.u.bltin == typecmd)) {
    997 				savelocalvars = localvars;
    998 				localvars = 0;
    999 				mklocal(path - 5 /* PATH= */, 0);
   1000 				temp_path = 1;
   1001 			} else
   1002 				temp_path = 0;
   1003 			redirect(cmd->ncmd.redirect, mode);
   1004 
   1005 			/* exec is a special builtin, but needs this list... */
   1006 			cmdenviron = varlist.list;
   1007 			/* we must check 'readonly' flag for all builtins */
   1008 			listsetvar(varlist.list,
   1009 				cmdentry.cmdtype == CMDSPLBLTIN ? 0 : VNOSET);
   1010 			commandname = argv[0];
   1011 			/* initialize nextopt */
   1012 			argptr = argv + 1;
   1013 			optptr = NULL;
   1014 			/* and getopt */
   1015 #ifndef __linux__
   1016 			optreset = 1;
   1017 #endif
   1018 			optind = 1;
   1019 			exitstatus = cmdentry.u.bltin(argc, argv);
   1020 		} else {
   1021 			e = exception;
   1022 			exitstatus = e == EXINT ? SIGINT + 128 :
   1023 					e == EXEXEC ? exerrno : 2;
   1024 		}
   1025 		handler = savehandler;
   1026 		flushall();
   1027 		out1 = &output;
   1028 		out2 = &errout;
   1029 		freestdout();
   1030 		if (temp_path) {
   1031 			poplocalvars();
   1032 			localvars = savelocalvars;
   1033 		}
   1034 		cmdenviron = NULL;
   1035 		if (e != EXSHELLPROC) {
   1036 			commandname = savecmdname;
   1037 			if (flags & EV_EXIT)
   1038 				exitshell(exitstatus);
   1039 		}
   1040 		if (e != -1) {
   1041 			if ((e != EXERROR && e != EXEXEC)
   1042 			    || cmdentry.cmdtype == CMDSPLBLTIN)
   1043 				exraise(e);
   1044 			FORCEINTON;
   1045 		}
   1046 		if (cmdentry.u.bltin != execcmd)
   1047 			popredir();
   1048 		if (flags == EV_BACKCMD) {
   1049 			backcmd->buf = memout.buf;
   1050 			backcmd->nleft = memout.nextc - memout.buf;
   1051 			memout.buf = NULL;
   1052 		}
   1053 		break;
   1054 
   1055 	default:
   1056 #ifdef DEBUG
   1057 		trputs("normal command:  ");  trargs(argv);
   1058 #endif
   1059 		clearredir(vforked);
   1060 		redirect(cmd->ncmd.redirect, vforked ? REDIR_VFORK : 0);
   1061 		if (!vforked)
   1062 			for (sp = varlist.list ; sp ; sp = sp->next)
   1063 				setvareq(sp->text, VEXPORT|VSTACK);
   1064 		envp = environment();
   1065 		shellexec(argv, envp, path, cmdentry.u.index, vforked);
   1066 		break;
   1067 	}
   1068 	goto out;
   1069 
   1070 parent:	/* parent process gets here (if we forked) */
   1071 	if (mode == FORK_FG) {	/* argument to fork */
   1072 		exitstatus = waitforjob(jp);
   1073 	} else if (mode == FORK_NOJOB) {
   1074 		backcmd->fd = pip[0];
   1075 		close(pip[1]);
   1076 		backcmd->jp = jp;
   1077 	}
   1078 	FORCEINTON;
   1079 
   1080 out:
   1081 	if (lastarg)
   1082 		/* dsl: I think this is intended to be used to support
   1083 		 * '_' in 'vi' command mode during line editing...
   1084 		 * However I implemented that within libedit itself.
   1085 		 */
   1086 		setvar("_", lastarg, 0);
   1087 	popstackmark(&smark);
   1088 
   1089 	if (eflag && exitstatus && !(flags & EV_TESTED))
   1090 		exitshell(exitstatus);
   1091 }
   1092 
   1093 
   1094 /*
   1095  * Search for a command.  This is called before we fork so that the
   1096  * location of the command will be available in the parent as well as
   1097  * the child.  The check for "goodname" is an overly conservative
   1098  * check that the name will not be subject to expansion.
   1099  */
   1100 
   1101 STATIC void
   1102 prehash(union node *n)
   1103 {
   1104 	struct cmdentry entry;
   1105 
   1106 	if (n->type == NCMD && n->ncmd.args)
   1107 		if (goodname(n->ncmd.args->narg.text))
   1108 			find_command(n->ncmd.args->narg.text, &entry, 0,
   1109 				     pathval());
   1110 }
   1111 
   1112 
   1113 
   1114 /*
   1115  * Builtin commands.  Builtin commands whose functions are closely
   1116  * tied to evaluation are implemented here.
   1117  */
   1118 
   1119 /*
   1120  * No command given.
   1121  */
   1122 
   1123 int
   1124 bltincmd(int argc, char **argv)
   1125 {
   1126 	/*
   1127 	 * Preserve exitstatus of a previous possible redirection
   1128 	 * as POSIX mandates
   1129 	 */
   1130 	return back_exitstatus;
   1131 }
   1132 
   1133 
   1134 /*
   1135  * Handle break and continue commands.  Break, continue, and return are
   1136  * all handled by setting the evalskip flag.  The evaluation routines
   1137  * above all check this flag, and if it is set they start skipping
   1138  * commands rather than executing them.  The variable skipcount is
   1139  * the number of loops to break/continue, or the number of function
   1140  * levels to return.  (The latter is always 1.)  It should probably
   1141  * be an error to break out of more loops than exist, but it isn't
   1142  * in the standard shell so we don't make it one here.
   1143  */
   1144 
   1145 int
   1146 breakcmd(int argc, char **argv)
   1147 {
   1148 	int n = argc > 1 ? number(argv[1]) : 1;
   1149 
   1150 	if (n > loopnest)
   1151 		n = loopnest;
   1152 	if (n > 0) {
   1153 		evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
   1154 		skipcount = n;
   1155 	}
   1156 	return 0;
   1157 }
   1158 
   1159 
   1160 /*
   1161  * The return command.
   1162  */
   1163 
   1164 int
   1165 returncmd(int argc, char **argv)
   1166 {
   1167 	int ret = argc > 1 ? number(argv[1]) : exitstatus;
   1168 
   1169 	if (funcnest) {
   1170 		evalskip = SKIPFUNC;
   1171 		skipcount = 1;
   1172 		return ret;
   1173 	}
   1174 	else {
   1175 		/* Do what ksh does; skip the rest of the file */
   1176 		evalskip = SKIPFILE;
   1177 		skipcount = 1;
   1178 		return ret;
   1179 	}
   1180 }
   1181 
   1182 
   1183 int
   1184 falsecmd(int argc, char **argv)
   1185 {
   1186 	return 1;
   1187 }
   1188 
   1189 
   1190 int
   1191 truecmd(int argc, char **argv)
   1192 {
   1193 	return 0;
   1194 }
   1195 
   1196 
   1197 int
   1198 execcmd(int argc, char **argv)
   1199 {
   1200 	if (argc > 1) {
   1201 		struct strlist *sp;
   1202 
   1203 		iflag = 0;		/* exit on error */
   1204 		mflag = 0;
   1205 		optschanged();
   1206 		for (sp = cmdenviron; sp; sp = sp->next)
   1207 			setvareq(sp->text, VEXPORT|VSTACK);
   1208 		shellexec(argv + 1, environment(), pathval(), 0, 0);
   1209 	}
   1210 	return 0;
   1211 }
   1212 
   1213 static int
   1214 conv_time(clock_t ticks, char *seconds, size_t l)
   1215 {
   1216 	static clock_t tpm = 0;
   1217 	clock_t mins;
   1218 	int i;
   1219 
   1220 	mins = ticks / tpm;
   1221 	snprintf(seconds, l, "%.4f", (ticks - mins * tpm) * 60.0 / tpm );
   1222 
   1223 	if (seconds[0] == '6' && seconds[1] == '0') {
   1224 		/* 59.99995 got rounded up... */
   1225 		mins++;
   1226 		strlcpy(seconds, "0.0", l);
   1227 		return mins;
   1228 	}
   1229 
   1230 	/* suppress trailing zeros */
   1231 	i = strlen(seconds) - 1;
   1232 	for (; seconds[i] == '0' && seconds[i - 1] != '.'; i--)
   1233 		seconds[i] = 0;
   1234 	return mins;
   1235 }
   1236 
   1237 int
   1238 timescmd(int argc, char **argv)
   1239 {
   1240 	struct tms tms;
   1241 	int u, s, cu, cs;
   1242 	char us[8], ss[8], cus[8], css[8];
   1243 
   1244 	nextopt("");
   1245 
   1246 	times(&tms);
   1247 
   1248 	u = conv_time(tms.tms_utime, us, sizeof(us));
   1249 	s = conv_time(tms.tms_stime, ss, sizeof(ss));
   1250 	cu = conv_time(tms.tms_cutime, cus, sizeof(cus));
   1251 	cs = conv_time(tms.tms_cstime, css, sizeof(css));
   1252 
   1253 	outfmt(out1, "%dm%ss %dm%ss\n%dm%ss %dm%ss\n",
   1254 		u, us, s, ss, cu, cus, cs, css);
   1255 
   1256 	return 0;
   1257 }
   1258