static void
sh_check_init() {
struct rlimit l;
if (getrlimit(RLIMIT_CORE, &l) == -1) {
sh_exit("getrlimit core fail: %s", strerror(errno));
}
if (l.rlim_cur != RLIM_INFINITY) {
l.rlim_cur = RLIM_INFINITY;
l.rlim_max = RLIM_INFINITY;
if (setrlimit(RLIMIT_CORE, &l) == -1) {
sh_exit("setrlimit core fail: %s", strerror(errno));
}
}
int max = sh_getint("connmax", 0) + 1000;
if (getrlimit(RLIMIT_NOFILE, &l) == -1) {
sh_exit("getrlimit nofile fail: %s", strerror(errno));
}
if (l.rlim_cur < max) {
l.rlim_cur = max;
if (l.rlim_max < l.rlim_cur) {
l.rlim_max = l.rlim_cur;
}
if (setrlimit(RLIMIT_NOFILE, &l) == -1) {
sh_exit("setrlimit nofile %d fail: %s", max, strerror(errno));
}
}
}
int b_return(register int n, register char *argv[],Shbltin_t *context)
{
register char *arg;
register Shell_t *shp = context->shp;
struct checkpt *pp = (struct checkpt*)shp->jmplist;
const char *options = (**argv=='r'?sh_optreturn:sh_optexit);
while((n = optget(argv,options))) switch(n)
{
case ':':
if(!strmatch(argv[opt_info.index],"[+-]+([0-9])"))
errormsg(SH_DICT,2, "%s", opt_info.arg);
goto done;
case '?':
errormsg(SH_DICT,ERROR_usage(0), "%s", opt_info.arg);
return(2);
}
done:
if(error_info.errors)
errormsg(SH_DICT,ERROR_usage(2),"%s",optusage((char*)0));
pp->mode = (**argv=='e'?SH_JMPEXIT:SH_JMPFUN);
argv += opt_info.index;
n = (((arg= *argv)?(int)strtol(arg, (char**)0, 10):shp->oldexit));
if(n<0 || n==256 || n > SH_EXITMASK+shp->gd->sigmax)
n &= ((unsigned int)n)&SH_EXITMASK;
/* return outside of function, dotscript and profile is exit */
if(shp->fn_depth==0 && shp->dot_depth==0 && !sh_isstate(shp,SH_PROFILE))
pp->mode = SH_JMPEXIT;
sh_exit(shp,shp->savexit=n);
return(1);
}
static_fn void put_funcname(Namval_t *np, const void *val, int flags, Namfun_t *fp) {
// Bash silently returns with an error when FUNCNAME is set, unsetting
// FUNCNAME is allowed.
if (val && !(flags & NV_RDONLY)) sh_exit(sh_getinterp(), 1);
nv_putv(np, val, flags, fp);
}
void
sh_errx(int status, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
exvwarning(-1, fmt, ap);
va_end(ap);
sh_exit(status);
}
int buildin(char*** args, magick_t* mg)
{
int ret = 0;
if (strcmp(args[0][0], "exit") == 0) {
sh_exit(args);
return ret;
} else if (strcmp(args[0][0], "cd") == 0) {
ret = sh_cd(args);
return ret;
} else {
return 255;
}
}
int built_in(char **argv, char **env)
{
int i;
i = 0;
if (ft_strcmp(argv[0], "exit") == 0 && (i = 1))
sh_exit(argv, 42);
else if (ft_strcmp(argv[0], "cd") == 0 && (i = 1))
sh_cd(argv);
else if (ft_strcmp(argv[0], "env") == 0 && (i = 1))
sh_env(argv, env);
else if (ft_strcmp(argv[0], "setenv") == 0 && (i = 1))
sh_setenv(argv);
else if (ft_strcmp(argv[0], "unsetenv") == 0 && (i = 1))
sh_unsetenv(argv);
else if (ft_strcmp(argv[0], "help") == 0 && (i = 1))
sh_help();
return (i);
}
void ft_cmd(char *line, t_cmd *cmd)
{
char **tab;
int i;
i = 0;
tab = ft_strsplit(line, ';');
while (tab[i])
{
if (is_empty(tab[i]))
{
parse(tab[i], cmd);
if (!ft_strcmp(cmd->cmd, "exit"))
sh_exit(cmd);
else
exec(cmd);
}
i++;
}
}
void
sh_verrx(int status, const char *fmt, va_list ap)
{
exvwarning(-1, fmt, ap);
sh_exit(status);
}
// This routine turns options on and off.
// The options "PDicr" are illegal from set command.
// The -o option is used to set option by name.
// This routine returns the number of non-option arguments.
int sh_argopts(int argc, char *argv[], void *context) {
Shell_t *shp = context;
int n, o;
Arg_t *ap = shp->arg_context;
Lex_t *lp = shp->lex_context;
Shopt_t newflags;
int setflag = 0, action = 0, trace = (int)sh_isoption(shp, SH_XTRACE);
Namval_t *np = NULL;
const char *sp;
char *keylist = NULL;
int verbose, f, unsetnp = 0;
Optdisc_t disc;
newflags = shp->options;
memset(&disc, 0, sizeof(disc));
disc.version = OPT_VERSION;
disc.infof = infof;
opt_info.disc = &disc;
if (argc > 0) {
setflag = 4;
} else {
argc = -argc;
}
while ((n = optget(argv, setflag ? sh_optset : sh_optksh))) {
o = 0;
f = *opt_info.option == '-' && (opt_info.num || opt_info.arg);
switch (n) {
case 'A': {
np = nv_open(opt_info.arg, shp->var_tree, NV_ARRAY | NV_VARNAME);
if (f) unsetnp = 1;
continue;
}
case 'K': {
keylist = opt_info.arg;
continue;
}
#if SHOPT_BASH
case 'O': { // shopt options, only in bash mode
if (!sh_isoption(shp, SH_BASH)) {
errormsg(SH_DICT, ERROR_exit(1), e_option, opt_info.name);
__builtin_unreachable();
}
}
#endif
// FALLTHRU
case 'o': { // set options
byname:
if (!opt_info.arg || !*opt_info.arg || *opt_info.arg == '-') {
action = PRINT;
// print style: -O => shopt options.
// bash => print unset options also, no heading.
verbose = (f ? PRINT_VERBOSE : PRINT_NO_HEADER) | (n == 'O' ? PRINT_SHOPT : 0) |
(sh_isoption(shp, SH_BASH) ? PRINT_ALL | PRINT_NO_HEADER : 0) |
((opt_info.arg && (!*opt_info.arg || *opt_info.arg == '-'))
? (PRINT_TABLE | PRINT_NO_HEADER)
: 0);
continue;
}
o = sh_lookopt(opt_info.arg, &f);
if (o <= 0 || (!sh_isoption(shp, SH_BASH) && (o & SH_BASHEXTRA)) ||
((!sh_isoption(shp, SH_BASH) || n == 'o') && (o & SH_BASHOPT))
|| (setflag && (o & SH_COMMANDLINE))) {
errormsg(SH_DICT, 2, e_option, opt_info.arg);
error_info.errors++;
}
o &= 0xff;
if (sh_isoption(shp, SH_RESTRICTED) && !f && o == SH_RESTRICTED) {
errormsg(SH_DICT, ERROR_exit(1), e_restricted, opt_info.arg);
__builtin_unreachable();
}
break;
}
#if SHOPT_BASH
case -1: { // --rcfile
shp->gd->rcfile = opt_info.arg;
continue;
}
case -2: { // --noediting
if (!f) {
off_option(&newflags, SH_VI);
off_option(&newflags, SH_EMACS);
off_option(&newflags, SH_GMACS);
}
continue;
}
case -3: { // --profile
n = 'l';
sp = strchr(optksh, n);
if (sp) o = flagval[sp - optksh];
break;
}
case -4: { // --posix
// Mask lower 8 bits to find char in optksh string.
n &= 0xff;
sp = strchr(optksh, n);
if (sp) o = flagval[sp - optksh];
break;
}
case -5: { // --version
sfputr(sfstdout, "ksh bash emulation, version ", -1);
np = nv_open("BASH_VERSION", shp->var_tree, 0);
sfputr(sfstdout, nv_getval(np), -1);
np = nv_open("MACHTYPE", shp->var_tree, 0);
sfprintf(sfstdout, " (%s)\n", nv_getval(np));
sh_exit(shp, 0);
}
#endif
case -6: { // --default
const Shtable_t *tp;
for (tp = shtab_options; (o = tp->sh_number); tp++) {
if (!(o & SH_COMMANDLINE) && is_option(&newflags, o & 0xff)) {
off_option(&newflags, o & 0xff);
}
}
continue;
}
case -7: {
f = 0;
goto byname;
}
case 'D': {
on_option(&newflags, SH_NOEXEC);
// Cppcheck doesn't recognize the "goto" in the preceding case and thus thinks we
// might fall through and call strchr() with n == -7. Even though this it
// technically a bug in cppcheck it is one reason why `goto` shouldn't be used; at
// least inside `switch` blocks.
// cppcheck-suppress invalidFunctionArg
sp = strchr(optksh, n);
if (sp) o = flagval[sp - optksh];
break;
}
case 'T': {
if (opt_info.num) {
shp->test |= opt_info.num;
} else {
shp->test = 0;
}
continue;
}
case 's': {
if (setflag) {
action = SORT;
continue;
}
sp = strchr(optksh, n);
if (sp) o = flagval[sp - optksh];
break;
}
case 'R': {
if (setflag) {
n = ':';
} else {
ap->kiafile = opt_info.arg;
n = 'n';
}
sp = strchr(optksh, n);
if (sp) o = flagval[sp - optksh];
break;
}
case ':': {
if (opt_info.name[0] == '-' && opt_info.name[1] == '-') {
opt_info.arg = argv[opt_info.index - 1] + 2;
f = 1;
goto byname;
}
errormsg(SH_DICT, 2, "%s", opt_info.arg);
continue;
}
case '?': {
errormsg(SH_DICT, ERROR_usage(0), "%s", opt_info.arg);
return -1;
}
default: {
sp = strchr(optksh, n);
if (sp) o = flagval[sp - optksh];
break;
}
}
if (f) {
if (o == SH_VI || o == SH_EMACS || o == SH_GMACS) {
off_option(&newflags, SH_VI);
off_option(&newflags, SH_EMACS);
off_option(&newflags, SH_GMACS);
}
on_option(&newflags, o);
off_option(&shp->offoptions, o);
} else {
if (o == SH_RESTRICTED && sh_isoption(shp, SH_RESTRICTED)) {
errormsg(SH_DICT, ERROR_exit(1), e_restricted, "r");
__builtin_unreachable();
}
if (o == SH_XTRACE) trace = 0;
off_option(&newflags, o);
if (setflag == 0) on_option(&shp->offoptions, o);
}
}
if (error_info.errors) {
errormsg(SH_DICT, ERROR_usage(2), "%s", optusage(NULL));
__builtin_unreachable();
}
// Check for '-' or '+' argument.
sp = argv[opt_info.index];
if (sp && sp[1] == 0 && (*sp == '+' || *sp == '-') && strcmp(argv[opt_info.index - 1], "--")) {
opt_info.index++;
off_option(&newflags, SH_XTRACE);
off_option(&newflags, SH_VERBOSE);
trace = 0;
}
if (trace) sh_trace(shp, argv, 1);
argc -= opt_info.index;
argv += opt_info.index;
if (action == PRINT) sh_printopts(shp, newflags, verbose, 0);
if (setflag) {
if (action == SORT) {
int (*sortfn)(const char *, const char *) = strcoll;
Namarr_t *arp;
struct Value *args;
unsigned char *bits;
if (argc > 0) {
strsort(argv, argc, sortfn);
} else if (np && (arp = nv_arrayptr(np)) && (args = nv_aivec(np, &bits))) {
char *cp;
int i, c, keys = 0;
if (keylist) {
for (cp = keylist; (c = *cp); cp++) {
if (c == ',') keys++;
}
keys++;
} else {
keylist = "";
}
arp->nelem = nv_aipack(arp);
cp = nv_name(np);
c = strlen(cp);
// This used to multiply by `(keys - 1)` but `keys` can be zero which means the
// nodesize can be less than `sizeof(struct Node)` which is obviously wrong.
// Whether multiplying by `keys` is correct is unclear.
// See issue #824.
size_t nodesize = sizeof(struct Node) + keys * sizeof(Namval_t *);
struct Sort *sp =
malloc(sizeof(struct Sort) + strlen(keylist) + (sizeof(char *) + 1) * keys +
(arp->nelem + 1) * (nodesize + sizeof(void *)) + c + 3);
sp->shp = shp;
sp->np = np;
if (!(sp->root = shp->last_root)) sp->root = shp->var_tree;
sp->vp = args;
sp->cur = 0;
sp->nodes = (struct Node *)&sp->keys[keys + 2];
memset(sp->nodes, 0, arp->nelem * nodesize);
sp->nptrs = (struct Node **)((char *)sp->nodes + arp->nelem * nodesize);
sp->flags = (char *)&sp->nptrs[arp->nelem + 1];
memset(sp->flags, 0, keys + 1);
sp->name = sp->flags + keys + 1;
memcpy(sp->name, cp, c + 1);
sp->keys[0] = sp->name + c + 1;
strcpy(sp->keys[0], keylist);
cp = (char *)sp->nodes;
for (c = 0; c < arp->nelem; c++) {
if (*keylist && *keylist != ':') {
struct Namval *np = FETCH_VT(args[c], np);
((struct Node *)cp)->index = strtol(np->nvname, NULL, 10);
((struct Node *)cp)->bits = bits[c];
} else {
((struct Node *)cp)->index = c;
}
((struct Node *)cp)->vp = args[c];
sp->nptrs[c] = (struct Node *)cp;
cp += nodesize;
}
if (!(cp = sp->keys[0])) cp = keylist;
for (keys = 0; (c = *cp); cp++) {
if (c == ',') {
*cp++ = 0;
sp->keys[++keys] = cp;
sp->flags[keys] = 0;
} else if (c == ':') {
again:
*cp++ = 0;
c = *cp;
if (c == 'r') {
sp->flags[keys] |= SORT_reverse;
c = cp[1];
} else if (c == 'n') {
sp->flags[keys] |= SORT_numeric;
c = cp[1];
}
if (c == 'n' || c == 'r') goto again;
}
}
sp->keys[++keys] = 0;
Sp = sp;
if (sp->keys[0] && *sp->keys[0]) {
sortfn = arraysort;
} else if (sp->flags[0] & SORT_numeric) {
sortfn = numsort;
} else {
sortfn = alphasort;
}
strsort((char **)sp->nptrs, arp->nelem, sortfn);
cp = (char *)sp->nodes;
for (c = 0; c < arp->nelem; c++) {
i = (char *)sp->nptrs[c] - (char *)&sp->nodes[0];
if (i / nodesize != c) {
args[c] = ((struct Node *)(cp + i))->vp;
bits[c] = ((struct Node *)(cp + i))->bits;
}
}
free(sp);
nv_close(np);
np = NULL;
} else {
strsort(shp->st.dolv + 1, shp->st.dolc, sortfn);
}
}
if (np) {
if (unsetnp) nv_unset(np);
nv_setvec(np, 0, argc, argv);
nv_close(np);
} else if (argc > 0 || ((sp = argv[-1]) && strcmp(sp, "--") == 0)) {
sh_argset(ap, argv - 1);
}
} else if (is_option(&newflags, SH_CFLAG)) {
if (!(shp->comdiv = *argv++)) {
errormsg(SH_DICT, 2, e_cneedsarg);
errormsg(SH_DICT, ERROR_usage(2), optusage(NULL));
__builtin_unreachable();
}
argc--;
}
// Handling SH_INTERACTIVE and SH_PRIVILEGED has been moved to
// sh_applyopts(), so that the code can be reused from b_shopt(), too.
sh_applyopts(shp, newflags);
if (!ap->kiafile) return argc;
if (!argv[0]) {
errormsg(SH_DICT, ERROR_usage(2), "-R requires scriptname");
__builtin_unreachable();
}
if (!(lp->kiafile = sfopen(NULL, ap->kiafile, "w+"))) {
errormsg(SH_DICT, ERROR_system(3), e_create, ap->kiafile);
__builtin_unreachable();
}
if (!(lp->kiatmp = sftmp(2 * SF_BUFSIZE))) {
errormsg(SH_DICT, ERROR_system(3), e_tmpcreate);
__builtin_unreachable();
}
sfputr(lp->kiafile, ";vdb;CIAO/ksh", '\n');
lp->kiabegin = sftell(lp->kiafile);
lp->entity_tree = dtopen(&_Nvdisc, Dtbag);
lp->scriptname = strdup(sh_fmtq(argv[0]));
lp->script = kiaentity(lp, lp->scriptname, -1, 'p', -1, 0, 0, 's', 0, "");
lp->fscript = kiaentity(lp, lp->scriptname, -1, 'f', -1, 0, 0, 's', 0, "");
lp->unknown = kiaentity(lp, "<unknown>", -1, 'p', -1, 0, 0, '0', 0, "");
kiaentity(lp, "<unknown>", -1, 'p', 0, 0, lp->unknown, '0', 0, "");
lp->current = lp->script;
ap->kiafile = NULL;
return argc;
}
/*
* This routine turns options on and off
* The options "PDicr" are illegal from set command.
* The -o option is used to set option by name
* This routine returns the number of non-option arguments
*/
int sh_argopts(int argc,register char *argv[], void *context)
{
Shell_t *shp = (Shell_t*)context;
register int n,o;
register Arg_t *ap = (Arg_t*)(shp->arg_context);
Lex_t *lp = (Lex_t*)(shp->lex_context);
Shopt_t newflags;
int setflag=0, action=0, trace=(int)sh_isoption(SH_XTRACE);
Namval_t *np = NIL(Namval_t*);
const char *cp;
int verbose,f;
Optdisc_t disc;
newflags=ap->sh->options;
memset(&disc, 0, sizeof(disc));
disc.version = OPT_VERSION;
disc.infof = infof;
opt_info.disc = &disc;
if(argc>0)
setflag = 4;
else
argc = -argc;
while((n = optget(argv,setflag?sh_optset:sh_optksh)))
{
o=0;
f=*opt_info.option=='-' && (opt_info.num || opt_info.arg);
switch(n)
{
case 'A':
np = nv_open(opt_info.arg,ap->sh->var_tree,NV_NOASSIGN|NV_ARRAY|NV_VARNAME);
if(f)
nv_unset(np);
continue;
#if SHOPT_BASH
case 'O': /* shopt options, only in bash mode */
if(!sh_isoption(SH_BASH))
errormsg(SH_DICT,ERROR_exit(1), e_option, opt_info.name);
#endif
case 'o': /* set options */
byname:
if(!opt_info.arg||!*opt_info.arg||*opt_info.arg=='-')
{
action = PRINT;
/* print style: -O => shopt options
* bash => print unset options also, no heading
*/
verbose = (f?PRINT_VERBOSE:PRINT_NO_HEADER)|
(n=='O'?PRINT_SHOPT:0)|
(sh_isoption(SH_BASH)?PRINT_ALL|PRINT_NO_HEADER:0)|
((opt_info.arg&&(!*opt_info.arg||*opt_info.arg=='-'))?(PRINT_TABLE|PRINT_NO_HEADER):0);
continue;
}
o = sh_lookopt(opt_info.arg,&f);
if(o<=0
|| (!sh_isoption(SH_BASH) && (o&SH_BASHEXTRA))
|| ((!sh_isoption(SH_BASH) || n=='o') && (o&SH_BASHOPT))
|| (setflag && (o&SH_COMMANDLINE)))
{
errormsg(SH_DICT,2, e_option, opt_info.arg);
error_info.errors++;
}
o &= 0xff;
if(sh_isoption(SH_RESTRICTED) && !f && o==SH_RESTRICTED)
errormsg(SH_DICT,ERROR_exit(1), e_restricted, opt_info.arg);
break;
#if SHOPT_BASH
case -1: /* --rcfile */
ap->sh->gd->rcfile = opt_info.arg;
continue;
case -2: /* --noediting */
if (!f)
{
off_option(&newflags,SH_VI);
off_option(&newflags,SH_EMACS);
off_option(&newflags,SH_GMACS);
}
continue;
case -3: /* --profile */
n = 'l';
goto skip;
case -4: /* --posix */
/* mask lower 8 bits to find char in optksh string */
n&=0xff;
goto skip;
case -5: /* --version */
sfputr(sfstdout, "ksh bash emulation, version ",-1);
np = nv_open("BASH_VERSION",ap->sh->var_tree,0);
sfputr(sfstdout, nv_getval(np),-1);
np = nv_open("MACHTYPE",ap->sh->var_tree,0);
sfprintf(sfstdout, " (%s)\n", nv_getval(np));
sh_exit(0);
#endif
case -6: /* --default */
{
register const Shtable_t *tp;
for(tp=shtab_options; o = tp->sh_number; tp++)
if(!(o&SH_COMMANDLINE) && is_option(&newflags,o&0xff))
off_option(&newflags,o&0xff);
}
continue;
case -7:
f = 0;
goto byname;
case 'D':
on_option(&newflags,SH_NOEXEC);
goto skip;
case 'T':
if (opt_info.num)
ap->sh->test |= opt_info.num;
else
ap->sh->test = 0;
continue;
case 's':
if(setflag)
{
action = SORT;
continue;
}
#if SHOPT_KIA
goto skip;
case 'R':
if(setflag)
n = ':';
else
{
ap->kiafile = opt_info.arg;
n = 'n';
}
/*FALLTHROUGH*/
#endif /* SHOPT_KIA */
#if SHOPT_REGRESS
goto skip;
case 'I':
continue;
#endif /* SHOPT_REGRESS */
skip:
default:
if(cp=strchr(optksh,n))
o = flagval[cp-optksh];
break;
case ':':
if(opt_info.name[0]=='-'&&opt_info.name[1]=='-')
{
opt_info.arg = argv[opt_info.index-1] + 2;
f = 1;
goto byname;
}
errormsg(SH_DICT,2, "%s", opt_info.arg);
continue;
case '?':
errormsg(SH_DICT,ERROR_usage(0), "%s", opt_info.arg);
return(-1);
}
if(f)
{
if(o==SH_VI || o==SH_EMACS || o==SH_GMACS)
{
off_option(&newflags,SH_VI);
off_option(&newflags,SH_EMACS);
off_option(&newflags,SH_GMACS);
}
on_option(&newflags,o);
off_option(&ap->sh->offoptions,o);
}
else
{
if(o==SH_XTRACE)
trace = 0;
off_option(&newflags,o);
if(setflag==0)
on_option(&ap->sh->offoptions,o);
}
}
if(error_info.errors)
errormsg(SH_DICT,ERROR_usage(2),"%s",optusage(NIL(char*)));
/* check for '-' or '+' argument */
if((cp=argv[opt_info.index]) && cp[1]==0 && (*cp=='+' || *cp=='-') &&
strcmp(argv[opt_info.index-1],"--"))
{
opt_info.index++;
off_option(&newflags,SH_XTRACE);
off_option(&newflags,SH_VERBOSE);
trace = 0;
}
if(trace)
sh_trace(shp,argv,1);
argc -= opt_info.index;
argv += opt_info.index;
if(action==PRINT)
sh_printopts(newflags,verbose,0);
if(setflag)
{
if(action==SORT)
{
if(argc>0)
strsort(argv,argc,strcoll);
else
strsort(ap->sh->st.dolv+1,ap->sh->st.dolc,strcoll);
}
if(np)
{
nv_setvec(np,0,argc,argv);
nv_close(np);
}
else if(argc>0 || ((cp=argv[-1]) && strcmp(cp,"--")==0))
sh_argset(ap,argv-1);
}
else if(is_option(&newflags,SH_CFLAG))
{
if(!(ap->sh->comdiv = *argv++))
{
errormsg(SH_DICT,2,e_cneedsarg);
errormsg(SH_DICT,ERROR_usage(2),optusage(NIL(char*)));
}
argc--;
}
/* main loop, parse lines into trees and execute them
* ----------------------------------------------------------------------- */
void sh_loop(void) {
struct parser p;
union node *list;
stralloc cmd;
/* if we're in interactive mode some
additional stuff is to be initialized */
if(source->mode & SOURCE_IACTIVE)
history_load();
stralloc_init(&cmd);
parse_init(&p, P_DEFAULT);
while(!(parse_gettok(&p, P_DEFAULT) & T_EOF)) {
p.pushback++;
parse_lineno = source->line;
var_setvint("LINENO", parse_lineno, V_DEFAULT);
/* launch the parser to get a complete command */
if((list = parse_list(&p)))
{
struct eval e;
if(source->mode & SOURCE_IACTIVE)
{
tree_printlist(list, &cmd, NULL);
stralloc_catc(&cmd, '\n');
stralloc_nul(&cmd);
history_set(cmd.s);
cmd.s = NULL;
history_advance();
}
#ifdef DEBUG
/* debug_list(list, 0);
buffer_putnlflush(fd_err->w);*/
#endif /* DEBUG */
eval_push(&e, E_JCTL);
eval_tree(&e, list, E_ROOT|E_LIST);
sh->exitcode = eval_pop(&e);
stralloc_zero(&cmd);
tree_free(list);
} else if(!(p.tok & (T_NL | T_SEMI | T_BGND))) {
/* we have a parse error */
if(p.tok != T_EOF)
parse_error(&p, 0);
/* exit if not interactive */
if(!(source->mode & SOURCE_IACTIVE))
sh_exit(1);
/* ..otherwise discard the input buffer */
source_flush();
p.pushback = 0;
}
if(p.tok & (T_NL|T_SEMI|T_BGND))
p.pushback = 0;
/* reset prompt */
prompt_number = 0;
}
}
/* execute another program, possibly searching for it first
*
* if the 'exec' argument is set it will never return
* ----------------------------------------------------------------------- */
int exec_program(char *path, char **argv, int exec, union node *redir) {
int ret = 0;
sigset_t nset, oset;
/* if we're gonna execve() a program and 'exec' isn't
set or we aren't in the root shell environment we
have to fork() so we can return */
if(!exec || sh->parent) {
pid_t pid;
struct fdstack io;
unsigned int n;
fdstack_push(&io);
/* buffered fds which have not a real effective file descriptor,
like here-docs which are read from strallocs and command
expansions, which write to strallocs can't be shared across
different process spaces, so we have to establish pipes */
if((n = fdstack_npipes(FD_HERE|FD_SUBST)))
fdstack_pipe(n, fdstack_alloc(n));
/* block child and interrupt signal, so we won't terminate ourselves
when the child does */
/*
sigemptyset(&nset);
sigaddset(&nset, SIGINT);
#ifdef SIGCHLD
sigaddset(&nset, SIGCHLD);
#endif
sigemptyset(&oset);
sigprocmask(SIG_BLOCK, &nset, &oset);
*/
sig_block();
/* in the parent wait for the child to finish and then return
or exit, according to the 'exec' argument */
if((pid = fork())) {
int status = 1;
/* this will close child ends of the pipes and read data from the parent end :) */
fdstack_pop(&io);
fdstack_data();
job_wait(NULL, pid, &status, 0);
job_status(pid, status);
ret = WEXITSTATUS(status);
#ifndef __MINGW32__
sigprocmask(SIG_SETMASK, &oset, NULL);
#endif
/* exit if 'exec' is set, otherwise return */
if(exec) sh_exit(ret);
return ret;
}
/* ...in the child we always exit */
sh_forked();
}
fdtable_exec();
fdstack_flatten();
/* when there is a path then we gotta execute a command,
otherwise we exit/return immediately */
if(path) {
/* export environment */
char **envp;
unsigned long envn = var_count(V_EXPORT) + 1;
envp = var_export(alloca(envn * sizeof(char *)));
/* try to execute the program */
execve(path, argv, envp);
/* execve() returned so it failed, we're gonna map
the error code to the appropriate POSIX errors */
ret = exec_error();
/* yield an error message */
sh_error(path);
}
/* we never return at this point! */
exit(ret);
}
/*
* This routine turns options on and off
* The options "PDicr" are illegal from set command.
* The -o option is used to set option by name
* This routine returns the number of non-option arguments
*/
int sh_argopts(int argc,register char *argv[], void *context)
{
Shell_t *shp = (Shell_t*)context;
register int n,o;
register Arg_t *ap = (Arg_t*)(shp->arg_context);
Lex_t *lp = (Lex_t*)(shp->lex_context);
Shopt_t newflags;
int setflag=0, action=0, trace=(int)sh_isoption(shp,SH_XTRACE);
Namval_t *np = NIL(Namval_t*);
const char *sp;
char *keylist=0;
int verbose,f,unsetnp=0;
Optdisc_t disc;
newflags=shp->options;
memset(&disc, 0, sizeof(disc));
disc.version = OPT_VERSION;
disc.infof = infof;
opt_info.disc = &disc;
if(argc>0)
setflag = 4;
else
argc = -argc;
while((n = optget(argv,setflag?sh_optset:sh_optksh)))
{
o=0;
f=*opt_info.option=='-' && (opt_info.num || opt_info.arg);
switch(n)
{
case 'A':
np = nv_open(opt_info.arg,shp->var_tree,NV_NOASSIGN|NV_ARRAY|NV_VARNAME);
if(f)
unsetnp=1;
continue;
case 'K':
keylist = opt_info.arg;
continue;
#if SHOPT_BASH
case 'O': /* shopt options, only in bash mode */
if(!sh_isoption(shp,SH_BASH))
errormsg(SH_DICT,ERROR_exit(1), e_option, opt_info.name);
#endif
case 'o': /* set options */
byname:
if(!opt_info.arg||!*opt_info.arg||*opt_info.arg=='-')
{
action = PRINT;
/* print style: -O => shopt options
* bash => print unset options also, no heading
*/
verbose = (f?PRINT_VERBOSE:PRINT_NO_HEADER)|
(n=='O'?PRINT_SHOPT:0)|
(sh_isoption(shp,SH_BASH)?PRINT_ALL|PRINT_NO_HEADER:0)|
((opt_info.arg&&(!*opt_info.arg||*opt_info.arg=='-'))?(PRINT_TABLE|PRINT_NO_HEADER):0);
continue;
}
o = sh_lookopt(opt_info.arg,&f);
if(o<=0
|| (!sh_isoption(shp,SH_BASH) && (o&SH_BASHEXTRA))
|| ((!sh_isoption(shp,SH_BASH) || n=='o') && (o&SH_BASHOPT))
|| (setflag && (o&SH_COMMANDLINE)))
{
errormsg(SH_DICT,2, e_option, opt_info.arg);
error_info.errors++;
}
o &= 0xff;
if(sh_isoption(shp,SH_RESTRICTED) && !f && o==SH_RESTRICTED)
errormsg(SH_DICT,ERROR_exit(1), e_restricted, opt_info.arg);
break;
#if SHOPT_BASH
case -1: /* --rcfile */
shp->gd->rcfile = opt_info.arg;
continue;
case -2: /* --noediting */
if (!f)
{
off_option(&newflags,SH_VI);
off_option(&newflags,SH_EMACS);
off_option(&newflags,SH_GMACS);
}
continue;
case -3: /* --profile */
n = 'l';
goto skip;
case -4: /* --posix */
/* mask lower 8 bits to find char in optksh string */
n&=0xff;
goto skip;
case -5: /* --version */
sfputr(sfstdout, "ksh bash emulation, version ",-1);
np = nv_open("BASH_VERSION",shp->var_tree,0);
sfputr(sfstdout, nv_getval(np),-1);
np = nv_open("MACHTYPE",shp->var_tree,0);
sfprintf(sfstdout, " (%s)\n", nv_getval(np));
sh_exit(shp,0);
#endif
case -6: /* --default */
{
register const Shtable_t *tp;
for(tp=shtab_options; o = tp->sh_number; tp++)
if(!(o&SH_COMMANDLINE) && is_option(&newflags,o&0xff))
off_option(&newflags,o&0xff);
}
continue;
case -7:
f = 0;
goto byname;
case 'D':
on_option(&newflags,SH_NOEXEC);
goto skip;
case 'T':
if (opt_info.num)
shp->test |= opt_info.num;
else
shp->test = 0;
continue;
case 's':
if(setflag)
{
action = SORT;
continue;
}
#if SHOPT_KIA
goto skip;
case 'R':
if(setflag)
n = ':';
else
{
ap->kiafile = opt_info.arg;
n = 'n';
}
/*FALLTHROUGH*/
#endif /* SHOPT_KIA */
#if SHOPT_REGRESS
goto skip;
case 'I':
continue;
#endif /* SHOPT_REGRESS */
skip:
default:
if(sp=strchr(optksh,n))
o = flagval[sp-optksh];
break;
case ':':
if(opt_info.name[0]=='-'&&opt_info.name[1]=='-')
{
opt_info.arg = argv[opt_info.index-1] + 2;
f = 1;
goto byname;
}
errormsg(SH_DICT,2, "%s", opt_info.arg);
continue;
case '?':
errormsg(SH_DICT,ERROR_usage(0), "%s", opt_info.arg);
return(-1);
}
if(f)
{
if(o==SH_VI || o==SH_EMACS || o==SH_GMACS)
{
off_option(&newflags,SH_VI);
off_option(&newflags,SH_EMACS);
off_option(&newflags,SH_GMACS);
}
on_option(&newflags,o);
off_option(&shp->offoptions,o);
}
else
{
if(o==SH_XTRACE)
trace = 0;
off_option(&newflags,o);
if(setflag==0)
on_option(&shp->offoptions,o);
}
}
if(error_info.errors)
errormsg(SH_DICT,ERROR_usage(2),"%s",optusage(NIL(char*)));
/* check for '-' or '+' argument */
if((sp=argv[opt_info.index]) && sp[1]==0 && (*sp=='+' || *sp=='-') &&
strcmp(argv[opt_info.index-1],"--"))
{
opt_info.index++;
off_option(&newflags,SH_XTRACE);
off_option(&newflags,SH_VERBOSE);
trace = 0;
}
if(trace)
sh_trace(shp,argv,1);
argc -= opt_info.index;
argv += opt_info.index;
if(action==PRINT)
sh_printopts(shp,newflags,verbose,0);
if(setflag)
{
if(action==SORT)
{
int (*sortfn)(const char*,const char*) = strcoll;
Namarr_t *arp;
union Value *args;
unsigned char *bits;
if(argc>0)
strsort(argv,argc,sortfn);
else if(np && (arp=nv_arrayptr(np)) && (args = nv_aivec(np,&bits)))
{
struct Sort *sp;
char *cp;
int i, c, keys=0;
size_t nodesize;
if(keylist)
{
for(cp=keylist;c= *cp; cp++)
{
if(c==',')
keys++;
}
keys++;
}
else
keylist = Empty;
arp->nelem = nv_aipack(arp);;
cp = nv_name(np);
c = strlen(cp);
nodesize = sizeof(struct Node)+(keys-1)*sizeof(Namval_t*);
sp = (struct Sort*)malloc(sizeof(struct Sort)+strlen(keylist)+(sizeof(char*)+1)*keys+(arp->nelem+1)*(nodesize+sizeof(void*))+c+3);
sp->shp = shp;
sp->np = np;
if(!(sp->root = shp->last_root))
sp->root = shp->var_tree;
sp->vp = args;
sp->cur = 0;
sp->nodes = (struct Node*)&sp->keys[keys+2];
memset(sp->nodes, 0, arp->nelem*nodesize);
sp->nptrs = (struct Node**)((char*)sp->nodes+arp->nelem*nodesize);
sp->flags = (char*)&sp->nptrs[arp->nelem+1];
memset(sp->flags,0,keys+1);
sp->name = sp->flags + keys+1;
memcpy(sp->name,cp,c+1);
sp->keys[0] = sp->name+c+1;
strcpy(sp->keys[0],keylist);
cp = (char*)sp->nodes;
for(c=0; c < arp->nelem; c++)
{
if(keylist!=Empty && *keylist!=':')
{
((struct Node*)cp)->index = strtol(args[c].np->nvname,NULL,10);
((struct Node*)cp)->bits = bits[c];
}
else
((struct Node*)cp)->index = c;
((struct Node*)cp)->vp = args[c];
sp->nptrs[c] = (struct Node*)cp;
cp += nodesize;
}
if(!(cp = sp->keys[0]))
cp = keylist;
for(keys=0;c= *cp; cp++)
{
if(c==',')
{
*cp++ = 0;
sp->keys[++keys] = cp;
sp->flags[keys] = 0;
}
else if(c==':')
{
again:
*cp++ = 0;
if((c= *cp) == 'r')
{
sp->flags[keys] |= SORT_reverse;
c = cp[1];
}
else if(c=='n')
{
sp->flags[keys] |= SORT_numeric;
c = cp[1];
}
if(c=='n' || c=='r')
goto again;
}
}
sp->keys[++keys] = 0;
Sp = sp;
if(sp->keys[0] && *sp->keys[0])
sortfn = arraysort;
else if(sp->flags[0]&SORT_numeric)
sortfn = numsort;
else
sortfn = alphasort;
strsort((char**)sp->nptrs,arp->nelem,sortfn);
cp = (char*)sp->nodes;
for(c=0; c < arp->nelem; c++)
{
i = (char*)sp->nptrs[c]-(char*)&sp->nodes[0];
if(i/nodesize !=c)
{
args[c] = ((struct Node*)(cp+i))->vp;
bits[c] = ((struct Node*)(cp+i))->bits;
}
}
free(sp);
nv_close(np);
np = 0;
}
else
strsort(shp->st.dolv+1,shp->st.dolc,sortfn);
}
if(np)
{
if(unsetnp)
nv_unset(np);
nv_setvec(np,0,argc,argv);
nv_close(np);
}
else if(argc>0 || ((sp=argv[-1]) && strcmp(sp,"--")==0))
sh_argset(ap,argv-1);
}
else if(is_option(&newflags,SH_CFLAG))
{
if(!(shp->comdiv = *argv++))
{
errormsg(SH_DICT,2,e_cneedsarg);
errormsg(SH_DICT,ERROR_usage(2),optusage(NIL(char*)));
}
argc--;
}
