2.9BSD/usr/src/ucb/oldcsh/sh.sem.c
/* @(#)sh.sem.c 2.1 SCCS id keyword */
/* Copyright (c) 1980 Regents of the University of California */
#include "sh.h"
/*
* C shell
*/
execute(t, pipein, pipeout)
register struct command *t;
int *pipein, *pipeout;
{
int pid, flags, pv[2];
register struct command *t1;
register char *cp;
bool forked = 0;
bool shudint, shudhup;
#ifdef VFORK
int (*savint)(), vffree();
int ochild, osetintr, ohaderr, otimflg, odidfds, odidcch;
int oSHIN, oSHOUT, oSHDIAG, oOLDSTD;
int isvfork = 0;
#endif
if (t == 0)
return;
switch (t->t_dtyp) {
case TCOM:
cp = t->t_dcom[0];
if ((cp[0] & (QUOTE|TRIM)) == QUOTE)
strcpy(cp, cp + 1);
if ((t->t_dflg & FREDO) == 0)
Dfix(t); /* $ " ' \ */
if (t->t_dcom[0] == 0)
return;
/* fall into... */
case TPAR:
flags = t->t_dflg;
if (flags & FPOU)
mypipe(pipeout);
/*
* A child will be interruptible only under very
* certain conditions:
* we must be monkeying with interrupts
* the child must not be &'ed
* we must not have had an "onintr -"
*/
shudint = setintr && (flags & FINT) == 0 && (!gointr || !eq(gointr, "-"));
shudhup = (flags & FAND) == 0;
/*
* Must do << early so parent will know
* where input pointer should be
*/
if (flags & FHERE)
close(0), heredoc(t->t_dlef);
/*
* If not executing commands then
* all we must do is read forward in the input to
* account for << redirection if present.
*/
if (noexec) {
if (flags & FHERE)
close(0);
return;
}
set("status", "0");
pid = 0;
/*
* Built-in functions
*/
if (t->t_dtyp == TCOM && isbfunc(t->t_dcom[0])) {
/*
* If output is piped, or running & and we would
* eventually fork for non-builtin commands,
* then do it now, so we won't block.
*/
if ((flags & (FPOU|FAND)) && (flags & FPAR) == 0)
pid = dofork(shudint, shudhup), forked++;
/*
* If the builtin is actually executed (some, e.g.
* time and nice may refuse to execute here)
* then either exit (if we forked) or close i/o
* and continue execution (if we didn't).
*/
if (pid == 0) {
doio(t, pipein, pipeout);
if (flags & FPOU) {
close(pipeout[0]), close(pipeout[1]);
pipeout[0] = pipeout[1] = -1;
}
if (setintr && forked) {
if (shudint)
signal(SIGINT, SIG_DFL), signal(SIGQUIT, SIG_DFL);
signal(SIGTERM, parterm);
if (flags & FINT)
setintr = 0;
}
if (func(t, pipein, pipeout)) {
if (forked)
exitstat();
if (didfds && !(t->t_dflg & FREDO))
donefds();
return;
}
}
}
/*
* Now, we must make a new process since either the
* command is non-builtin, a parenthesized list,
* or builtin such as time or nice which really
* requires a child.
*/
if (!forked && (flags & FPAR) == 0)
#ifdef VFORK
if (t->t_dtyp == TPAR || (flags&FREDO) ||
eq(t->t_dcom[0], "nice") || eq(t->t_dcom[0], "nohup"))
#endif
pid = dofork(shudint, shudhup);
#ifdef VFORK
else {
savint = signal(SIGINT, SIG_IGN);
ochild = child; osetintr = setintr;
ohaderr = haderr; otimflg = timflg;
odidfds = didfds; odidcch = didcch;
oSHIN = SHIN; oSHOUT = SHOUT;
oSHDIAG = SHDIAG; oOLDSTD = OLDSTD;
Vsav = Vdp = 0; Vav = 0;
isvfork++;
pid = vfork();
if (pid < 0) {
signal(SIGINT, savint);
error("No more processes");
}
if (pid == 0) {
child++;
signal(SIGINT, shudint ? SIG_DFL : savint);
if (!shudhup)
signal(SIGHUP, SIG_IGN);
} else {
child = ochild; setintr = osetintr;
haderr = ohaderr; timflg = otimflg;
didfds = odidfds; didcch = odidcch;
SHIN = oSHIN; SHOUT = oSHOUT;
SHDIAG = oSHDIAG; OLDSTD = oOLDSTD;
xfree(Vsav), Vsav = 0;
xfree(Vdp), Vdp = 0;
xfree(Vav), Vav = 0;
signal(SIGINT, savint);
}
}
#endif
if (pid != 0) {
/*
* The parent path (or nobody does this if
* (flags & FPAR), i.e. date in (set;date))
*/
if (didfds == 0 && (flags & FPIN))
close(pipein[0]), close(pipein[1]);
if (didfds && !(t->t_dflg & FREDO))
donefds();
if (flags & FPRS)
printf("%d\n", pid), set("child", putn(pid));
/*
* Unless output is piped or command is &
* wait for it.
*/
if (t->t_dtyp == TCOM)
cadd(pid, t->t_dcom[0]);
else
cadd(pid, "()");
if ((flags & (FPOU|FAND)) == 0)
pwait(pid);
return;
}
/*
* Insure that this (child) shell doesn't muck on
*/
child++;
/*
* If havent yet, finally set up the file descriptors.
*/
doio(t, pipein, pipeout);
if (flags & FPOU)
close(pipeout[0]), close(pipeout[1]);
/*
* If mucking with interrupts fix interrupt, quit,
* and terminate handling ... in any case set setintr
* to 0 if we are not interruptible so that no further
* interrupt mucking occurs.
*/
if (setintr) {
if (shudint) {
signal(SIGQUIT, SIG_DFL);
#ifdef VFORK
if (isvfork)
signal(SIGINT, vffree);
else
#endif
signal(SIGINT, SIG_DFL);
}
signal(SIGTERM, parterm);
if (flags & FINT)
setintr = 0;
}
/*
* For () commands must put new 0,1,2 in FSH* and recurse
*/
if (t->t_dtyp == TPAR) {
t1 = t->t_dspr;
t1->t_dflg |= flags & FINT;
OLDSTD = dcopy(0, FOLDSTD);
SHOUT = dcopy(1, FSHOUT);
SHDIAG = dcopy(2, FSHDIAG);
close(SHIN), SHIN = -1;
didcch = 0, didfds = 0;
execute(t1);
exitstat();
}
if (eq(t->t_dcom[0], "nice")) {
/* sigh...
nice(20);
nice(-10);
*/
cp = t->t_dcom[1];
if (any(cp[0], "+-"))
nice(getn(cp)), lshift(t->t_dcom, 2);
else
nice(4), lshift(t->t_dcom, 1);
t->t_dflg = FPAR | FREDO;
execute(t);
exitstat();
}
if (eq(t->t_dcom[0], "nohup")) {
if (setintr == 0)
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, SIG_IGN);
lshift(t->t_dcom, 1);
t->t_dflg = FPAR | FREDO;
execute(t);
exitstat();
}
doexec(t);
/* no return */
case TFIL:
flags = t->t_dflg;
t1 = t->t_dcar;
t1->t_dflg |= FPOU | (flags & (FPIN|FINT|FPRS|FDIAG));
execute(t1, pipein, pv);
t1 = t->t_dcdr;
t1->t_dflg |= FPIN | (flags & (FPOU|FINT|FAND|FPRS|FPAR));
execute(t1, pv, pipeout);
return;
case TLST:
flags = t->t_dflg & FINT;
if (t1 = t->t_dcar)
t1->t_dflg |= flags, execute(t1);
if (t1 = t->t_dcdr)
t1->t_dflg |= t->t_dflg & (FINT|FPAR), execute(t1);
return;
case TOR:
case TAND:
flags = t->t_dflg & FINT;
if (t1 = t->t_dcar) {
t1->t_dflg |= flags, execute(t1);
if ((getn(value("status")) == 0) != (t->t_dtyp == TAND))
return;
}
if (t1 = t->t_dcdr)
t1->t_dflg |= t->t_dflg & (FINT|FPAR), execute(t1);
return;
}
}
#ifdef VFORK
vffree()
{
register char **v;
if (v = gargv)
gargv = 0, xfree(gargv);
if (v = pargv)
pargv = 0, xfree(pargv);
_exit(1);
}
#endif
doio(t, pipein, pipeout)
register struct command *t;
int *pipein, *pipeout;
{
register char *cp;
register int flags = t->t_dflg;
char *dp;
if (didfds || (flags & FREDO))
return;
if (flags & FHERE)
goto skipin;
close(0);
if (cp = t->t_dlef) {
cp = globone(dp = Dfix1(cp));
xfree(dp);
xfree(cp);
if (open(cp, 0) < 0)
Perror(cp);
} else if (flags & FPIN)
dup(pipein[0]), close(pipein[0]), close(pipein[1]);
else if (flags & FINT)
close(0), open("/dev/null", 0);
else
dup(OLDSTD);
skipin:
close(1);
if (cp = t->t_drit) {
cp = globone(dp = Dfix1(cp));
xfree(dp);
xfree(cp);
if ((flags & FCAT) && open(cp, 1) >= 0)
lseek(1, 0l, 2);
else {
if (!(flags & FANY) && adrof("noclobber")) {
if (flags & FCAT)
Perror(cp);
chkclob(cp);
}
#ifdef V6
if (creat(cp, 0644) < 0)
Perror(cp);
#else
if (creat(cp, 0666) < 0)
Perror(cp);
#endif
}
} else
dup((flags & FPOU) ? pipeout[1] : SHOUT);
close(2);
dup((flags & FDIAG) ? 1 : SHDIAG);
didfds = 1;
}
dofork(shudint, shudhup)
bool shudint, shudhup;
{
register int pid, (*savint)();
savint = signal(SIGINT, SIG_IGN);
pid = fork();
if (pid < 0) {
signal(SIGINT, savint);
error("No more processes");
}
if (pid == 0) {
child++;
signal(SIGINT, shudint ? SIG_DFL : savint);
if (!shudhup)
signal(SIGHUP, SIG_IGN);
} else
signal(SIGINT, savint);
return (pid);
}
mypipe(pv)
register int *pv;
{
if (pipe(pv) < 0)
goto oops;
pv[0] = dmove(pv[0], -1);
pv[1] = dmove(pv[1], -1);
if (pv[0] >= 0 && pv[1] >= 0)
return;
oops:
error("Can't make pipe");
}
chkclob(cp)
register char *cp;
{
struct stat stb;
if (stat(cp, &stb) < 0)
return;
if ((stb.st_mode & S_IFMT) == S_IFCHR)
return;
error("%s: File exists", cp);
}