STATIC void
evalpipe(union node *n)
{
struct job *jp;
struct nodelist *lp;
int pipelen;
int prevfd;
int pip[2];
TRACE(("evalpipe(0x%lx) called\n", (long)n));
pipelen = 0;
for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
pipelen++;
INTOFF;
jp = makejob(n, pipelen);
prevfd = -1;
for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
prehash(lp->n);
pip[1] = -1;
if (lp->next) {
if (sh_pipe(pip) < 0) {
if (prevfd >= 0)
close(prevfd);
error("Pipe call failed");
}
}
if (forkshell(jp, lp->n, n->npipe.backgnd ? FORK_BG : FORK_FG) == 0) {
INTON;
if (prevfd > 0) {
close(0);
copyfd(prevfd, 0, 1, 0);
close(prevfd);
}
if (pip[1] >= 0) {
close(pip[0]);
if (pip[1] != 1) {
close(1);
copyfd(pip[1], 1, 1, 0);
close(pip[1]);
}
}
evaltree(lp->n, EV_EXIT);
}
if (prevfd >= 0)
close(prevfd);
prevfd = pip[0];
close(pip[1]);
}
if (n->npipe.backgnd == 0) {
exitstatus = waitforjob(jp);
TRACE(("evalpipe: job done exit status %d\n", exitstatus));
} else
exitstatus = 0;
INTON;
}
void
evalbackcmd(union node *n, struct backcmd *result)
{
int pip[2];
struct job *jp;
struct stackmark smark; /* unnecessary */
setstackmark(&smark);
result->fd = -1;
result->buf = NULL;
result->nleft = 0;
result->jp = NULL;
if (nflag || n == NULL) {
goto out;
}
#ifdef notyet
/*
* For now we disable executing builtins in the same
* context as the shell, because we are not keeping
* enough state to recover from changes that are
* supposed only to affect subshells. eg. echo "`cd /`"
*/
if (n->type == NCMD) {
exitstatus = oexitstatus;
evalcommand(n, EV_BACKCMD, result);
} else
#endif
{
INTOFF;
if (sh_pipe(pip) < 0)
error("Pipe call failed");
jp = makejob(n, 1);
if (forkshell(jp, n, FORK_NOJOB) == 0) {
FORCEINTON;
close(pip[0]);
if (pip[1] != 1) {
close(1);
copyfd(pip[1], 1, 1, 0);
close(pip[1]);
}
eflag = 0;
evaltree(n, EV_EXIT);
/* NOTREACHED */
}
close(pip[1]);
result->fd = pip[0];
result->jp = jp;
INTON;
}
out:
popstackmark(&smark);
TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
result->fd, result->buf, result->nleft, result->jp));
}
STATIC void
evalpipe(shinstance *psh, union node *n)
{
struct job *jp;
struct nodelist *lp;
int pipelen;
int prevfd;
int pip[2];
TRACE((psh, "evalpipe(0x%lx) called\n", (long)n));
pipelen = 0;
for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
pipelen++;
INTOFF;
jp = makejob(psh, n, pipelen);
prevfd = -1;
for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
prehash(psh, lp->n);
pip[1] = -1;
if (lp->next) {
if (sh_pipe(psh, pip) < 0) {
shfile_close(&psh->fdtab, prevfd);
error(psh, "Pipe call failed");
}
}
if (forkshell(psh, jp, lp->n, n->npipe.backgnd ? FORK_BG : FORK_FG) == 0) {
INTON;
if (prevfd > 0) {
movefd(psh, prevfd, 0);
}
if (pip[1] >= 0) {
shfile_close(&psh->fdtab, pip[0]);
if (pip[1] != 1) {
movefd(psh, pip[1], 1);
}
}
evaltree(psh, lp->n, EV_EXIT);
}
if (prevfd >= 0)
shfile_close(&psh->fdtab, prevfd);
prevfd = pip[0];
shfile_close(&psh->fdtab, pip[1]);
}
if (n->npipe.backgnd == 0) {
psh->exitstatus = waitforjob(psh, jp);
TRACE((psh, "evalpipe: job done exit status %d\n", psh->exitstatus));
}
INTON;
}
struct argnod *sh_argprocsub(Shell_t *shp, struct argnod *argp) {
// Argument of the form <(cmd) or >(cmd).
struct argnod *ap;
int nn, monitor, fd, pv[3];
int subshell = shp->subshell;
pid_t pid0;
ap = (struct argnod *)stkseek(shp->stk, ARGVAL);
ap->argflag |= ARG_MAKE;
ap->argflag &= ~ARG_RAW;
fd = argp->argflag & ARG_RAW;
if (fd == 0 && shp->subshell) sh_subtmpfile(shp);
#if has_dev_fd
sfwrite(shp->stk, e_devfdNN, 8);
pv[2] = 0;
sh_pipe(pv);
sfputr(shp->stk, fmtbase((long)pv[fd], 10, 0), 0);
#else // has_dev_fd
pv[0] = -1;
shp->fifo = ast_temp_path("ksh.fifo");
if (mkfifo(shp->fifo, S_IRUSR | S_IWUSR)) abort();
sfputr(shp->stk, shp->fifo, 0);
#endif // has_dev_fd
ap = (struct argnod *)stkfreeze(shp->stk, 0);
shp->inpipe = shp->outpipe = NULL;
monitor = (sh_isstate(shp, SH_MONITOR) != 0);
if (monitor) sh_offstate(shp, SH_MONITOR);
shp->subshell = 0;
#if has_dev_fd
#if USE_SPAWN
if (shp->vex || (shp->vex = spawnvex_open(0))) {
spawnvex_add(shp->vex, pv[fd], pv[fd], 0, 0);
} else
#endif // USE_SPAWN
fcntl(pv[fd], F_SETFD, 0);
shp->fdstatus[pv[fd]] &= ~IOCLEX;
#endif // has_dev_fd
pid0 = shp->procsub ? *shp->procsub : 0;
if (fd) {
if (!shp->procsub) {
shp->nprocsub = 4;
shp->procsub = procsub = calloc(1, shp->nprocsub * sizeof(pid_t));
} else {
nn = procsub - shp->procsub;
if (nn >= shp->nprocsub) {
shp->nprocsub += 3;
shp->procsub = realloc(shp->procsub, shp->nprocsub * sizeof(pid_t));
procsub = shp->procsub + nn;
}
}
if (pid0) *shp->procsub = 0;
shp->inpipe = pv;
sh_exec(shp, (Shnode_t *)argp->argchn.ap, (int)sh_isstate(shp, SH_ERREXIT));
if (pid0) *shp->procsub = pid0;
*procsub++ = job.lastpost;
} else {
shp->outpipe = pv;
sh_exec(shp, (Shnode_t *)argp->argchn.ap, (int)sh_isstate(shp, SH_ERREXIT));
}
shp->subshell = subshell;
if (monitor) sh_onstate(shp, SH_MONITOR);
#if has_dev_fd
sh_close(pv[1 - fd]);
sh_iosave(shp, -pv[fd], shp->topfd, NULL);
#else
free(shp->fifo);
shp->fifo = NULL;
#endif // has_dev_fd
return ap;
}
STATIC void
evalcommand(shinstance *psh, union node *cmd, int flags, struct backcmd *backcmd)
{
struct stackmark smark;
union node *argp;
struct arglist arglist;
struct arglist varlist;
char **argv;
int argc;
char **envp;
int varflag;
struct strlist *sp;
int mode;
int pip[2];
struct cmdentry cmdentry;
struct job *jp;
struct jmploc jmploc;
struct jmploc *volatile savehandler;
char *volatile savecmdname;
volatile struct shparam saveparam;
struct localvar *volatile savelocalvars;
volatile int e;
char *lastarg;
const char *path = pathval(psh);
volatile int temp_path;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &argv;
(void) &argc;
(void) &lastarg;
(void) &flags;
#endif
psh->vforked = 0;
/* First expand the arguments. */
TRACE((psh, "evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
setstackmark(psh, &smark);
psh->back_exitstatus = 0;
arglist.lastp = &arglist.list;
varflag = 1;
/* Expand arguments, ignoring the initial 'name=value' ones */
for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
char *p = argp->narg.text;
if (varflag && is_name(*p)) {
do {
p++;
} while (is_in_name(*p));
if (*p == '=')
continue;
}
expandarg(psh, argp, &arglist, EXP_FULL | EXP_TILDE);
varflag = 0;
}
*arglist.lastp = NULL;
expredir(psh, cmd->ncmd.redirect);
/* Now do the initial 'name=value' ones we skipped above */
varlist.lastp = &varlist.list;
for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
char *p = argp->narg.text;
if (!is_name(*p))
break;
do
p++;
while (is_in_name(*p));
if (*p != '=')
break;
expandarg(psh, argp, &varlist, EXP_VARTILDE);
}
*varlist.lastp = NULL;
argc = 0;
for (sp = arglist.list ; sp ; sp = sp->next)
argc++;
argv = stalloc(psh, sizeof (char *) * (argc + 1));
for (sp = arglist.list ; sp ; sp = sp->next) {
TRACE((psh, "evalcommand arg: %s\n", sp->text));
*argv++ = sp->text;
}
*argv = NULL;
lastarg = NULL;
if (iflag(psh) && psh->funcnest == 0 && argc > 0)
lastarg = argv[-1];
argv -= argc;
/* Print the command if xflag is set. */
if (xflag(psh)) {
char sep = 0;
out2str(psh, ps4val(psh));
for (sp = varlist.list ; sp ; sp = sp->next) {
if (sep != 0)
outc(sep, &psh->errout);
out2str(psh, sp->text);
sep = ' ';
}
for (sp = arglist.list ; sp ; sp = sp->next) {
if (sep != 0)
outc(sep, &psh->errout);
out2str(psh, sp->text);
sep = ' ';
}
outc('\n', &psh->errout);
flushout(&psh->errout);
}
/* Now locate the command. */
if (argc == 0) {
cmdentry.cmdtype = CMDSPLBLTIN;
cmdentry.u.bltin = bltincmd;
} else {
static const char PATH[] = "PATH=";
int cmd_flags = DO_ERR;
/*
* Modify the command lookup path, if a PATH= assignment
* is present
*/
for (sp = varlist.list; sp; sp = sp->next)
if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0)
path = sp->text + sizeof(PATH) - 1;
do {
int argsused, use_syspath;
find_command(psh, argv[0], &cmdentry, cmd_flags, path);
if (cmdentry.cmdtype == CMDUNKNOWN) {
psh->exitstatus = 127;
flushout(&psh->errout);
goto out;
}
/* implement the 'command' builtin here */
if (cmdentry.cmdtype != CMDBUILTIN ||
cmdentry.u.bltin != bltincmd)
break;
cmd_flags |= DO_NOFUNC;
argsused = parse_command_args(psh, argc, argv, &use_syspath);
if (argsused == 0) {
/* use 'type' builting to display info */
cmdentry.u.bltin = typecmd;
break;
}
argc -= argsused;
argv += argsused;
if (use_syspath)
path = syspath(psh) + 5;
} while (argc != 0);
if (cmdentry.cmdtype == CMDSPLBLTIN && cmd_flags & DO_NOFUNC)
/* posix mandates that 'command <splbltin>' act as if
<splbltin> was a normal builtin */
cmdentry.cmdtype = CMDBUILTIN;
}
/* Fork off a child process if necessary. */
if (cmd->ncmd.backgnd
|| (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)
|| ((flags & EV_BACKCMD) != 0
&& ((cmdentry.cmdtype != CMDBUILTIN && cmdentry.cmdtype != CMDSPLBLTIN)
|| cmdentry.u.bltin == dotcmd
|| cmdentry.u.bltin == evalcmd))) {
INTOFF;
jp = makejob(psh, cmd, 1);
mode = cmd->ncmd.backgnd;
if (flags & EV_BACKCMD) {
mode = FORK_NOJOB;
if (sh_pipe(psh, pip) < 0)
error(psh, "Pipe call failed");
}
#ifdef DO_SHAREDVFORK
/* It is essential that if DO_SHAREDVFORK is defined that the
* child's address space is actually shared with the parent as
* we rely on this.
*/
if (cmdentry.cmdtype == CMDNORMAL) {
pid_t pid;
savelocalvars = psh->localvars;
psh->localvars = NULL;
psh->vforked = 1;
switch (pid = vfork()) {
case -1:
TRACE((psh, "Vfork failed, errno=%d\n", errno));
INTON;
error(psh, "Cannot vfork");
break;
case 0:
/* Make sure that exceptions only unwind to
* after the vfork(2)
*/
if (setjmp(jmploc.loc)) {
if (psh->exception == EXSHELLPROC) {
/* We can't progress with the vfork,
* so, set vforked = 2 so the parent
* knows, and _exit();
*/
psh->vforked = 2;
sh__exit(psh, 0);
} else {
sh__exit(psh, psh->exerrno);
}
}
savehandler = psh->handler;
psh->handler = &jmploc;
listmklocal(psh, varlist.list, VEXPORT | VNOFUNC);
forkchild(psh, jp, cmd, mode, psh->vforked);
break;
default:
psh->handler = savehandler; /* restore from vfork(2) */
poplocalvars(psh);
psh->localvars = savelocalvars;
if (psh->vforked == 2) {
psh->vforked = 0;
(void)sh_waitpid(psh, pid, NULL, 0);
/* We need to progress in a normal fork fashion */
goto normal_fork;
}
psh->vforked = 0;
forkparent(psh, jp, cmd, mode, pid);
goto parent;
}
} else {
normal_fork:
#endif
if (forkshell(psh, jp, cmd, mode) != 0)
goto parent; /* at end of routine */
FORCEINTON;
#ifdef DO_SHAREDVFORK
}
#endif
if (flags & EV_BACKCMD) {
if (!psh->vforked) {
FORCEINTON;
}
shfile_close(&psh->fdtab, pip[0]);
if (pip[1] != 1) {
movefd(psh, pip[1], 1);
}
}
flags |= EV_EXIT;
}
/* This is the child process if a fork occurred. */
/* Execute the command. */
switch (cmdentry.cmdtype) {
case CMDFUNCTION:
#ifdef DEBUG
trputs(psh, "Shell function: "); trargs(psh, argv);
#endif
redirect(psh, cmd->ncmd.redirect, REDIR_PUSH);
saveparam = psh->shellparam;
psh->shellparam.malloc = 0;
psh->shellparam.reset = 1;
psh->shellparam.nparam = argc - 1;
psh->shellparam.p = argv + 1;
psh->shellparam.optnext = NULL;
INTOFF;
savelocalvars = psh->localvars;
psh->localvars = NULL;
INTON;
if (setjmp(jmploc.loc)) {
if (psh->exception == EXSHELLPROC) {
freeparam(psh, (volatile struct shparam *)
&saveparam);
} else {
freeparam(psh, &psh->shellparam);
psh->shellparam = saveparam;
}
poplocalvars(psh);
psh->localvars = savelocalvars;
psh->handler = savehandler;
longjmp(psh->handler->loc, 1);
}
savehandler = psh->handler;
psh->handler = &jmploc;
listmklocal(psh, varlist.list, 0);
/* stop shell blowing its stack */
if (++psh->funcnest > 1000)
error(psh, "too many nested function calls");
evaltree(psh, cmdentry.u.func, flags & EV_TESTED);
psh->funcnest--;
INTOFF;
poplocalvars(psh);
psh->localvars = savelocalvars;
freeparam(psh, &psh->shellparam);
psh->shellparam = saveparam;
psh->handler = savehandler;
popredir(psh);
INTON;
if (psh->evalskip == SKIPFUNC) {
psh->evalskip = 0;
psh->skipcount = 0;
}
if (flags & EV_EXIT)
exitshell(psh, psh->exitstatus);
break;
case CMDBUILTIN:
case CMDSPLBLTIN:
#ifdef DEBUG
trputs(psh, "builtin command: "); trargs(psh, argv);
#endif
mode = (cmdentry.u.bltin == execcmd) ? 0 : REDIR_PUSH;
if (flags == EV_BACKCMD) {
psh->memout.nleft = 0;
psh->memout.nextc = psh->memout.buf;
psh->memout.bufsize = 64;
mode |= REDIR_BACKQ;
}
e = -1;
savehandler = psh->handler;
savecmdname = psh->commandname;
psh->handler = &jmploc;
if (!setjmp(jmploc.loc)) {
/* We need to ensure the command hash table isn't
* corruped by temporary PATH assignments.
* However we must ensure the 'local' command works!
*/
if (path != pathval(psh) && (cmdentry.u.bltin == hashcmd ||
cmdentry.u.bltin == typecmd)) {
savelocalvars = psh->localvars;
psh->localvars = 0;
mklocal(psh, path - 5 /* PATH= */, 0);
temp_path = 1;
} else
temp_path = 0;
redirect(psh, cmd->ncmd.redirect, mode);
/* exec is a special builtin, but needs this list... */
psh->cmdenviron = varlist.list;
/* we must check 'readonly' flag for all builtins */
listsetvar(psh, varlist.list,
cmdentry.cmdtype == CMDSPLBLTIN ? 0 : VNOSET);
psh->commandname = argv[0];
/* initialize nextopt */
psh->argptr = argv + 1;
psh->optptr = NULL;
/* and getopt */
#if 0 /** @todo fix getop usage! */
#if defined(__FreeBSD__) || defined(__EMX__) || defined(__APPLE__)
optreset = 1;
optind = 1;
#else
optind = 0; /* init */
#endif
#endif
psh->exitstatus = cmdentry.u.bltin(psh, argc, argv);
} else {
e = psh->exception;
psh->exitstatus = e == EXINT ? SIGINT + 128 :
e == EXEXEC ? psh->exerrno : 2;
}
psh->handler = savehandler;
output_flushall(psh);
psh->out1 = &psh->output;
psh->out2 = &psh->errout;
freestdout(psh);
if (temp_path) {
poplocalvars(psh);
psh->localvars = savelocalvars;
}
psh->cmdenviron = NULL;
if (e != EXSHELLPROC) {
psh->commandname = savecmdname;
if (flags & EV_EXIT)
exitshell(psh, psh->exitstatus);
}
if (e != -1) {
if ((e != EXERROR && e != EXEXEC)
|| cmdentry.cmdtype == CMDSPLBLTIN)
exraise(psh, e);
FORCEINTON;
}
if (cmdentry.u.bltin != execcmd)
popredir(psh);
if (flags == EV_BACKCMD) {
backcmd->buf = psh->memout.buf;
backcmd->nleft = (int)(psh->memout.nextc - psh->memout.buf);
psh->memout.buf = NULL;
}
break;
default:
#ifdef DEBUG
trputs(psh, "normal command: "); trargs(psh, argv);
#endif
clearredir(psh, psh->vforked);
redirect(psh, cmd->ncmd.redirect, psh->vforked ? REDIR_VFORK : 0);
if (!psh->vforked)
for (sp = varlist.list ; sp ; sp = sp->next)
setvareq(psh, sp->text, VEXPORT|VSTACK);
envp = environment(psh);
shellexec(psh, argv, envp, path, cmdentry.u.index, psh->vforked);
break;
}
goto out;
parent: /* parent process gets here (if we forked) */
if (mode == FORK_FG) { /* argument to fork */
psh->exitstatus = waitforjob(psh, jp);
} else if (mode == FORK_NOJOB) {
backcmd->fd = pip[0];
shfile_close(&psh->fdtab, pip[1]);
backcmd->jp = jp;
}
FORCEINTON;
out:
if (lastarg)
/* dsl: I think this is intended to be used to support
* '_' in 'vi' command mode during line editing...
* However I implemented that within libedit itself.
*/
setvar(psh, "_", lastarg, 0);
popstackmark(psh, &smark);
if (eflag(psh) && psh->exitstatus && !(flags & EV_TESTED))
exitshell(psh, psh->exitstatus);
}
/*
* This routine will turn the sftmp() file into a real /tmp file or pipe
*/
void sh_subtmpfile(int pflag)
{
Shell_t *shp = &sh;
int fds[2];
Sfoff_t off;
register struct checkpt *pp = (struct checkpt*)shp->jmplist;
register struct subshell *sp = subshell_data->pipe;
if(sfset(sfstdout,0,0)&SF_STRING)
{
register int fd;
/* save file descriptor 1 if open */
if((sp->tmpfd = fd = fcntl(1,F_DUPFD,10)) >= 0)
{
fcntl(fd,F_SETFD,FD_CLOEXEC);
shp->fdstatus[fd] = shp->fdstatus[1]|IOCLEX;
close(1);
shp->fdstatus[1] = IOCLOSE;
}
else if(errno!=EBADF)
{
((struct checkpt*)shp->jmplist)->mode = SH_JMPERREXIT;
shp->toomany = 1;
errormsg(SH_DICT,ERROR_system(1),e_toomany);
}
if(shp->subshare || !pflag)
{
sfdisc(sfstdout,SF_POPDISC);
if((fd=sffileno(sfstdout))>=0)
{
shp->fdstatus[fd] = IOREAD|IOWRITE;
sfsync(sfstdout);
if(fd==1)
fcntl(1,F_SETFD,0);
else
{
sfsetfd(sfstdout,1);
shp->fdstatus[1] = shp->fdstatus[fd];
shp->fdstatus[fd] = IOCLOSE;
}
goto skip;
}
}
}
if(sp && (shp->fdstatus[1]==IOCLOSE || (!shp->subshare && !(shp->fdstatus[1]&IONOSEEK))))
{
struct stat statb,statx;
int fd;
sh_pipe(fds);
sp->pipefd = fds[0];
sh_fcntl(sp->pipefd,F_SETFD,FD_CLOEXEC);
/* write the data to the pipe */
if(off = sftell(sfstdout))
{
write(fds[1],sfsetbuf(sfstdout,(Void_t*)sfstdout,0),(size_t)off);
sfpurge(sfstdout);
}
if((sfset(sfstdout,0,0)&SF_STRING) || fstat(1,&statb)<0)
statb.st_ino = 0;
sfclose(sfstdout);
if((sh_fcntl(fds[1],F_DUPFD, 1)) != 1)
errormsg(SH_DICT,ERROR_system(1),e_redirect);
sh_close(fds[1]);
if(statb.st_ino) for(fd=0; fd < 10; fd++)
{
if(fd==1 || ((shp->fdstatus[fd]&(IONOSEEK|IOSEEK|IOWRITE))!=(IOSEEK|IOWRITE)) || fstat(fd,&statx)<0)
continue;
if(statb.st_ino==statx.st_ino && statb.st_dev==statx.st_dev)
{
sh_close(fd);
fcntl(1,F_DUPFD, fd);
}
}
skip:
sh_iostream(shp,1);
sfset(sfstdout,SF_SHARE|SF_PUBLIC,1);
sfpool(sfstdout,shp->outpool,SF_WRITE);
if(pp && pp->olist && pp->olist->strm == sfstdout)
pp->olist->strm = 0;
}
}
