int
main(int argc, char **argv)
{
struct stackmark smark;
volatile int state;
char *shinit;
uid_t uid;
gid_t gid;
uid = getuid();
gid = getgid();
max_user_fd = fcntl(0, F_MAXFD);
if (max_user_fd < 2)
max_user_fd = 2;
setlocale(LC_ALL, "");
posix = getenv("POSIXLY_CORRECT") != NULL;
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
#endif
state = 0;
if (setjmp(main_handler.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (exception) {
case EXSHELLPROC:
rootpid = getpid();
rootshell = 1;
minusc = NULL;
state = 3;
break;
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (exception != EXSHELLPROC) {
if (state == 0 || iflag == 0 || ! rootshell ||
exception == EXEXIT)
exitshell(exitstatus);
}
reset();
if (exception == EXINT) {
out2c('\n');
flushout(&errout);
}
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &main_handler;
#ifdef DEBUG
#if DEBUG >= 2
debug = 1; /* this may be reset by procargs() later */
#endif
opentrace();
trputs("Shell args: "); trargs(argv);
#if DEBUG >= 3
set_debug(((DEBUG)==3 ? "_@" : "++"), 1);
#endif
#endif
rootpid = getpid();
rootshell = 1;
init();
initpwd();
setstackmark(&smark);
procargs(argc, argv);
/*
* Limit bogus system(3) or popen(3) calls in setuid binaries,
* by requiring the -p flag
*/
if (!pflag && (uid != geteuid() || gid != getegid())) {
setuid(uid);
setgid(gid);
/* PS1 might need to be changed accordingly. */
choose_ps1();
}
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
read_profile(".profile");
}
state2:
state = 3;
if ((iflag || !posix) &&
getuid() == geteuid() && getgid() == getegid()) {
struct stackmark env_smark;
setstackmark(&env_smark);
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(expandenv(shinit));
}
popstackmark(&env_smark);
}
state3:
state = 4;
line_number = 1; /* undo anything from profile files */
if (sflag == 0 || minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
size_t i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(sigs[i], 0);
}
if (minusc)
evalstring(minusc, sflag ? 0 : EV_EXIT);
if (sflag || minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
if (iflag) {
out2str("\n");
flushout(&errout);
}
}
#if PROFILE
monitor(0);
#endif
line_number = plinno;
exitshell(exitstatus);
/* NOTREACHED */
}
void
evaltree(union node *n, int flags)
{
int do_etest;
union node *next;
struct stackmark smark;
setstackmark(&smark);
do_etest = 0;
if (n == NULL) {
TRACE(("evaltree(NULL) called\n"));
exitstatus = 0;
goto out;
}
do {
next = NULL;
#ifndef NO_HISTORY
displayhist = 1; /* show history substitutions done with fc */
#endif
TRACE(("evaltree(%p: %d) called\n", (void *)n, n->type));
switch (n->type) {
case NSEMI:
evaltree(n->nbinary.ch1, flags & ~EV_EXIT);
if (evalskip)
goto out;
next = n->nbinary.ch2;
break;
case NAND:
evaltree(n->nbinary.ch1, EV_TESTED);
if (evalskip || exitstatus != 0) {
goto out;
}
next = n->nbinary.ch2;
break;
case NOR:
evaltree(n->nbinary.ch1, EV_TESTED);
if (evalskip || exitstatus == 0)
goto out;
next = n->nbinary.ch2;
break;
case NREDIR:
evalredir(n, flags);
break;
case NSUBSHELL:
evalsubshell(n, flags);
do_etest = !(flags & EV_TESTED);
break;
case NBACKGND:
evalsubshell(n, flags);
break;
case NIF: {
evaltree(n->nif.test, EV_TESTED);
if (evalskip)
goto out;
if (exitstatus == 0)
next = n->nif.ifpart;
else if (n->nif.elsepart)
next = n->nif.elsepart;
else
exitstatus = 0;
break;
}
case NWHILE:
case NUNTIL:
evalloop(n, flags & ~EV_EXIT);
break;
case NFOR:
evalfor(n, flags & ~EV_EXIT);
break;
case NCASE:
next = evalcase(n);
break;
case NCLIST:
next = n->nclist.body;
break;
case NCLISTFALLTHRU:
if (n->nclist.body) {
evaltree(n->nclist.body, flags & ~EV_EXIT);
if (evalskip)
goto out;
}
next = n->nclist.next;
break;
case NDEFUN:
defun(n->narg.text, n->narg.next);
exitstatus = 0;
break;
case NNOT:
evaltree(n->nnot.com, EV_TESTED);
if (evalskip)
goto out;
exitstatus = !exitstatus;
break;
case NPIPE:
evalpipe(n);
do_etest = !(flags & EV_TESTED);
break;
case NCMD:
evalcommand(n, flags, (struct backcmd *)NULL);
do_etest = !(flags & EV_TESTED);
break;
default:
out1fmt("Node type = %d\n", n->type);
flushout(&output);
break;
}
n = next;
popstackmark(&smark);
setstackmark(&smark);
} while (n != NULL);
out:
popstackmark(&smark);
if (pendingsig)
dotrap();
if (eflag && exitstatus != 0 && do_etest)
exitshell(exitstatus);
if (flags & EV_EXIT)
exraise(EXEXIT);
}
void
evalbackcmd(union node *n, struct backcmd *result)
{
int pip[2];
struct job *jp;
struct stackmark smark; /* unnecessary */
struct jmploc jmploc;
struct jmploc *savehandler;
struct localvar *savelocalvars;
setstackmark(&smark);
result->fd = -1;
result->buf = NULL;
result->nleft = 0;
result->jp = NULL;
if (n == NULL) {
exitstatus = 0;
goto out;
}
if (is_valid_fast_cmdsubst(n)) {
exitstatus = oexitstatus;
savelocalvars = localvars;
localvars = NULL;
forcelocal++;
savehandler = handler;
if (setjmp(jmploc.loc)) {
if (exception == EXERROR || exception == EXEXEC)
exitstatus = 2;
else if (exception != 0) {
handler = savehandler;
forcelocal--;
poplocalvars();
localvars = savelocalvars;
longjmp(handler->loc, 1);
}
} else {
handler = &jmploc;
evalcommand(n, EV_BACKCMD, result);
}
handler = savehandler;
forcelocal--;
poplocalvars();
localvars = savelocalvars;
} else {
exitstatus = 0;
if (pipe(pip) < 0)
error("Pipe call failed: %s", strerror(errno));
jp = makejob(n, 1);
if (forkshell(jp, n, FORK_NOJOB) == 0) {
FORCEINTON;
close(pip[0]);
if (pip[1] != 1) {
dup2(pip[1], 1);
close(pip[1]);
}
evaltree(n, EV_EXIT);
}
close(pip[1]);
result->fd = pip[0];
result->jp = jp;
}
out:
popstackmark(&smark);
TRACE(("evalbackcmd done: fd=%d buf=%p nleft=%d jp=%p\n",
result->fd, result->buf, result->nleft, result->jp));
}
static void
evalcommand(union node *cmd, int flgs, struct backcmd *backcmd)
{
struct stackmark smark;
union node *argp;
struct arglist arglist;
struct arglist varlist;
volatile int flags = flgs;
char **volatile argv;
volatile int argc;
char **envp;
int varflag;
struct strlist *sp;
int mode;
int pip[2];
struct cmdentry cmdentry;
struct job *volatile jp;
struct jmploc jmploc;
struct jmploc *savehandler;
const char *savecmdname;
struct shparam saveparam;
struct localvar *savelocalvars;
struct parsefile *savetopfile;
volatile int e;
char *volatile lastarg;
int realstatus;
volatile int do_clearcmdentry;
const char *path = pathval();
/* First expand the arguments. */
TRACE(("evalcommand(%p, %d) called\n", (void *)cmd, flags));
setstackmark(&smark);
arglist.lastp = &arglist.list;
varlist.lastp = &varlist.list;
varflag = 1;
jp = NULL;
do_clearcmdentry = 0;
oexitstatus = exitstatus;
exitstatus = 0;
for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
if (varflag && isassignment(argp->narg.text)) {
expandarg(argp, &varlist, EXP_VARTILDE);
continue;
}
expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
varflag = 0;
}
*arglist.lastp = NULL;
*varlist.lastp = NULL;
expredir(cmd->ncmd.redirect);
argc = 0;
for (sp = arglist.list ; sp ; sp = sp->next)
argc++;
/* Add one slot at the beginning for tryexec(). */
argv = stalloc(sizeof (char *) * (argc + 2));
argv++;
for (sp = arglist.list ; sp ; sp = sp->next) {
TRACE(("evalcommand arg: %s\n", sp->text));
*argv++ = sp->text;
}
*argv = NULL;
lastarg = NULL;
if (iflag && funcnest == 0 && argc > 0)
lastarg = argv[-1];
argv -= argc;
/* Print the command if xflag is set. */
if (xflag) {
char sep = 0;
const char *p, *ps4;
ps4 = expandstr(ps4val());
out2str(ps4 != NULL ? ps4 : ps4val());
for (sp = varlist.list ; sp ; sp = sp->next) {
if (sep != 0)
out2c(' ');
p = strchr(sp->text, '=');
if (p != NULL) {
p++;
outbin(sp->text, p - sp->text, out2);
out2qstr(p);
} else
out2qstr(sp->text);
sep = ' ';
}
for (sp = arglist.list ; sp ; sp = sp->next) {
if (sep != 0)
out2c(' ');
/* Disambiguate command looking like assignment. */
if (sp == arglist.list &&
strchr(sp->text, '=') != NULL &&
strchr(sp->text, '\'') == NULL) {
out2c('\'');
out2str(sp->text);
out2c('\'');
} else
out2qstr(sp->text);
sep = ' ';
}
out2c('\n');
flushout(&errout);
}
/* Now locate the command. */
if (argc == 0) {
/* Variable assignment(s) without command */
cmdentry.cmdtype = CMDBUILTIN;
cmdentry.u.index = BLTINCMD;
cmdentry.special = 0;
} else {
static const char PATH[] = "PATH=";
int cmd_flags = 0, bltinonly = 0;
/*
* 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;
/*
* On `PATH=... command`, we need to make
* sure that the command isn't using the
* non-updated hash table of the outer PATH
* setting and we need to make sure that
* the hash table isn't filled with items
* from the temporary setting.
*
* It would be better to forbit using and
* updating the table while this command
* runs, by the command finding mechanism
* is heavily integrated with hash handling,
* so we just delete the hash before and after
* the command runs. Partly deleting like
* changepatch() does doesn't seem worth the
* bookinging effort, since most such runs add
* directories in front of the new PATH.
*/
clearcmdentry();
do_clearcmdentry = 1;
}
for (;;) {
if (bltinonly) {
cmdentry.u.index = find_builtin(*argv, &cmdentry.special);
if (cmdentry.u.index < 0) {
cmdentry.u.index = BLTINCMD;
argv--;
argc++;
break;
}
} else
find_command(argv[0], &cmdentry, cmd_flags, path);
/* implement the bltin and command builtins here */
if (cmdentry.cmdtype != CMDBUILTIN)
break;
if (cmdentry.u.index == BLTINCMD) {
if (argc == 1)
break;
argv++;
argc--;
bltinonly = 1;
} else if (cmdentry.u.index == COMMANDCMD) {
if (argc == 1)
break;
if (!strcmp(argv[1], "-p")) {
if (argc == 2)
break;
if (argv[2][0] == '-') {
if (strcmp(argv[2], "--"))
break;
if (argc == 3)
break;
argv += 3;
argc -= 3;
} else {
argv += 2;
argc -= 2;
}
path = _PATH_STDPATH;
clearcmdentry();
do_clearcmdentry = 1;
} else if (!strcmp(argv[1], "--")) {
if (argc == 2)
break;
argv += 2;
argc -= 2;
} else if (argv[1][0] == '-')
break;
else {
argv++;
argc--;
}
cmd_flags |= DO_NOFUNC;
bltinonly = 0;
} else
break;
}
/*
* Special builtins lose their special properties when
* called via 'command'.
*/
if (cmd_flags & DO_NOFUNC)
cmdentry.special = 0;
}
/* Fork off a child process if necessary. */
if (((cmdentry.cmdtype == CMDNORMAL || cmdentry.cmdtype == CMDUNKNOWN)
&& ((flags & EV_EXIT) == 0 || have_traps()))
|| ((flags & EV_BACKCMD) != 0
&& (cmdentry.cmdtype != CMDBUILTIN ||
!safe_builtin(cmdentry.u.index, argc, argv)))) {
jp = makejob(cmd, 1);
mode = FORK_FG;
if (flags & EV_BACKCMD) {
mode = FORK_NOJOB;
if (pipe(pip) < 0)
error("Pipe call failed: %s", strerror(errno));
}
if (cmdentry.cmdtype == CMDNORMAL &&
cmd->ncmd.redirect == NULL &&
varlist.list == NULL &&
(mode == FORK_FG || mode == FORK_NOJOB) &&
!disvforkset() && !iflag && !mflag) {
vforkexecshell(jp, argv, environment(), path,
cmdentry.u.index, flags & EV_BACKCMD ? pip : NULL);
goto parent;
}
if (forkshell(jp, cmd, mode) != 0)
goto parent; /* at end of routine */
if (flags & EV_BACKCMD) {
FORCEINTON;
close(pip[0]);
if (pip[1] != 1) {
dup2(pip[1], 1);
close(pip[1]);
}
flags &= ~EV_BACKCMD;
}
flags |= EV_EXIT;
}
/* This is the child process if a fork occurred. */
/* Execute the command. */
if (cmdentry.cmdtype == CMDFUNCTION) {
#ifdef DEBUG
trputs("Shell function: "); trargs(argv);
#endif
saveparam = shellparam;
shellparam.malloc = 0;
shellparam.reset = 1;
shellparam.nparam = argc - 1;
shellparam.p = argv + 1;
shellparam.optnext = NULL;
INTOFF;
savelocalvars = localvars;
localvars = NULL;
reffunc(cmdentry.u.func);
savehandler = handler;
if (setjmp(jmploc.loc)) {
freeparam(&shellparam);
shellparam = saveparam;
popredir();
unreffunc(cmdentry.u.func);
poplocalvars();
localvars = savelocalvars;
funcnest--;
handler = savehandler;
longjmp(handler->loc, 1);
}
handler = &jmploc;
funcnest++;
redirect(cmd->ncmd.redirect, REDIR_PUSH);
INTON;
for (sp = varlist.list ; sp ; sp = sp->next)
mklocal(sp->text);
exitstatus = oexitstatus;
evaltree(getfuncnode(cmdentry.u.func),
flags & (EV_TESTED | EV_EXIT));
INTOFF;
unreffunc(cmdentry.u.func);
poplocalvars();
localvars = savelocalvars;
freeparam(&shellparam);
shellparam = saveparam;
handler = savehandler;
funcnest--;
popredir();
INTON;
if (evalskip == SKIPFUNC) {
evalskip = 0;
skipcount = 0;
}
if (jp)
exitshell(exitstatus);
} else if (cmdentry.cmdtype == CMDBUILTIN) {
#ifdef DEBUG
trputs("builtin command: "); trargs(argv);
#endif
mode = (cmdentry.u.index == EXECCMD)? 0 : REDIR_PUSH;
if (flags == EV_BACKCMD) {
memout.nleft = 0;
memout.nextc = memout.buf;
memout.bufsize = 64;
mode |= REDIR_BACKQ;
}
savecmdname = commandname;
savetopfile = getcurrentfile();
cmdenviron = varlist.list;
e = -1;
savehandler = handler;
if (setjmp(jmploc.loc)) {
e = exception;
if (e == EXINT)
exitstatus = SIGINT+128;
else if (e != EXEXIT)
exitstatus = 2;
goto cmddone;
}
handler = &jmploc;
redirect(cmd->ncmd.redirect, mode);
/*
* If there is no command word, redirection errors should
* not be fatal but assignment errors should.
*/
if (argc == 0)
cmdentry.special = 1;
listsetvar(cmdenviron, cmdentry.special ? 0 : VNOSET);
if (argc > 0)
bltinsetlocale();
commandname = argv[0];
argptr = argv + 1;
nextopt_optptr = NULL; /* initialize nextopt */
builtin_flags = flags;
exitstatus = (*builtinfunc[cmdentry.u.index])(argc, argv);
flushall();
cmddone:
if (argc > 0)
bltinunsetlocale();
cmdenviron = NULL;
out1 = &output;
out2 = &errout;
freestdout();
handler = savehandler;
commandname = savecmdname;
if (jp)
exitshell(exitstatus);
if (flags == EV_BACKCMD) {
backcmd->buf = memout.buf;
backcmd->nleft = memout.nextc - memout.buf;
memout.buf = NULL;
}
if (cmdentry.u.index != EXECCMD)
popredir();
if (e != -1) {
if ((e != EXERROR && e != EXEXEC)
|| cmdentry.special)
exraise(e);
popfilesupto(savetopfile);
if (flags != EV_BACKCMD)
FORCEINTON;
}
} else {
#ifdef DEBUG
trputs("normal command: "); trargs(argv);
#endif
redirect(cmd->ncmd.redirect, 0);
for (sp = varlist.list ; sp ; sp = sp->next)
setvareq(sp->text, VEXPORT|VSTACK);
envp = environment();
shellexec(argv, envp, path, cmdentry.u.index);
/*NOTREACHED*/
}
goto out;
parent: /* parent process gets here (if we forked) */
if (mode == FORK_FG) { /* argument to fork */
INTOFF;
exitstatus = waitforjob(jp, &realstatus);
INTON;
if (iflag && loopnest > 0 && WIFSIGNALED(realstatus)) {
evalskip = SKIPBREAK;
skipcount = loopnest;
}
} else if (mode == FORK_NOJOB) {
backcmd->fd = pip[0];
close(pip[1]);
backcmd->jp = jp;
}
out:
if (lastarg)
setvar("_", lastarg, 0);
if (do_clearcmdentry)
clearcmdentry();
popstackmark(&smark);
}
int
main(int argc, char *argv[])
{
struct stackmark smark, smark2;
volatile int state;
char *shinit;
setlocale(LC_ALL, "");
initcharset();
state = 0;
if (setjmp(main_handler.loc)) {
switch (exception) {
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (state == 0 || iflag == 0 || ! rootshell ||
exception == EXEXIT)
exitshell(exitstatus);
reset();
if (exception == EXINT)
out2fmt_flush("\n");
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &main_handler;
#ifdef DEBUG
opentrace();
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
rootshell = 1;
initvar();
setstackmark(&smark);
setstackmark(&smark2);
procargs(argc, argv);
pwd_init(iflag);
if (iflag)
chkmail(1);
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
if (privileged == 0)
read_profile("${HOME-}/.profile");
else
read_profile("/etc/suid_profile");
}
state2:
state = 3;
if (!privileged && iflag) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(shinit);
}
}
state3:
state = 4;
popstackmark(&smark2);
if (minusc) {
evalstring(minusc, sflag ? 0 : EV_EXIT);
}
state4:
if (sflag || minusc == NULL) {
cmdloop(1);
}
exitshell(exitstatus);
/*NOTREACHED*/
return 0;
}
STATIC void
evalcommand(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;
int realstatus;
int do_clearcmdentry;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &argv;
(void) &argc;
(void) &lastarg;
(void) &flags;
(void) &do_clearcmdentry;
#endif
/* First expand the arguments. */
TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
setstackmark(&smark);
arglist.lastp = &arglist.list;
varlist.lastp = &varlist.list;
varflag = 1;
do_clearcmdentry = 0;
oexitstatus = exitstatus;
exitstatus = 0;
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 == '=') {
expandarg(argp, &varlist, EXP_VARTILDE);
continue;
}
}
expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
varflag = 0;
}
*arglist.lastp = NULL;
*varlist.lastp = NULL;
expredir(cmd->ncmd.redirect);
argc = 0;
for (sp = arglist.list ; sp ; sp = sp->next)
argc++;
argv = stalloc(sizeof (char *) * (argc + 1));
for (sp = arglist.list ; sp ; sp = sp->next) {
TRACE(("evalcommand arg: %s\n", sp->text));
*argv++ = sp->text;
}
*argv = NULL;
lastarg = NULL;
if (iflag && funcnest == 0 && argc > 0)
lastarg = argv[-1];
argv -= argc;
/* Print the command if xflag is set. */
if (xflag) {
outc('+', &errout);
for (sp = varlist.list ; sp ; sp = sp->next) {
outc(' ', &errout);
out2str(sp->text);
}
for (sp = arglist.list ; sp ; sp = sp->next) {
outc(' ', &errout);
out2str(sp->text);
}
outc('\n', &errout);
flushout(&errout);
}
/* Now locate the command. */
if (argc == 0) {
cmdentry.cmdtype = CMDBUILTIN;
cmdentry.u.index = BLTINCMD;
} else {
static const char PATH[] = "PATH=";
char *path = pathval();
/*
* 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;
/*
* On `PATH=... command`, we need to make
* sure that the command isn't using the
* non-updated hash table of the outer PATH
* setting and we need to make sure that
* the hash table isn't filled with items
* from the temporary setting.
*
* It would be better to forbit using and
* updating the table while this command
* runs, by the command finding mechanism
* is heavily integrated with hash handling,
* so we just delete the hash before and after
* the command runs. Partly deleting like
* changepatch() does doesn't seem worth the
* bookinging effort, since most such runs add
* directories in front of the new PATH.
*/
clearcmdentry(0);
do_clearcmdentry = 1;
}
find_command(argv[0], &cmdentry, 1, path);
if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
exitstatus = 127;
flushout(&errout);
return;
}
/* implement the bltin builtin here */
if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) {
for (;;) {
argv++;
if (--argc == 0)
break;
if ((cmdentry.u.index = find_builtin(*argv)) < 0) {
outfmt(&errout, "%s: not found\n", *argv);
exitstatus = 127;
flushout(&errout);
return;
}
if (cmdentry.u.index != BLTINCMD)
break;
}
}
}
/* Fork off a child process if necessary. */
if (cmd->ncmd.backgnd
|| (cmdentry.cmdtype == CMDNORMAL
&& ((flags & EV_EXIT) == 0 || Tflag))
|| ((flags & EV_BACKCMD) != 0
&& (cmdentry.cmdtype != CMDBUILTIN
|| cmdentry.u.index == CDCMD
|| cmdentry.u.index == DOTCMD
|| cmdentry.u.index == EVALCMD))
|| (cmdentry.cmdtype == CMDBUILTIN &&
cmdentry.u.index == COMMANDCMD)) {
jp = makejob(cmd, 1);
mode = cmd->ncmd.backgnd;
if (flags & EV_BACKCMD) {
mode = FORK_NOJOB;
if (pipe(pip) < 0)
error("Pipe call failed: %s", strerror(errno));
}
if (forkshell(jp, cmd, mode) != 0)
goto parent; /* at end of routine */
if (flags & EV_BACKCMD) {
FORCEINTON;
close(pip[0]);
if (pip[1] != 1) {
dup2(pip[1], 1);
close(pip[1]);
}
}
flags |= EV_EXIT;
}
/* This is the child process if a fork occurred. */
/* Execute the command. */
if (cmdentry.cmdtype == CMDFUNCTION) {
#if DEBUG
trputs("Shell function: "); trargs(argv);
#endif
redirect(cmd->ncmd.redirect, REDIR_PUSH);
saveparam = shellparam;
shellparam.malloc = 0;
shellparam.reset = 1;
shellparam.nparam = argc - 1;
shellparam.p = argv + 1;
shellparam.optnext = NULL;
INTOFF;
savelocalvars = localvars;
localvars = NULL;
INTON;
if (setjmp(jmploc.loc)) {
if (exception == EXSHELLPROC)
freeparam((struct shparam *)&saveparam);
else {
freeparam(&shellparam);
shellparam = saveparam;
}
poplocalvars();
localvars = savelocalvars;
handler = savehandler;
longjmp(handler->loc, 1);
}
savehandler = handler;
handler = &jmploc;
for (sp = varlist.list ; sp ; sp = sp->next)
mklocal(sp->text);
funcnest++;
if (flags & EV_TESTED)
evaltree(cmdentry.u.func, EV_TESTED);
else
evaltree(cmdentry.u.func, 0);
funcnest--;
INTOFF;
poplocalvars();
localvars = savelocalvars;
freeparam(&shellparam);
shellparam = saveparam;
handler = savehandler;
popredir();
INTON;
if (evalskip == SKIPFUNC) {
evalskip = 0;
skipcount = 0;
}
if (flags & EV_EXIT)
exitshell(exitstatus);
} else if (cmdentry.cmdtype == CMDBUILTIN) {
#if DEBUG
trputs("builtin command: "); trargs(argv);
#endif
mode = (cmdentry.u.index == EXECCMD)? 0 : REDIR_PUSH;
if (flags == EV_BACKCMD) {
memout.nleft = 0;
memout.nextc = memout.buf;
memout.bufsize = 64;
mode |= REDIR_BACKQ;
}
redirect(cmd->ncmd.redirect, mode);
savecmdname = commandname;
cmdenviron = varlist.list;
e = -1;
if (setjmp(jmploc.loc)) {
e = exception;
exitstatus = (e == EXINT)? SIGINT+128 : 2;
goto cmddone;
}
savehandler = handler;
handler = &jmploc;
commandname = argv[0];
argptr = argv + 1;
optptr = NULL; /* initialize nextopt */
exitstatus = (*builtinfunc[cmdentry.u.index])(argc, argv);
flushall();
cmddone:
cmdenviron = NULL;
out1 = &output;
out2 = &errout;
freestdout();
if (e != EXSHELLPROC) {
commandname = savecmdname;
if (flags & EV_EXIT) {
exitshell(exitstatus);
}
}
handler = savehandler;
if (e != -1) {
if ((e != EXERROR && e != EXEXEC)
|| cmdentry.u.index == BLTINCMD
|| cmdentry.u.index == DOTCMD
|| cmdentry.u.index == EVALCMD
#ifndef NO_HISTORY
|| cmdentry.u.index == HISTCMD
#endif
|| cmdentry.u.index == EXECCMD
|| cmdentry.u.index == COMMANDCMD)
exraise(e);
FORCEINTON;
}
if (cmdentry.u.index != EXECCMD)
popredir();
if (flags == EV_BACKCMD) {
backcmd->buf = memout.buf;
backcmd->nleft = memout.nextc - memout.buf;
memout.buf = NULL;
}
} else {
#if DEBUG
trputs("normal command: "); trargs(argv);
#endif
clearredir();
redirect(cmd->ncmd.redirect, 0);
for (sp = varlist.list ; sp ; sp = sp->next)
setvareq(sp->text, VEXPORT|VSTACK);
envp = environment();
shellexec(argv, envp, pathval(), cmdentry.u.index);
/*NOTREACHED*/
}
goto out;
parent: /* parent process gets here (if we forked) */
if (mode == 0) { /* argument to fork */
INTOFF;
exitstatus = waitforjob(jp, &realstatus);
INTON;
if (iflag && loopnest > 0 && WIFSIGNALED(realstatus)) {
evalskip = SKIPBREAK;
skipcount = loopnest;
}
} else if (mode == 2) {
backcmd->fd = pip[0];
close(pip[1]);
backcmd->jp = jp;
}
out:
if (lastarg)
setvar("_", lastarg, 0);
if (do_clearcmdentry)
clearcmdentry(0);
popstackmark(&smark);
}
STATIC void
evalcommand(union node *cmd, int flgs, struct backcmd *backcmd)
{
struct stackmark smark;
union node *argp;
struct arglist arglist;
struct arglist varlist;
volatile int flags = flgs;
char ** volatile argv;
volatile int argc;
char **envp;
int varflag;
struct strlist *sp;
volatile int mode;
int pip[2];
struct cmdentry cmdentry;
struct job * volatile jp;
struct jmploc jmploc;
struct jmploc *volatile savehandler = NULL;
const char *volatile savecmdname;
volatile struct shparam saveparam;
struct localvar *volatile savelocalvars;
volatile int e;
char * volatile lastarg;
const char * volatile path = pathval();
volatile int temp_path;
vforked = 0;
/* First expand the arguments. */
TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
setstackmark(&smark);
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(argp, &arglist, EXP_FULL | EXP_TILDE);
varflag = 0;
}
*arglist.lastp = NULL;
expredir(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(argp, &varlist, EXP_VARTILDE);
}
*varlist.lastp = NULL;
argc = 0;
for (sp = arglist.list ; sp ; sp = sp->next)
argc++;
argv = stalloc(sizeof (char *) * (argc + 1));
for (sp = arglist.list ; sp ; sp = sp->next) {
TRACE(("evalcommand arg: %s\n", sp->text));
*argv++ = sp->text;
}
*argv = NULL;
lastarg = NULL;
if (iflag && funcnest == 0 && argc > 0)
lastarg = argv[-1];
argv -= argc;
/* Print the command if xflag is set. */
if (xflag) {
char sep = 0;
out2str(ps4val());
for (sp = varlist.list ; sp ; sp = sp->next) {
char *p;
if (sep != 0)
outc(sep, &errout);
/*
* The "var=" part should not be quoted, regardless
* of the value, or it would not represent an
* assignment, but rather a command
*/
p = strchr(sp->text, '=');
if (p != NULL) {
*p = '\0'; /*XXX*/
out2shstr(sp->text);
out2c('=');
*p++ = '='; /*XXX*/
} else
p = sp->text;
out2shstr(p);
sep = ' ';
}
for (sp = arglist.list ; sp ; sp = sp->next) {
if (sep != 0)
outc(sep, &errout);
out2shstr(sp->text);
sep = ' ';
}
outc('\n', &errout);
flushout(&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(argv[0], &cmdentry, cmd_flags, path);
if (cmdentry.cmdtype == CMDUNKNOWN) {
exitstatus = 127;
flushout(&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(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() + 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 || (trap[0] && (flags & EV_EXIT) != 0)
|| (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(cmd, 1);
mode = cmd->ncmd.backgnd;
if (flags & EV_BACKCMD) {
mode = FORK_NOJOB;
if (sh_pipe(pip) < 0)
error("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 (usefork == 0 && cmdentry.cmdtype == CMDNORMAL) {
pid_t pid;
int serrno;
savelocalvars = localvars;
localvars = NULL;
vforked = 1;
switch (pid = vfork()) {
case -1:
serrno = errno;
TRACE(("Vfork failed, errno=%d\n", serrno));
INTON;
error("Cannot vfork (%s)", strerror(serrno));
break;
case 0:
/* Make sure that exceptions only unwind to
* after the vfork(2)
*/
if (setjmp(jmploc.loc)) {
if (exception == EXSHELLPROC) {
/* We can't progress with the vfork,
* so, set vforked = 2 so the parent
* knows, and _exit();
*/
vforked = 2;
_exit(0);
} else {
_exit(exerrno);
}
}
savehandler = handler;
handler = &jmploc;
listmklocal(varlist.list, VEXPORT | VNOFUNC);
forkchild(jp, cmd, mode, vforked);
break;
default:
handler = savehandler; /* restore from vfork(2) */
poplocalvars();
localvars = savelocalvars;
if (vforked == 2) {
vforked = 0;
(void)waitpid(pid, NULL, 0);
/* We need to progress in a normal fork fashion */
goto normal_fork;
}
vforked = 0;
forkparent(jp, cmd, mode, pid);
goto parent;
}
} else {
normal_fork:
#endif
if (forkshell(jp, cmd, mode) != 0)
goto parent; /* at end of routine */
FORCEINTON;
#ifdef DO_SHAREDVFORK
}
#endif
if (flags & EV_BACKCMD) {
if (!vforked) {
FORCEINTON;
}
close(pip[0]);
if (pip[1] != 1) {
close(1);
copyfd(pip[1], 1, 1, 0);
close(pip[1]);
}
}
flags |= EV_EXIT;
}
/* This is the child process if a fork occurred. */
/* Execute the command. */
switch (cmdentry.cmdtype) {
case CMDFUNCTION:
#ifdef DEBUG
trputs("Shell function: "); trargs(argv);
#endif
redirect(cmd->ncmd.redirect, REDIR_PUSH);
saveparam = shellparam;
shellparam.malloc = 0;
shellparam.reset = 1;
shellparam.nparam = argc - 1;
shellparam.p = argv + 1;
shellparam.optnext = NULL;
INTOFF;
savelocalvars = localvars;
localvars = NULL;
INTON;
if (setjmp(jmploc.loc)) {
if (exception == EXSHELLPROC) {
freeparam((volatile struct shparam *)
&saveparam);
} else {
freeparam(&shellparam);
shellparam = saveparam;
}
poplocalvars();
localvars = savelocalvars;
handler = savehandler;
longjmp(handler->loc, 1);
}
savehandler = handler;
handler = &jmploc;
listmklocal(varlist.list, VEXPORT);
/* stop shell blowing its stack */
if (++funcnest > 1000)
error("too many nested function calls");
evaltree(cmdentry.u.func, flags & EV_TESTED);
funcnest--;
INTOFF;
poplocalvars();
localvars = savelocalvars;
freeparam(&shellparam);
shellparam = saveparam;
handler = savehandler;
popredir();
INTON;
if (evalskip == SKIPFUNC) {
evalskip = SKIPNONE;
skipcount = 0;
}
if (flags & EV_EXIT)
exitshell(exitstatus);
break;
case CMDBUILTIN:
case CMDSPLBLTIN:
#ifdef DEBUG
trputs("builtin command: "); trargs(argv);
#endif
mode = (cmdentry.u.bltin == execcmd) ? 0 : REDIR_PUSH;
if (flags == EV_BACKCMD) {
memout.nleft = 0;
memout.nextc = memout.buf;
memout.bufsize = 64;
mode |= REDIR_BACKQ;
}
e = -1;
savehandler = handler;
savecmdname = commandname;
handler = &jmploc;
temp_path = 0;
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() && (cmdentry.u.bltin == hashcmd ||
cmdentry.u.bltin == typecmd)) {
savelocalvars = localvars;
localvars = 0;
temp_path = 1;
mklocal(path - 5 /* PATH= */, 0);
}
redirect(cmd->ncmd.redirect, mode);
/* exec is a special builtin, but needs this list... */
cmdenviron = varlist.list;
/* we must check 'readonly' flag for all builtins */
listsetvar(varlist.list,
cmdentry.cmdtype == CMDSPLBLTIN ? 0 : VNOSET);
commandname = argv[0];
/* initialize nextopt */
argptr = argv + 1;
optptr = NULL;
/* and getopt */
optreset = 1;
optind = 1;
builtin_flags = flags;
exitstatus = cmdentry.u.bltin(argc, argv);
} else {
e = exception;
exitstatus = e == EXINT ? SIGINT + 128 :
e == EXEXEC ? exerrno : 2;
}
handler = savehandler;
flushall();
out1 = &output;
out2 = &errout;
freestdout();
if (temp_path) {
poplocalvars();
localvars = savelocalvars;
}
cmdenviron = NULL;
if (e != EXSHELLPROC) {
commandname = savecmdname;
if (flags & EV_EXIT)
exitshell(exitstatus);
}
if (e != -1) {
if ((e != EXERROR && e != EXEXEC)
|| cmdentry.cmdtype == CMDSPLBLTIN)
exraise(e);
FORCEINTON;
}
if (cmdentry.u.bltin != execcmd)
popredir();
if (flags == EV_BACKCMD) {
backcmd->buf = memout.buf;
backcmd->nleft = memout.nextc - memout.buf;
memout.buf = NULL;
}
break;
default:
#ifdef DEBUG
trputs("normal command: "); trargs(argv);
#endif
redirect(cmd->ncmd.redirect,
(vforked ? REDIR_VFORK : 0) | REDIR_KEEP);
if (!vforked)
for (sp = varlist.list ; sp ; sp = sp->next)
setvareq(sp->text, VEXPORT|VSTACK);
envp = environment();
shellexec(argv, envp, path, cmdentry.u.index, vforked);
break;
}
goto out;
parent: /* parent process gets here (if we forked) */
exitstatus = 0; /* if not altered just below */
if (mode == FORK_FG) { /* argument to fork */
exitstatus = waitforjob(jp);
} else if (mode == FORK_NOJOB) {
backcmd->fd = pip[0];
close(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("_", lastarg, 0);
popstackmark(&smark);
}
SH_NORETURN_1 void
shell_main(shinstance *psh, int argc, char **argv)
{
struct jmploc jmploc;
struct stackmark smark;
volatile int state;
char *shinit;
state = 0;
if (setjmp(jmploc.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (psh->exception) {
case EXSHELLPROC:
psh->rootpid = /*getpid()*/ psh->pid;
psh->rootshell = 1;
psh->minusc = NULL;
state = 3;
break;
case EXEXEC:
psh->exitstatus = psh->exerrno;
break;
case EXERROR:
psh->exitstatus = 2;
break;
default:
break;
}
if (psh->exception != EXSHELLPROC) {
if (state == 0 || iflag(psh) == 0 || ! psh->rootshell)
exitshell(psh, psh->exitstatus);
}
reset(psh);
if (psh->exception == EXINT
#if ATTY
&& (! attyset(psh) || equal(termval(psh), "emacs"))
#endif
) {
out2c(psh, '\n');
flushout(&psh->errout);
}
popstackmark(psh, &smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
psh->handler = &jmploc;
psh->rootpid = /*getpid()*/ psh->pid;
psh->rootshell = 1;
#ifdef DEBUG
#if DEBUG == 2
debug(psh) = 1;
#endif
opentrace(psh);
trputs(psh, "Shell args: "); trargs(psh, argv);
#endif
init(psh);
setstackmark(psh, &smark);
procargs(psh, argc, argv);
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile(psh, "/etc/profile");
state1:
state = 2;
read_profile(psh, ".profile");
}
state2:
state = 3;
if (sh_getuid(psh) == sh_geteuid(psh) && sh_getgid(psh) == sh_getegid(psh)) {
if ((shinit = lookupvar(psh, "ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(psh, shinit);
}
}
state3:
state = 4;
if (sflag(psh) == 0 || psh->minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
unsigned i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(psh, sigs[i], 0);
}
if (psh->minusc)
evalstring(psh, psh->minusc, 0);
if (sflag(psh) || psh->minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(psh, 1);
}
exitshell(psh, psh->exitstatus);
/* NOTREACHED */
}
int
main(int argc, char *argv[])
{
struct stackmark smark, smark2;
volatile int state;
char *shinit;
#ifdef CBSD
char *MY_APP = NULL;
char *cbsdpath = NULL;
char *workdir = NULL;
char *cbsd_disable_history = NULL; //getenv
chdir("/var/empty");
/* Only use history when stdin is a tty. */
if ( isatty(0) && isatty(1) ) {
cbsd_enable_history = 1;
}
#endif
(void) setlocale(LC_ALL, "");
initcharset();
state = 0;
if (setjmp(main_handler.loc)) {
switch (exception) {
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (state == 0 || iflag == 0 || ! rootshell ||
exception == EXEXIT)
exitshell(exitstatus);
reset();
if (exception == EXINT)
out2fmt_flush("\n");
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &main_handler;
#ifdef DEBUG
opentrace();
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
rootshell = 1;
INTOFF;
initvar();
setstackmark(&smark);
setstackmark(&smark2);
#ifdef CBSD
if (argc>1) {
if (!strcmp(argv[1],"--help")) {
system("/usr/local/bin/cbsd help");
exit(0);
} else {
if (!strcmp(argv[1],"version")) {
printf("%s\n",VERSION);
exit(0);
}
}
}
cbsd_disable_history=lookupvar("NO_CBSD_HISTORY");
if ( cbsd_disable_history != NULL ) cbsd_enable_history=0;
workdir=lookupvar("workdir");
if ( workdir == NULL ) {
read_profile("/etc/rc.conf");
setvarsafe("workdir", lookupvar("cbsd_workdir"), 0);
}
workdir=lookupvar("workdir");
if ( workdir == NULL ) {
out2fmt_flush("cbsd: no workdir defined\n");
exitshell(1);
}
setvarsafe("PS1","cbsd@\\h> ",1);
setvarsafe("workdir",workdir,1);
workdir=lookupvar("workdir"); // ^^ after "setsave*" original is free
cbsdpath = calloc(MAXPATHLEN, sizeof(char *));
if (argv[1]) {
setvarsafe("CBSD_APP",basename(argv[1]),1);
}
if (cbsdpath == NULL) {
out2fmt_flush("cbsd: out of memory for cbsdpath\n");
exitshell(1);
}
// %s/modules must be first for opportunity to have a module commands greater priority than the original CBSD command.
// This makes it possible to write a 3rd party modules with altered functionality of the original code.
sprintf(cbsdpath,"%s/modules:%s/bin:%s/sbin:%s/tools:%s/jailctl:%s/nodectl:%s/system:/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin",workdir,cbsd_distdir,cbsd_distdir,cbsd_distdir,cbsd_distdir,cbsd_distdir,cbsd_distdir);
setvarsafe("PATH",cbsdpath,1);
ckfree(cbsdpath);
// read global params first (disable/enable colors, repos etc..)
read_profile("${workdir}/etc/defaults/global.conf");
read_profile("${workdir}/etc/global.conf");
if (lookupvar("NOCOLOR") != NULL ) {
putenv("NOCOLOR=1");
}
// non-interactive global env
if (lookupvar("NOINTER") != NULL ) {
setvarsafe("inter","1",1);
putenv("inter=0");
}
read_profile("/usr/local/cbsd/cbsd.conf");
read_profile("${workdir}/etc/defaults/logger.conf");
read_profile("${workdir}/etc/logger.conf");
if (cbsd_enable_history==1) {
cbsd_history_file=calloc(MAXPATHLEN, sizeof(char *));
sprintf(cbsd_history_file,"%s/%s",workdir,CBSD_HISTORYFILE);
}
#endif
procargs(argc, argv);
pwd_init(iflag);
INTON;
#ifndef CBSD
if (iflag)
chkmail(1);
#endif
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
if (privileged == 0)
read_profile("${HOME-}/.profile");
else
read_profile("/etc/suid_profile");
}
state2:
state = 3;
if (!privileged && iflag) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(shinit);
}
}
state3:
state = 4;
popstackmark(&smark2);
if (minusc) {
evalstring(minusc, sflag ? 0 : EV_EXIT);
}
state4:
if (sflag || minusc == NULL) {
cmdloop(1);
}
exitshell(exitstatus);
/*NOTREACHED*/
return 0;
}
