source: trunk/ash/eval.c@ 3211

Last change on this file since 3211 was 2463, checked in by bird, 20 years ago

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