1 // exec.c - command execution

     2 //

     3 // © Portions Copyright (c) Symbian Software Ltd 2007 - 2008. All rights reserved.

     4 //

     5 /*

     6  * This file is part of zsh, the Z shell.

     7  *

     8  * Copyright (c) 1992-1997 Paul Falstad

     9  * All rights reserved.

    10  *

    11  * Permission is hereby granted, without written agreement and without

    12  * license or royalty fees, to use, copy, modify, and distribute this

    13  * software and to distribute modified versions of this software for any

    14  * purpose, provided that the above copyright notice and the following

    15  * two paragraphs appear in all copies of this software.

    16  *

    17  * In no event shall Paul Falstad or the Zsh Development Group be liable

    18  * to any party for direct, indirect, special, incidental, or consequential

    19  * damages arising out of the use of this software and its documentation,

    20  * even if Paul Falstad and the Zsh Development Group have been advised of

    21  * the possibility of such damage.

    22  *

    23  * Paul Falstad and the Zsh Development Group specifically disclaim any

    24  * warranties, including, but not limited to, the implied warranties of

    25  * merchantability and fitness for a particular purpose.  The software

    26  * provided hereunder is on an "as is" basis, and Paul Falstad and the

    27  * Zsh Development Group have no obligation to provide maintenance,

    28  * support, updates, enhancements, or modifications.

    29  *

    30  */

    31 

    32 #include "zsh.mdh"

    33 #include "exec.pro"

    34 

    35 #ifdef __SYMBIAN32__

    36 #ifdef __WINSCW__

    37 #pragma warn_unusedarg off

    38 #pragma warn_possunwant off

    39 #endif//__WINSCW__

    40 #endif//__SYMBIAN32__

    41 

    42 #ifdef __SYMBIAN32__

    43 #include <pthread.h>

    44 #include <sys/param.h>

    45 #include <sys/select.h>

    46 #include <sys/stat.h>

    47 #include <stdlib.h>

    48 #include "dummy.h"

    49 #endif //__SYMBIAN32__

    50 

    51 #ifdef __SYMBIAN32__

    52 typedef struct

    53 	{

    54 	Eprog p;

    55 	int dont_change_job;

    56 	int exiting;	

    57 	} st_exec;	

    58 #endif //	__SYMBIAN32__

    59 

    60 /* used to suppress ERREXIT and trapping of SIGZERR, SIGEXIT. */

    61 

    62 /**/

    63 int noerrexit;

    64 

    65 /* suppress error messages */

    66  

    67 /**/

    68 mod_export int noerrs;

    69  

    70 /* do not save history on exec and exit */

    71 

    72 /**/

    73 int nohistsave;

    74  

    75 /* error/break flag */

    76  

    77 /**/

    78 mod_export int errflag;

    79  

    80 /* Status of return from a trap */

    81  

    82 /**/

    83 int trapreturn;

    84  

    85 /* != 0 if this is a subshell */

    86  

    87 /**/

    88 int subsh;

    89  

    90 /* != 0 if we have a return pending */

    91  

    92 /**/

    93 mod_export int retflag;

    94 

    95 /**/

    96 long lastval2;

    97  

    98 /* The table of file descriptors.  A table element is zero if the  *

    99  * corresponding fd is not used by the shell.  It is greater than  *

   100  * 1 if the fd is used by a <(...) or >(...) substitution and 1 if *

   101  * it is an internal file descriptor which must be closed before   *

   102  * executing an external command.  The first ten elements of the   *

   103  * table is not used.  A table element is set by movefd and cleard *

   104  * by zclose.                                                      */

   105 

   106 /**/

   107 char *fdtable;

   108 

   109 /* The allocated size of fdtable */

   110 

   111 /**/

   112 int fdtable_size;

   113 

   114 /* The highest fd that marked with nonzero in fdtable */

   115 

   116 /**/

   117 int max_zsh_fd;

   118 

   119 /* input fd from the coprocess */

   120 

   121 /**/

   122 mod_export int coprocin;

   123 

   124 /* output fd from the coprocess */

   125 

   126 /**/

   127 mod_export int coprocout;

   128 

   129 /* != 0 if the line editor is active */

   130 

   131 /**/

   132 mod_export int zleactive;

   133 

   134 /* pid of process undergoing 'process substitution' */

   135  

   136 /**/

   137 pid_t cmdoutpid;

   138  

   139 /* exit status of process undergoing 'process substitution' */

   140  

   141 /**/

   142 int cmdoutval;

   143 

   144 /* The context in which a shell function is called, see SFC_* in zsh.h. */ 

   145 

   146 /**/

   147 mod_export int sfcontext;

   148 

   149 /* Stack to save some variables before executing a signal handler function */

   150 

   151 /**/

   152 struct execstack *exstack;

   153 

   154 /* Stack with names of functions currently active. */

   155 

   156 /**/

   157 mod_export Funcstack funcstack;

   158 

   159 #define execerr() if (!forked) { lastval = 1; goto done; } else _exit(1)

   160 

   161 static LinkList args;

   162 static int doneps4;

   163 static char *STTYval;

   164 

   165 /* Execution functions. */

   166 

   167 static int (*execfuncs[WC_COUNT-WC_CURSH]) _((Estate, int)) = {

   168     execcursh, exectime, execfuncdef, execfor, execselect,

   169     execwhile, execrepeat, execcase, execif, execcond,

   170     execarith, execautofn, exectry

   171 };

   172 

   173 /* structure for command builtin for when it is used with -v or -V */

   174 static struct builtin commandbn =

   175     BUILTIN(0, 0, bin_whence, 0, -1, BIN_COMMAND, "vV", NULL);

   176 

   177 

   178 /* parse string into a list */

   179 

   180 /**/

   181 mod_export Eprog

   182 parse_string(char *s)

   183 {

   184     Eprog p;

   185     int oldlineno = lineno;

   186 

   187     lexsave();

   188     inpush(s, INP_LINENO, NULL);

   189     strinbeg(0);

   190     lineno = 1;

   191     p = parse_list();

   192     lineno = oldlineno;

   193     if (tok == LEXERR && !lastval)

   194 	lastval = 1;

   195     strinend();

   196     inpop();

   197     lexrestore();

   198     return p;

   199 }

   200 

   201 /**/

   202 #ifdef HAVE_GETRLIMIT

   203 

   204 /* the resource limits for the shell and its children */

   205 

   206 /**/

   207 mod_export struct rlimit current_limits[RLIM_NLIMITS], limits[RLIM_NLIMITS];

   208  

   209 /**/

   210 mod_export int

   211 zsetlimit(int limnum, char *nam)

   212 {

   213     if (limits[limnum].rlim_max != current_limits[limnum].rlim_max ||

   214 	limits[limnum].rlim_cur != current_limits[limnum].rlim_cur) {

   215 	if (setrlimit(limnum, limits + limnum)) {

   216 	    if (nam)

   217 		zwarnnam(nam, "setrlimit failed: %e", NULL, errno);

   218 	    return -1;

   219 	}

   220 	current_limits[limnum] = limits[limnum];

   221     }

   222     return 0;

   223 }

   224 

   225 /**/

   226 mod_export int

   227 setlimits(char *nam)

   228 {

   229     int limnum;

   230     int ret = 0;

   231 

   232     for (limnum = 0; limnum < RLIM_NLIMITS; limnum++)

   233 	if (zsetlimit(limnum, nam))

   234 	    ret++;

   235     return ret;

   236 }

   237 

   238 /**/

   239 #endif /* HAVE_GETRLIMIT */

   240 

   241 /* fork and set limits */

   242 

   243 /**/

   244 #ifndef __SYMBIAN32__

   245 static pid_t

   246 zfork(struct timeval *tv)

   247 {

   248     pid_t pid;

   249     struct timezone dummy_tz;

   250 

   251     /*

   252      * Is anybody willing to explain this test?

   253      */

   254     if (thisjob != -1 && thisjob >= jobtabsize - 1 && !expandjobtab()) {

   255 	zerr("job table full", NULL, 0);

   256 	return -1;

   257     }

   258     if (tv)

   259 	gettimeofday(tv, &dummy_tz);

   260     pid = fork();

   261     if (pid == -1) {

   262 	zerr("fork failed: %e", NULL, errno);

   263 	return -1;

   264     }

   265 #ifdef HAVE_GETRLIMIT

   266     if (!pid)

   267 	/* set resource limits for the child process */

   268 	setlimits(NULL);

   269 #endif

   270     return pid;

   271 }

   272 #endif //__SYMBIAN32__

   273 

   274 /*

   275  *   Allen Edeln gebiet ich Andacht,

   276  *   Hohen und Niedern von Heimdalls Geschlecht;

   277  *   Ich will list_pipe's Wirken kuenden

   278  *   Die aeltesten Sagen, der ich mich entsinne...

   279  *

   280  * In most shells, if you do something like:

   281  *

   282  *   cat foo | while read a; do grep $a bar; done

   283  *

   284  * the shell forks and executes the loop in the sub-shell thus created.

   285  * In zsh this traditionally executes the loop in the current shell, which

   286  * is nice to have if the loop does something to change the shell, like

   287  * setting parameters or calling builtins.

   288  * Putting the loop in a sub-shell makes life easy, because the shell only

   289  * has to put it into the job-structure and then treats it as a normal

   290  * process. Suspending and interrupting is no problem then.

   291  * Some years ago, zsh either couldn't suspend such things at all, or

   292  * it got really messed up when users tried to do it. As a solution, we

   293  * implemented the list_pipe-stuff, which has since then become a reason

   294  * for many nightmares.

   295  * Pipelines like the one above are executed by the functions in this file

   296  * which call each other (and sometimes recursively). The one above, for

   297  * example would lead to a function call stack roughly like:

   298  *

   299  *  execlist->execpline->execcmd->execwhile->execlist->execpline

   300  *

   301  * (when waiting for the grep, ignoring execpline2 for now). At this time,

   302  * zsh has built two job-table entries for it: one for the cat and one for

   303  * the grep. If the user hits ^Z at this point (and jobbing is used), the 

   304  * shell is notified that the grep was suspended. The list_pipe flag is

   305  * used to tell the execpline where it was waiting that it was in a pipeline

   306  * with a shell construct at the end (which may also be a shell function or

   307  * several other things). When zsh sees the suspended grep, it forks to let

   308  * the sub-shell execute the rest of the while loop. The parent shell walks

   309  * up in the function call stack to the first execpline. There it has to find

   310  * out that it has just forked and then has to add information about the sub-

   311  * shell (its pid and the text for it) in the job entry of the cat. The pid

   312  * is passed down in the list_pipe_pid variable.

   313  * But there is a problem: the suspended grep is a child of the parent shell

   314  * and can't be adopted by the sub-shell. So the parent shell also has to 

   315  * keep the information about this process (more precisely: this pipeline)

   316  * by keeping the job table entry it created for it. The fact that there

   317  * are two jobs which have to be treated together is remembered by setting

   318  * the STAT_SUPERJOB flag in the entry for the cat-job (which now also

   319  * contains a process-entry for the whole loop -- the sub-shell) and by

   320  * setting STAT_SUBJOB in the job of the grep-job. With that we can keep

   321  * sub-jobs from being displayed and we can handle an fg/bg on the super-

   322  * job correctly. When the super-job is continued, the shell also wakes up

   323  * the sub-job. But then, the grep will exit sometime. Now the parent shell

   324  * has to remember not to try to wake it up again (in case of another ^Z).

   325  * It also has to wake up the sub-shell (which suspended itself immediately

   326  * after creation), so that the rest of the loop is executed by it.

   327  * But there is more: when the sub-shell is created, the cat may already

   328  * have exited, so we can't put the sub-shell in the process group of it.

   329  * In this case, we put the sub-shell in the process group of the parent

   330  * shell and in any case, the sub-shell has to put all commands executed

   331  * by it into its own process group, because only this way the parent

   332  * shell can control them since it only knows the process group of the sub-

   333  * shell. Of course, this information is also important when putting a job

   334  * in the foreground, where we have to attach its process group to the

   335  * controlling tty.

   336  * All this is made more difficult because we have to handle return values

   337  * correctly. If the grep is signaled, its exit status has to be propagated

   338  * back to the parent shell which needs it to set the exit status of the

   339  * super-job. And of course, when the grep is signaled (including ^C), the

   340  * loop has to be stopped, etc.

   341  * The code for all this is distributed over three files (exec.c, jobs.c,

   342  * and signals.c) and none of them is a simple one. So, all in all, there

   343  * may still be bugs, but considering the complexity (with race conditions,

   344  * signal handling, and all that), this should probably be expected.

   345  */

   346 

   347 /**/

   348 int list_pipe = 0, simple_pline = 0;

   349 

   350 static pid_t list_pipe_pid;

   351 static struct timeval list_pipe_start;

   352 static int nowait, pline_level = 0;

   353 static int list_pipe_child = 0, list_pipe_job;

   354 static char list_pipe_text[JOBTEXTSIZE];

   355 

   356 /* execute a current shell command */

   357 

   358 /**/

   359 static int

   360 execcursh(Estate state, int do_exec)

   361 {

   362     Wordcode end = state->pc + WC_CURSH_SKIP(state->pc[-1]);

   363 

   364     /* Skip word only used for try/always */

   365     state->pc++;

   366 

   367     if (!list_pipe && thisjob != list_pipe_job && !hasprocs(thisjob))

   368 	deletejob(jobtab + thisjob);

   369     cmdpush(CS_CURSH);

   370     execlist(state, 1, do_exec);

   371     cmdpop();

   372 

   373     state->pc = end;

   374 

   375     return lastval;

   376 }

   377 

   378 /* execve after handling $_ and #! */

   379 

   380 #define POUNDBANGLIMIT 64

   381 

   382 /**/

   383 static int

   384 zexecve(char *pth, char **argv)

   385 {

   386     int eno =0;

   387 #ifndef __SYMBIAN32__

   388     static char buf[PATH_MAX * 2];

   389     char **eep;

   390 

   391     unmetafy(pth, NULL);

   392     for (eep = argv; *eep; eep++)

   393 	if (*eep != pth)

   394 	    unmetafy(*eep, NULL);

   395     buf[0] = '_';

   396     buf[1] = '=';

   397     if (*pth == '/')

   398 	strcpy(buf + 2, pth);

   399     else

   400 	sprintf(buf + 2, "%s/%s", pwd, pth);

   401     zputenv(buf);

   402     closedumps();

   403     execve(pth, argv, environ);

   404 

   405     /* If the execve returns (which in general shouldn't happen),   *

   406      * then check for an errno equal to ENOEXEC.  This errno is set *

   407      * if the process file has the appropriate access permission,   *

   408      * but has an invalid magic number in its header.               */

   409     if ((eno = errno) == ENOEXEC) {

   410 	char execvebuf[POUNDBANGLIMIT + 1], *ptr, *ptr2, *argv0;

   411 	int fd, ct, t0;

   412 

   413 	if ((fd = open(pth, O_RDONLY|O_NOCTTY)) >= 0) {

   414 	    argv0 = *argv;

   415 	    *argv = pth;

   416 	    ct = read(fd, execvebuf, POUNDBANGLIMIT);

   417 	    close(fd);

   418 	    if (ct > 0) {

   419 		if (execvebuf[0] == '#') {

   420 		    if (execvebuf[1] == '!') {

   421 			for (t0 = 0; t0 != ct; t0++)

   422 			    if (execvebuf[t0] == '\n')

   423 				break;

   424 			while (inblank(execvebuf[t0]))

   425 			    execvebuf[t0--] = '\0';

   426 			execvebuf[POUNDBANGLIMIT] = '\0';

   427 			for (ptr = execvebuf + 2; *ptr && *ptr == ' '; ptr++);

   428 			for (ptr2 = ptr; *ptr && *ptr != ' '; ptr++);

   429 			if (*ptr) {

   430 			    *ptr = '\0';

   431 			    argv[-2] = ptr2;

   432 			    argv[-1] = ptr + 1;

   433 			    execve(ptr2, argv - 2, environ);

   434 			} else {

   435 			    argv[-1] = ptr2;

   436 			    execve(ptr2, argv - 1, environ);

   437 			}

   438 		    } else {

   439 			argv[-1] = "sh";

   440 			execve("/bin/sh", argv - 1, environ);

   441 		    }

   442 		} else {

   443 		    for (t0 = 0; t0 != ct; t0++)

   444 			if (!execvebuf[t0])

   445 			    break;

   446 		    if (t0 == ct) {

   447 			argv[-1] = "sh";

   448 			execve("/bin/sh", argv - 1, environ);

   449 		    }

   450 		}

   451 	    } else

   452 		eno = errno;

   453 	    *argv = argv0;

   454 	} else

   455 	    eno = errno;

   456     }

   457     /* restore the original arguments and path but do not bother with *

   458      * null characters as these cannot be passed to external commands *

   459      * anyway.  So the result is truncated at the first null char.    */

   460     pth = metafy(pth, -1, META_NOALLOC);

   461     for (eep = argv; *eep; eep++)

   462 	if (*eep != pth)

   463 	    (void) metafy(*eep, -1, META_NOALLOC);

   464 #endif//__SYMBIAN32__

   465 	

   466     return eno;

   467 }

   468 

   469 #define MAXCMDLEN (PATH_MAX*4)

   470 

   471 /* test whether we really want to believe the error number */

   472 

   473 /**/

   474 static int

   475 isgooderr(int e, char *dir)

   476 {

   477     /*

   478      * Maybe the directory was unreadable, or maybe it wasn't

   479      * even a directory. 

   480      */

   481     return ((e != EACCES || !access(dir, X_OK)) &&

   482 	    e != ENOENT && e != ENOTDIR); 

   483 }

   484 

   485 /* execute an external command */

   486 

   487 /**/

   488 void

   489 execute(UNUSED(Cmdnam cmdname), int dash, int defpath)

   490 {

   491     Cmdnam cn;

   492     char buf[MAXCMDLEN], buf2[MAXCMDLEN];

   493     char *s, *z, *arg0;

   494     char **argv, **pp;

   495     int eno = 0, ee;

   496 

   497     arg0 = (char *) peekfirst(args);

   498     if (isset(RESTRICTED) && (strchr(arg0, '/') || defpath)) {

   499 	zerr("%s: restricted", arg0, 0);

   500 	_exit(1);

   501     }

   502 

   503     /* If the parameter STTY is set in the command's environment, *

   504      * we first run the stty command with the value of this       *

   505      * parameter as it arguments.                                 */

   506     if ((s = STTYval) && isatty(0) && (GETPGRP() == getpid())) {

   507 	LinkList exargs = args;

   508 	char *t = tricat("stty", " ", s);

   509 

   510 	STTYval = 0;	/* this prevents infinite recursion */

   511 	zsfree(s);

   512 	args = NULL;

   513 	execstring(t, 1, 0);

   514 	zsfree(t);

   515 	args = exargs;

   516     } else if (s) {

   517 	STTYval = 0;

   518 	zsfree(s);

   519     }

   520 

   521     /* If ARGV0 is in the commands environment, we use *

   522      * that as argv[0] for this external command       */

   523     if (unset(RESTRICTED) && (z = zgetenv("ARGV0"))) {

   524 	setdata(firstnode(args), (void *) ztrdup(z));

   525 	delenvvalue(z - 6);

   526     } else if (dash) {

   527     /* Else if the pre-command `-' was given, we add `-' *

   528      * to the front of argv[0] for this command.         */

   529 	sprintf(buf2, "-%s", arg0);

   530 	setdata(firstnode(args), (void *) ztrdup(buf2));

   531     }

   532 

   533     argv = makecline(args);

   534     closem(3);

   535     child_unblock();

   536     if ((int) strlen(arg0) >= PATH_MAX) {

   537 	zerr("command too long: %s", arg0, 0);

   538 	_exit(1);

   539     }

   540     for (s = arg0; *s; s++)

   541 	if (*s == '/') {

   542 	    errno = zexecve(arg0, argv);

   543 	    if (arg0 == s || unset(PATHDIRS) ||

   544 		(arg0[0] == '.' && (arg0 + 1 == s ||

   545 				    (arg0[1] == '.' && arg0 + 2 == s)))) {

   546 		zerr("%e: %s", arg0, errno);

   547 		_exit((errno == EACCES || errno == ENOEXEC) ? 126 : 127);

   548 	    }

   549 	    break;

   550 	}

   551 

   552     /* for command -p, search the default path */ 

   553     if (defpath) {

   554 	char *s, pbuf[PATH_MAX];

   555 	char *dptr, *pe, *ps = DEFAULT_PATH;

   556 

   557 	for(;ps;ps = pe ? pe+1 : NULL) {

   558 	    pe = strchr(ps, ':');

   559 	    if (*ps == '/') {

   560 		s = pbuf;

   561 		if (pe)

   562 		    struncpy(&s, ps, pe-ps);

   563 		else

   564 		    strucpy(&s, ps);

   565 		*s++ = '/';

   566 		if ((s - pbuf) + strlen(arg0) >= PATH_MAX)

   567 		    continue;

   568 		strucpy(&s, arg0);

   569 		if (iscom(pbuf))

   570 		    break;

   571 	    }

   572 	}

   573 

   574 	if (!ps) {

   575 	    zerr("command not found: %s", arg0, 0);

   576 	    _exit(127);

   577 	}

   578 

   579 	ee = zexecve(pbuf, argv);

   580 

   581 	if ((dptr = strrchr(pbuf, '/')))

   582 	    *dptr = '\0';

   583 	if (isgooderr(ee, *pbuf ? pbuf : "/"))

   584 	    eno = ee;

   585 

   586     } else {

   587    

   588 	if ((cn = (Cmdnam) cmdnamtab->getnode(cmdnamtab, arg0))) {

   589 	    char nn[PATH_MAX], *dptr;

   590 

   591 	    if (cn->flags & HASHED)

   592 		strcpy(nn, cn->u.cmd);

   593 	    else {

   594 		for (pp = path; pp < cn->u.name; pp++)

   595 		    if (!**pp || (**pp == '.' && (*pp)[1] == '\0')) {

   596 			ee = zexecve(arg0, argv);

   597 			if (isgooderr(ee, *pp))

   598 			    eno = ee;

   599 		    } else if (**pp != '/') {

   600 			z = buf;

   601 			strucpy(&z, *pp);

   602 			*z++ = '/';

   603 			strcpy(z, arg0);

   604 			ee = zexecve(buf, argv);

   605 			if (isgooderr(ee, *pp))

   606 			    eno = ee;

   607 		    }

   608 		strcpy(nn, cn->u.name ? *(cn->u.name) : "");

   609 		strcat(nn, "/");

   610 		strcat(nn, cn->nam);

   611 	    }

   612 	    ee = zexecve(nn, argv);

   613 

   614 	    if ((dptr = strrchr(nn, '/')))

   615 		*dptr = '\0';

   616 	    if (isgooderr(ee, *nn ? nn : "/"))

   617 		eno = ee;

   618 	}

   619 	for (pp = path; *pp; pp++)

   620 	    if (!(*pp)[0] || ((*pp)[0] == '.' && !(*pp)[1])) {

   621 		ee = zexecve(arg0, argv);

   622 		if (isgooderr(ee, *pp))

   623 		    eno = ee;

   624 	    } else {

   625 		z = buf;

   626 		strucpy(&z, *pp);

   627 		*z++ = '/';

   628 		strcpy(z, arg0);

   629 		ee = zexecve(buf, argv);

   630 		if (isgooderr(ee, *pp))

   631 		    eno = ee;

   632 	    }

   633     }

   634 

   635     if (eno)

   636 	zerr("%e: %s", arg0, eno);

   637     else

   638 	zerr("command not found: %s", arg0, 0);

   639     _exit((eno == EACCES || eno == ENOEXEC) ? 126 : 127);

   640 }

   641 

   642 #define RET_IF_COM(X) { if (iscom(X)) return docopy ? dupstring(X) : arg0; }

   643 

   644 /*

   645  * Get the full pathname of an external command.

   646  * If the second argument is zero, return the first argument if found;

   647  * if non-zero, return the path using heap memory.  (RET_IF_COM(X), above).

   648  */

   649 

   650 /**/

   651 mod_export char *

   652 findcmd(char *arg0, int docopy)

   653 {

   654     char **pp;

   655     char *z, *s, buf[MAXCMDLEN];

   656     Cmdnam cn;

   657 

   658     cn = (Cmdnam) cmdnamtab->getnode(cmdnamtab, arg0);

   659     if (!cn && isset(HASHCMDS))

   660 	cn = hashcmd(arg0, path);

   661     if ((int) strlen(arg0) > PATH_MAX)

   662 	return NULL;

   663     for (s = arg0; *s; s++)

   664 	if (*s == '/') {

   665 	    RET_IF_COM(arg0);

   666 	    if (arg0 == s || unset(PATHDIRS)) {

   667 		return NULL;

   668 	    }

   669 	    break;

   670 	}

   671     if (cn) {

   672 	char nn[PATH_MAX];

   673 

   674 	if (cn->flags & HASHED)

   675 	    strcpy(nn, cn->u.cmd);

   676 	else {

   677 	    for (pp = path; pp < cn->u.name; pp++)

   678 		if (**pp != '/') {

   679 		    z = buf;

   680 		    if (**pp) {

   681 			strucpy(&z, *pp);

   682 			*z++ = '/';

   683 		    }

   684 		    strcpy(z, arg0);

   685 		    RET_IF_COM(buf);

   686 		}

   687 	    strcpy(nn, cn->u.name ? *(cn->u.name) : "");

   688 	    strcat(nn, "/");

   689 	    strcat(nn, cn->nam);

   690 	}

   691 	RET_IF_COM(nn);

   692     }

   693     for (pp = path; *pp; pp++) {

   694 	z = buf;

   695 	if (**pp) {

   696 	    strucpy(&z, *pp);

   697 	    *z++ = '/';

   698 	}

   699 	strcpy(z, arg0);

   700 	RET_IF_COM(buf);

   701     }

   702     return NULL;

   703 }

   704 

   705 /**/

   706 int

   707 iscom(char *s)

   708 {

   709     struct stat statbuf;

   710     char *us = unmeta(s);

   711 

   712     return (access(us, X_OK) == 0 && stat(us, &statbuf) >= 0 &&

   713 	    S_ISREG(statbuf.st_mode));

   714 }

   715 

   716 /**/

   717 int

   718 isreallycom(Cmdnam cn)

   719 {

   720     char fullnam[MAXCMDLEN];

   721 

   722     if (cn->flags & HASHED)

   723 	strcpy(fullnam, cn->u.cmd);

   724     else if (!cn->u.name)

   725 	return 0;

   726     else {

   727 	strcpy(fullnam, *(cn->u.name));

   728 	strcat(fullnam, "/");

   729 	strcat(fullnam, cn->nam);

   730     }

   731     return iscom(fullnam);

   732 }

   733 

   734 /**/

   735 int

   736 isrelative(char *s)

   737 {

   738     if (*s != '/')

   739 	return 1;

   740     for (; *s; s++)

   741 	if (*s == '.' && s[-1] == '/' &&

   742 	    (s[1] == '/' || s[1] == '\0' ||

   743 	     (s[1] == '.' && (s[2] == '/' || s[2] == '\0'))))

   744 	    return 1;

   745     return 0;

   746 }

   747 

   748 /**/

   749 mod_export Cmdnam

   750 hashcmd(char *arg0, char **pp)

   751 {

   752     Cmdnam cn;

   753     char *s, buf[PATH_MAX];

   754     char **pq;

   755 

   756     for (; *pp; pp++)

   757 	if (**pp == '/') {

   758 	    s = buf;

   759 	    strucpy(&s, *pp);

   760 	    *s++ = '/';

   761 	    if ((s - buf) + strlen(arg0) >= PATH_MAX)

   762 		continue;

   763 	    strcpy(s, arg0);

   764 	    if (iscom(buf))

   765 		break;

   766 	}

   767 

   768     if (!*pp)

   769 	return NULL;

   770 

   771     cn = (Cmdnam) zshcalloc(sizeof *cn);

   772     cn->flags = 0;

   773     cn->u.name = pp;

   774     cmdnamtab->addnode(cmdnamtab, ztrdup(arg0), cn);

   775 

   776     if (isset(HASHDIRS)) {

   777 	for (pq = pathchecked; pq <= pp; pq++)

   778 	    hashdir(pq);

   779 	pathchecked = pp + 1;

   780     }

   781 

   782     return cn;

   783 }

   784 

   785 /* execute a string */

   786 

   787 /**/

   788 mod_export void

   789 execstring(char *s, int dont_change_job, int exiting)

   790 {

   791     Eprog prog;

   792 

   793     pushheap();

   794     if ((prog = parse_string(s)))

   795 	execode(prog, dont_change_job, exiting);

   796     popheap();

   797 }

   798 

   799 

   800 #ifdef __SYMBIAN32__	

   801 mod_export

   802 void* execode_wrap(void* any)

   803 	{

   804 		st_exec *st=(st_exec*)any;

   805 		if(st)

   806 			execode(st->p, st->dont_change_job, st->exiting);

   807 		return NULL;

   808 	}

   809 #endif //__SYMBIAN32__	

   810 	

   811 /**/

   812 mod_export void

   813 execode(Eprog p, int dont_change_job, int exiting)

   814 {

   815     struct estate s;

   816 

   817     s.prog = p;

   818     s.pc = p->prog;

   819     s.strs = p->strs;

   820     useeprog(p);		/* Mark as in use */

   821 

   822     execlist(&s, dont_change_job, exiting);

   823 

   824     freeeprog(p);		/* Free if now unused */

   825 }

   826 

   827 /* Execute a simplified command. This is used to execute things that

   828  * will run completely in the shell, so that we can by-pass all that

   829  * nasty job-handling and redirection stuff in execpline and execcmd. */

   830 

   831 /**/

   832 static int

   833 execsimple(Estate state)

   834 {

   835     wordcode code = *state->pc++;

   836     int lv;

   837 

   838     if (errflag)

   839 	return (lastval = 1);

   840 

   841     /* In evaluated traps, don't modify the line number. */

   842     if ((!intrap || trapisfunc) && !ineval && code)

   843 	lineno = code - 1;

   844 

   845     code = wc_code(*state->pc++);

   846 

   847     if (code == WC_ASSIGN) {

   848 	cmdoutval = 0;

   849 	addvars(state, state->pc - 1, 0);

   850 	if (isset(XTRACE)) {

   851 	    fputc('\n', xtrerr);

   852 	    fflush(xtrerr);

   853 	}

   854 	lv = (lastval ? lastval : cmdoutval);

   855     } else

   856 	lv = (execfuncs[code - WC_CURSH])(state, 0);

   857     	

   858     return lastval = lv;

   859 }

   860 

   861 /* Main routine for executing a list.                                *

   862  * exiting means that the (sub)shell we are in is a definite goner   *

   863  * after the current list is finished, so we may be able to exec the *

   864  * last command directly instead of forking.  If dont_change_job is  *

   865  * nonzero, then restore the current job number after executing the  *

   866  * list.                                                             */

   867 

   868 /**/

   869 void

   870 execlist(Estate state, int dont_change_job, int exiting)

   871 {

   872     static int donetrap;

   873     Wordcode next;

   874     wordcode code;

   875     int ret, cj, csp, ltype;

   876     int old_pline_level, old_list_pipe, oldlineno;

   877     /*

   878      * ERREXIT only forces the shell to exit if the last command in a &&

   879      * or || fails.  This is the case even if an earlier command is a

   880      * shell function or other current shell structure, so we have to set

   881      * noerrexit here if the sublist is not of type END.

   882      */

   883     int oldnoerrexit = noerrexit;

   884 

   885     cj = thisjob;

   886     old_pline_level = pline_level;

   887     old_list_pipe = list_pipe;

   888     oldlineno = lineno;

   889 

   890     if (sourcelevel && unset(SHINSTDIN))

   891 	pline_level = list_pipe = 0;

   892 

   893     /* Loop over all sets of comands separated by newline, *

   894      * semi-colon or ampersand (`sublists').               */

   895     code = *state->pc++;

   896     while (wc_code(code) == WC_LIST && !breaks && !retflag) {

   897 	ltype = WC_LIST_TYPE(code);

   898 	csp = cmdsp;

   899 

   900 	if (ltype & Z_SIMPLE) {

   901 	    next = state->pc + WC_LIST_SKIP(code);

   902 	    execsimple(state);

   903 	    state->pc = next;

   904 	    goto sublist_done;

   905 	}

   906 	/* Reset donetrap:  this ensures that a trap is only *

   907 	 * called once for each sublist that fails.          */

   908 	donetrap = 0;

   909 

   910 	/* Loop through code followed by &&, ||, or end of sublist. */

   911 	code = *state->pc++;

   912 	while (wc_code(code) == WC_SUBLIST) {

   913 	    next = state->pc + WC_SUBLIST_SKIP(code);

   914 	    if (!oldnoerrexit)

   915 		noerrexit = (WC_SUBLIST_TYPE(code) != WC_SUBLIST_END);

   916 	    switch (WC_SUBLIST_TYPE(code)) {

   917 	    case WC_SUBLIST_END:

   918 		/* End of sublist; just execute, ignoring status. */

   919 		if (WC_SUBLIST_FLAGS(code) & WC_SUBLIST_SIMPLE)

   920 		    execsimple(state);

   921 		else

   922 		    execpline(state, code, ltype, (ltype & Z_END) && exiting);

   923 		state->pc = next;

   924 		goto sublist_done;

   925 		break;

   926 	    case WC_SUBLIST_AND:

   927 		/* If the return code is non-zero, we skip pipelines until *

   928 		 * we find a sublist followed by ORNEXT.                   */

   929 		if ((ret = ((WC_SUBLIST_FLAGS(code) & WC_SUBLIST_SIMPLE) ?

   930 			    execsimple(state) :

   931 			    execpline(state, code, Z_SYNC, 0)))) {

   932 		    state->pc = next;

   933 		    code = *state->pc++;

   934 		    next = state->pc + WC_SUBLIST_SKIP(code);

   935 		    while (wc_code(code) == WC_SUBLIST &&

   936 			   WC_SUBLIST_TYPE(code) == WC_SUBLIST_AND) {

   937 			state->pc = next;

   938 			code = *state->pc++;

   939 			next = state->pc + WC_SUBLIST_SKIP(code);

   940 		    }

   941 		    if (wc_code(code) != WC_SUBLIST) {

   942 			/* We've skipped to the end of the list, not executing *

   943 			 * the final pipeline, so don't perform error handling *

   944 			 * for this sublist.                                   */

   945 			donetrap = 1;

   946 			goto sublist_done;

   947 		    } else if (WC_SUBLIST_TYPE(code) == WC_SUBLIST_END) {

   948 			donetrap = 1;

   949 			/*

   950 			 * Treat this in the same way as if we reached

   951 			 * the end of the sublist normally.

   952 			 */

   953 			state->pc = next;

   954 			goto sublist_done;

   955 		    }

   956 		}

   957 		cmdpush(CS_CMDAND);

   958 		break;

   959 	    case WC_SUBLIST_OR:

   960 		/* If the return code is zero, we skip pipelines until *

   961 		 * we find a sublist followed by ANDNEXT.              */

   962 		if (!(ret = ((WC_SUBLIST_FLAGS(code) & WC_SUBLIST_SIMPLE) ?

   963 			     execsimple(state) :

   964 			     execpline(state, code, Z_SYNC, 0)))) {

   965 		    state->pc = next;

   966 		    code = *state->pc++;

   967 		    next = state->pc + WC_SUBLIST_SKIP(code);

   968 		    while (wc_code(code) == WC_SUBLIST &&

   969 			   WC_SUBLIST_TYPE(code) == WC_SUBLIST_OR) {

   970 			state->pc = next;

   971 			code = *state->pc++;

   972 			next = state->pc + WC_SUBLIST_SKIP(code);

   973 		    }

   974 		    if (wc_code(code) != WC_SUBLIST) {

   975 			/* We've skipped to the end of the list, not executing *

   976 			 * the final pipeline, so don't perform error handling *

   977 			 * for this sublist.                                   */

   978 			donetrap = 1;

   979 			goto sublist_done;

   980 		    } else if (WC_SUBLIST_TYPE(code) == WC_SUBLIST_END) {

   981 			donetrap = 1;

   982 			/*

   983 			 * Treat this in the same way as if we reached

   984 			 * the end of the sublist normally.

   985 			 */

   986 			state->pc = next;

   987 			goto sublist_done;

   988 		    }

   989 		}

   990 		cmdpush(CS_CMDOR);

   991 		break;

   992 	    }

   993 	    state->pc = next;

   994 	    code = *state->pc++;

   995 	}

   996 	state->pc--;

   997 sublist_done:

   998 

   999 	noerrexit = oldnoerrexit;

  1000 

  1001 	if (sigtrapped[SIGDEBUG]) {

  1002 	    exiting = donetrap;

  1003 	    ret = lastval;

  1004 	    dotrap(SIGDEBUG);

  1005 	    lastval = ret;

  1006 	    donetrap = exiting;

  1007 	    noerrexit = oldnoerrexit;

  1008 	}

  1009 

  1010 	cmdsp = csp;

  1011 

  1012 	/* Check whether we are suppressing traps/errexit *

  1013 	 * (typically in init scripts) and if we haven't  *

  1014 	 * already performed them for this sublist.       */

  1015 	if (!noerrexit && !donetrap) {

  1016 	    if (sigtrapped[SIGZERR] && lastval) {

  1017 		dotrap(SIGZERR);

  1018 		donetrap = 1;

  1019 	    }

  1020 	    if (lastval) {

  1021 		int errreturn = isset(ERRRETURN) && 

  1022 		    (isset(INTERACTIVE) || locallevel || sourcelevel);

  1023 		int errexit = isset(ERREXIT) || 

  1024 		    (isset(ERRRETURN) && !errreturn);

  1025 		if (errexit) {

  1026 		    if (sigtrapped[SIGEXIT])

  1027 			dotrap(SIGEXIT);

  1028 		    if (mypid != getpid())

  1029 			_exit(lastval);

  1030 		    else

  1031 			exit(lastval);

  1032 		}

  1033 		if (errreturn) {

  1034 		    retflag = 1;

  1035 		    breaks = loops;

  1036 		}

  1037 	    }

  1038 	}

  1039 	if (ltype & Z_END)

  1040 	    break;

  1041 	code = *state->pc++;

  1042     }

  1043     pline_level = old_pline_level;

  1044     list_pipe = old_list_pipe;

  1045     lineno = oldlineno;

  1046     if (dont_change_job)

  1047 	thisjob = cj;

  1048 }

  1049 

  1050 /* Execute a pipeline.                                                *

  1051  * last1 is a flag that this command is the last command in a shell   *

  1052  * that is about to exit, so we can exec instead of forking.  It gets *

  1053  * passed all the way down to execcmd() which actually makes the      *

  1054  * decision.  A 0 is always passed if the command is not the last in  *

  1055  * the pipeline.  This function assumes that the sublist is not NULL. *

  1056  * If last1 is zero but the command is at the end of a pipeline, we   *

  1057  * pass 2 down to execcmd().                                          *

  1058  */

  1059 

  1060 /**/

  1061 static int

  1062 execpline(Estate state, wordcode slcode, int how, int last1)

  1063 {

  1064     int ipipe[2], opipe[2];

  1065     int pj, newjob;

  1066     int old_simple_pline = simple_pline;

  1067     int slflags = WC_SUBLIST_FLAGS(slcode);

  1068     wordcode code = *state->pc++;

  1069     static int lastwj, lpforked;

  1070 

  1071     if (wc_code(code) != WC_PIPE)

  1072 	return lastval = (slflags & WC_SUBLIST_NOT) != 0;

  1073     else if (slflags & WC_SUBLIST_NOT)

  1074 	last1 = 0;

  1075 

  1076     pj = thisjob;

  1077     ipipe[0] = ipipe[1] = opipe[0] = opipe[1] = 0;

  1078     child_block();

  1079 

  1080     /*

  1081      * Get free entry in job table and initialize it.

  1082      * This is currently the only call to initjob(), so this

  1083      * is also the only place where we can expand the job table

  1084      * under us.

  1085      */

  1086     if ((thisjob = newjob = initjob()) == -1) {

  1087 	child_unblock();

  1088 	return 1;

  1089     }

  1090     if (how & Z_TIMED)

  1091 	jobtab[thisjob].stat |= STAT_TIMED;

  1092 

  1093     if (slflags & WC_SUBLIST_COPROC) {

  1094 	how = Z_ASYNC;

  1095 	if (coprocin >= 0) {

  1096 	    zclose(coprocin);

  1097 	    zclose(coprocout);

  1098 	}

  1099 	mpipe(ipipe);

  1100 	mpipe(opipe);

  1101 	coprocin = ipipe[0];

  1102 	coprocout = opipe[1];

  1103 	fdtable[coprocin] = fdtable[coprocout] = 0;

  1104     }

  1105     /* This used to set list_pipe_pid=0 unconditionally, but in things

  1106      * like `ls|if true; then sleep 20; cat; fi' where the sleep was

  1107      * stopped, the top-level execpline() didn't get the pid for the

  1108      * sub-shell because it was overwritten. */

  1109     if (!pline_level++) {

  1110         list_pipe_pid = 0;

  1111 	nowait = 0;

  1112 	simple_pline = (WC_PIPE_TYPE(code) == WC_PIPE_END);

  1113 	list_pipe_job = newjob;

  1114     }

  1115     lastwj = lpforked = 0;

  1116     execpline2(state, code, how, opipe[0], ipipe[1], last1);

  1117     pline_level--;

  1118     if (how & Z_ASYNC) {

  1119 	lastwj = newjob;

  1120 

  1121         if (thisjob == list_pipe_job)

  1122             list_pipe_job = 0;

  1123 	jobtab[thisjob].stat |= STAT_NOSTTY;

  1124 	if (slflags & WC_SUBLIST_COPROC) {

  1125 	    zclose(ipipe[1]);

  1126 	    zclose(opipe[0]);

  1127 	}

  1128 	if (how & Z_DISOWN) {

  1129 	    deletejob(jobtab + thisjob);

  1130 	    thisjob = -1;

  1131 	}

  1132 	else

  1133 	    spawnjob();

  1134 	child_unblock();