static_fn int alphasort(const char *s1, const char *s2) {
struct Sort *sp = Sp;
int r = 0;
char *sp1, *sp2;
nv_putsub(sp->np, NULL, ((struct Node *)s1)->index, 0);
sp1 = nv_getval(sp->np);
nv_putsub(sp->np, NULL, ((struct Node *)s2)->index, 0);
sp2 = nv_getval(sp->np);
r = strcoll(sp1, sp2);
if (sp->flags[0] & SORT_reverse) r = -r;
return r;
}
static int arraysort(const char *s1, const char *s2)
{
struct Sort *sp = Sp;
Shell_t *shp = sp->shp;
int r=0, cur=sp->cur;
Namval_t *np1, *np2;
Namfun_t fun;
char *cp;
memset(&fun,0,sizeof(Namfun_t));
if(!(np1 = ((struct Node*)s1)->nodes[sp->cur]))
{
sfprintf(shp->strbuf,"%s[%i].%s%c",sp->name,((struct Node*)s1)->index,sp->keys[sp->cur],0);
cp = sfstruse(shp->strbuf);
np1 = nv_create(cp,sp->root,NV_VARNAME|NV_NOFAIL|NV_NOADD|NV_NOSCOPE,&fun);
((struct Node*)s1)->nodes[sp->cur] = np1;
}
if(!(np2 = ((struct Node*)s2)->nodes[sp->cur]))
{
sfprintf( shp->strbuf,"%s[%i].%s%c",sp->name,((struct Node*)s2)->index,sp->keys[sp->cur],0);
cp = sfstruse(shp->strbuf);
np2 = nv_create(cp,sp->root,NV_VARNAME|NV_NOFAIL|NV_NOADD|NV_NOSCOPE,&fun);
((struct Node*)s2)->nodes[sp->cur] = np2;
}
if(sp->flags[sp->cur]&SORT_numeric)
{
Sfdouble_t d1 = np1?nv_getnum(np1):0;
Sfdouble_t d2 = np2?nv_getnum(np2):0;
if(d2<d1)
r = 1;
else if(d2>d1)
r = -1;
}
else if(np1 && np2)
{
char *sp1 = nv_getval(np1);
char *sp2 = nv_getval(np2);
r = strcoll(sp1,sp2);
}
else if(np1)
r = 1;
else if(np2)
r = -1;
if(sp->flags[sp->cur]&SORT_reverse)
r = -r;
if(r==0 && sp->keys[++sp->cur])
r = arraysort(s1,s2);
sp->cur = cur;
return(r);
}
//
// Look for edit macro named _i. If found, puts the macro definition into lookahead buffer and
// returns 1.
//
int ed_macro(Edit_t *ep, int i) {
char *out;
Namval_t *np;
genchar buff[LOOKAHEAD + 1];
if (i != '@') ep->e_macro[1] = i;
// Undocumented feature, macros of the form <ESC>[c evoke alias __c.
if (i == '_') {
ep->e_macro[2] = ed_getchar(ep, 1);
} else {
ep->e_macro[2] = 0;
}
if (isalnum(i) && (np = nv_search(ep->e_macro, ep->sh->alias_tree, 0)) &&
(out = nv_getval(np))) {
// Copy to buff in internal representation.
int c = 0;
if (strlen(out) > LOOKAHEAD) {
c = out[LOOKAHEAD];
out[LOOKAHEAD] = 0;
}
i = ed_internal(out, buff);
if (c) out[LOOKAHEAD] = c;
while (i-- > 0) ed_ungetchar(ep, buff[i]);
return 1;
}
return 0;
}
static char *get_time(Namval_t* np, Namfun_t* nfp)
{
static char buff[256];
struct dctime *dp = (struct dctime*)nfp;
time_t t = nv_getn(np,nfp);
char *format = nv_getval(dp->format);
tmfmt(buff,sizeof(buff),format,(time_t*)0);
return(buff);
}
/*
* ED_WINDOW()
*
* return the window size
*/
int ed_window(void)
{
int rows,cols;
register char *cp = nv_getval(COLUMNS);
if(cp)
cols = (int)strtol(cp, (char**)0, 10)-1;
else
{
astwinsize(2,&rows,&cols);
if(--cols <0)
cols = DFLTWINDOW-1;
}
if(cols < MINWINDOW)
cols = MINWINDOW;
else if(cols > MAXWINDOW)
cols = MAXWINDOW;
return(cols);
}
static int acctinit(History_t *hp)
{
register char *cp, *acctfile;
Namval_t *np = nv_search("ACCTFILE",((Shell_t*)hp->histshell)->var_tree,0);
if(!np || !(acctfile=nv_getval(np)))
return(0);
if(!(cp = getlogin()))
{
struct passwd *userinfo = getpwuid(getuid());
if(userinfo)
cp = userinfo->pw_name;
else
cp = "unknown";
}
logname = strdup(cp);
if((acctfd=sh_open(acctfile,
O_BINARY|O_WRONLY|O_APPEND|O_CREAT,S_IRUSR|S_IWUSR))>=0 &&
(unsigned)acctfd < 10)
{
int n;
if((n = fcntl(acctfd, F_DUPFD, 10)) >= 0)
{
close(acctfd);
acctfd = n;
}
}
if(acctfd < 0)
{
acctfd = 0;
return(0);
}
if(sh_isdevfd(acctfile))
{
char newfile[16];
sfsprintf(newfile,sizeof(newfile),"%.8s%d\0",e_devfdNN,acctfd);
nv_putval(np,newfile,NV_RDONLY);
}
else
fcntl(acctfd,F_SETFD,FD_CLOEXEC);
return(1);
}
/*
* look for edit macro named _i
* if found, puts the macro definition into lookahead buffer and returns 1
*/
int ed_macro(Edit_t *ep, register int i)
{
register char *out;
Namval_t *np;
genchar buff[LOOKAHEAD+1];
if(i != '@')
ep->e_macro[1] = i;
/* undocumented feature, macros of the form <ESC>[c evoke alias __c */
if(i=='_')
ep->e_macro[2] = ed_getchar(ep,1);
else
ep->e_macro[2] = 0;
if (isalnum(i)&&(np=nv_search(ep->e_macro,ep->sh->alias_tree,HASH_SCOPE))&&(out=nv_getval(np)))
{
#if SHOPT_MULTIBYTE
/* copy to buff in internal representation */
int c = 0;
if( strlen(out) > LOOKAHEAD )
{
c = out[LOOKAHEAD];
out[LOOKAHEAD] = 0;
}
i = ed_internal(out,buff);
if(c)
out[LOOKAHEAD] = c;
#else
strncpy((char*)buff,out,LOOKAHEAD);
buff[LOOKAHEAD] = 0;
i = strlen((char*)buff);
#endif /* SHOPT_MULTIBYTE */
while(i-- > 0)
ed_ungetchar(ep,buff[i]);
return(1);
}
return(0);
}
// 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(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--;
}
/*
* 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--;
}
void ed_setup(register Edit_t *ep, int fd, int reedit)
{
Shell_t *shp = ep->sh;
register char *pp;
register char *last, *prev;
char *ppmax;
int myquote = 0, n;
register int qlen = 1, qwid;
char inquote = 0;
ep->e_fd = fd;
ep->e_multiline = sh_isoption(SH_MULTILINE)!=0;
#ifdef SIGWINCH
if(!(shp->sigflag[SIGWINCH]&SH_SIGFAULT))
{
signal(SIGWINCH,sh_fault);
shp->sigflag[SIGWINCH] |= SH_SIGFAULT;
}
pp = shp->st.trapcom[SIGWINCH];
shp->st.trapcom[SIGWINCH] = 0;
sh_fault(SIGWINCH);
shp->st.trapcom[SIGWINCH] = pp;
ep->sh->winch = 0;
#endif
#if SHOPT_EDPREDICT
ep->hlist = 0;
ep->nhlist = 0;
ep->hoff = 0;
#endif /* SHOPT_EDPREDICT */
#if KSHELL
ep->e_stkptr = stakptr(0);
ep->e_stkoff = staktell();
if(!(last = shp->prompt))
last = "";
shp->prompt = 0;
#else
last = ep->e_prbuff;
#endif /* KSHELL */
if(shp->gd->hist_ptr)
{
register History_t *hp = shp->gd->hist_ptr;
ep->e_hismax = hist_max(hp);
ep->e_hismin = hist_min(hp);
}
else
{
ep->e_hismax = ep->e_hismin = ep->e_hloff = 0;
}
ep->e_hline = ep->e_hismax;
if(!sh_isoption(SH_VI) && !sh_isoption(SH_EMACS) && !sh_isoption(SH_GMACS))
ep->e_wsize = MAXLINE;
else
ep->e_wsize = ed_window()-2;
ep->e_winsz = ep->e_wsize+2;
ep->e_crlf = 1;
ep->e_plen = 0;
pp = ep->e_prompt;
ppmax = pp+PRSIZE-1;
*pp++ = '\r';
{
register int c;
while(prev = last, c = mbchar(last)) switch(c)
{
case ESC:
{
int skip=0;
ep->e_crlf = 0;
*pp++ = c;
for(n=1; c = *last++; n++)
{
if(pp < ppmax)
*pp++ = c;
if(c=='\a' || c==ESC || c=='\r')
break;
if(skip || (c>='0' && c<='9'))
{
skip = 0;
continue;
}
if(n>1 && c==';')
skip = 1;
else if(n>2 || (c!= '[' && c!= ']'))
break;
}
if(c==0 || c==ESC || c=='\r')
last--;
qlen += (n+1);
break;
}
case '\b':
if(pp>ep->e_prompt+1)
pp--;
break;
case '\r':
if(pp == (ep->e_prompt+2)) /* quote char */
myquote = *(pp-1);
/*FALLTHROUGH*/
case '\n':
/* start again */
ep->e_crlf = 1;
qlen = 1;
inquote = 0;
pp = ep->e_prompt+1;
break;
case '\t':
/* expand tabs */
while((pp-ep->e_prompt)%TABSIZE)
{
if(pp >= ppmax)
break;
*pp++ = ' ';
}
break;
case '\a':
/* cut out bells */
break;
default:
if(c==myquote)
{
qlen += inquote;
inquote ^= 1;
}
if(pp < ppmax)
{
if(inquote)
qlen++;
else if(!is_print(c))
ep->e_crlf = 0;
if((qwid = last - prev) > 1)
qlen += qwid - mbwidth(c);
while(prev < last && pp < ppmax)
*pp++ = *prev++;
}
break;
}
}
if(pp-ep->e_prompt > qlen)
ep->e_plen = pp - ep->e_prompt - qlen;
*pp = 0;
if(!ep->e_multiline && (ep->e_wsize -= ep->e_plen) < 7)
{
register int shift = 7-ep->e_wsize;
ep->e_wsize = 7;
pp = ep->e_prompt+1;
strcpy(pp,pp+shift);
ep->e_plen -= shift;
last[-ep->e_plen-2] = '\r';
}
sfsync(sfstderr);
if(fd == sffileno(sfstderr))
{
/* can't use output buffer when reading from stderr */
static char *buff;
if(!buff)
buff = (char*)malloc(MAXLINE);
ep->e_outbase = ep->e_outptr = buff;
ep->e_outlast = ep->e_outptr + MAXLINE;
return;
}
qlen = sfset(sfstderr,SF_READ,0);
/* make sure SF_READ not on */
ep->e_outbase = ep->e_outptr = (char*)sfreserve(sfstderr,SF_UNBOUND,SF_LOCKR);
ep->e_outlast = ep->e_outptr + sfvalue(sfstderr);
if(qlen)
sfset(sfstderr,SF_READ,1);
sfwrite(sfstderr,ep->e_outptr,0);
ep->e_eol = reedit;
if(ep->e_multiline)
{
#ifdef _cmd_tput
char *term;
if(!ep->e_term)
ep->e_term = nv_search("TERM",shp->var_tree,0);
if(ep->e_term && (term=nv_getval(ep->e_term)) && strlen(term)<sizeof(ep->e_termname) && strcmp(term,ep->e_termname))
{
sh_trap(".sh.subscript=$(tput cuu1 2>/dev/null)",0);
if(pp=nv_getval(SH_SUBSCRNOD))
strncpy(CURSOR_UP,pp,sizeof(CURSOR_UP)-1);
nv_unset(SH_SUBSCRNOD);
strcpy(ep->e_termname,term);
}
#endif
ep->e_wsize = MAXLINE - (ep->e_plen+1);
}
if(ep->e_default && (pp = nv_getval(ep->e_default)))
{
n = strlen(pp);
if(n > LOOKAHEAD)
n = LOOKAHEAD;
ep->e_lookahead = n;
while(n-- > 0)
ep->e_lbuf[n] = *pp++;
ep->e_default = 0;
}
}
int b_enum(int argc, char** argv, Shbltin_t *context)
#endif
{
bool pflag=false, iflag=false;
int i,n;
ssize_t sz = -1;
Namval_t *np, *tp, *mp;
Namarr_t *ap;
char *cp,*sp;
struct Enum *ep;
Shell_t *shp = context->shp;
struct {
Optdisc_t opt;
Namval_t *np;
} optdisc;
cmdinit(argc, argv, context, ERROR_CATALOG, ERROR_NOTIFY);
for (;;)
{
switch (optget(argv, enum_usage))
{
case 'p':
pflag = true;
continue;
case 'i':
iflag = true;
continue;
case '?':
error(ERROR_USAGE|4, "%s", opt_info.arg);
break;
case ':':
error(2, "%s", opt_info.arg);
break;
}
break;
}
argv += opt_info.index;
if (error_info.errors)
{
error(ERROR_USAGE|2, "%s", optusage(NiL));
return 1;
}
if(!*argv)
sh_outenum(shp,sfstdout,(Namval_t*)0);
while(cp = *argv++)
{
if(!(np = nv_open(cp, shp->var_tree, NV_VARNAME|NV_NOADD)) || !(ap=nv_arrayptr(np)) || ap->fun || (sz=ap->nelem) < 2)
error(ERROR_exit(1), "%s must name an array containing at least two elements",cp);
n = stktell(shp->stk);
sfprintf(shp->stk,"%s.%s%c",NV_CLASS,np->nvname,0);
tp = nv_open(stkptr(shp->stk,n), shp->var_tree, NV_VARNAME);
if(pflag)
{
sh_outenum(shp,sfstdout,tp);
continue;
}
stkseek(shp->stk,n);
n = sz;
i = 0;
nv_onattr(tp, NV_UINT16);
nv_putval(tp, (char*)&i, NV_INTEGER);
nv_putsub(np, (char*)0, 0L, ARRAY_SCAN);
do
{
sz += strlen(nv_getval(np));
}
while(nv_nextsub(np));
sz += n*sizeof(char*);
if(!(ep = newof(0,struct Enum,1,sz)))
error(ERROR_system(1), "out of space");
mp = nv_namptr(ep->node,0);
mp->nvshell = shp;
nv_setsize(mp,10);
nv_onattr(mp, NV_UINT16);
ep->iflag = iflag;
ep->nelem = n;
cp = (char*)&ep->values[n+1];
nv_putsub(np, (char*)0, 0L, ARRAY_SCAN);
ep->values[n] = 0;
i = 0;
do
{
ep->values[i++] = cp;
sp = nv_getval(np);
n = strlen(sp);
memcpy(cp,sp,n+1);
cp += n+1;
}
while(nv_nextsub(np));
ep->hdr.dsize = sizeof(struct Enum)+sz;
ep->hdr.disc = &ENUM_disc;
ep->hdr.type = tp;
nv_onattr(tp, NV_RDONLY);
nv_disc(tp, &ep->hdr,NV_FIRST);
memset(&optdisc,0,sizeof(optdisc));
optdisc.opt.infof = enuminfo;
optdisc.np = tp;
nv_addtype(tp, enum_type, &optdisc.opt, sizeof(optdisc));
nv_onattr(np,NV_LTOU|NV_UTOL);
}
nv_open(0,shp->var_tree,0);
return error_info.errors != 0;
}
/*
* open the history file
* if HISTNAME is not given and userid==0 then no history file.
* if login_sh and HISTFILE is longer than HIST_MAX bytes then it is
* cleaned up.
* hist_open() returns 1, if history file is open
*/
int sh_histinit(void *sh_context)
{
Shell_t *shp = (Shell_t*)sh_context;
register int fd;
register History_t *hp;
register char *histname;
char *fname=0;
int histmask, maxlines, hist_start=0;
register char *cp;
register off_t hsize = 0;
if(shgd->hist_ptr=hist_ptr)
return(1);
if(!(histname = nv_getval(HISTFILE)))
{
int offset = staktell();
if(cp=nv_getval(HOME))
stakputs(cp);
stakputs(hist_fname);
stakputc(0);
stakseek(offset);
histname = stakptr(offset);
}
#ifdef future
if(hp=wasopen)
{
/* reuse history file if same name */
wasopen = 0;
shgd->hist_ptr = hist_ptr = hp;
if(strcmp(histname,hp->histname)==0)
return(1);
else
hist_free();
}
#endif
retry:
cp = path_relative(shp,histname);
if(!histinit)
histmode = S_IRUSR|S_IWUSR;
if((fd=open(cp,O_BINARY|O_APPEND|O_RDWR|O_CREAT,histmode))>=0)
{
hsize=lseek(fd,(off_t)0,SEEK_END);
}
if((unsigned)fd <=2)
{
int n;
if((n=fcntl(fd,F_DUPFD,10))>=0)
{
close(fd);
fd=n;
}
}
/* make sure that file has history file format */
if(hsize && hist_check(fd))
{
close(fd);
hsize = 0;
if(unlink(cp)>=0)
goto retry;
fd = -1;
}
if(fd < 0)
{
#if KSHELL
/* don't allow root a history_file in /tmp */
if(shgd->userid)
#endif /* KSHELL */
{
if(!(fname = pathtmp(NIL(char*),0,0,NIL(int*))))
return(0);
fd = open(fname,O_BINARY|O_APPEND|O_CREAT|O_RDWR,S_IRUSR|S_IWUSR);
}
}
if(fd<0)
return(0);
/* set the file to close-on-exec */
fcntl(fd,F_SETFD,FD_CLOEXEC);
if(cp=nv_getval(HISTSIZE))
maxlines = (unsigned)strtol(cp, (char**)0, 10);
else
maxlines = HIST_DFLT;
for(histmask=16;histmask <= maxlines; histmask <<=1 );
if(!(hp=new_of(History_t,(--histmask)*sizeof(off_t))))
{
close(fd);
return(0);
}
shgd->hist_ptr = hist_ptr = hp;
hp->histshell = (void*)shp;
hp->histsize = maxlines;
hp->histmask = histmask;
hp->histfp= sfnew(NIL(Sfio_t*),hp->histbuff,HIST_BSIZE,fd,SF_READ|SF_WRITE|SF_APPENDWR|SF_SHARE);
memset((char*)hp->histcmds,0,sizeof(off_t)*(hp->histmask+1));
hp->histind = 1;
hp->histcmds[1] = 2;
hp->histcnt = 2;
hp->histname = strdup(histname);
hp->histdisc = hist_disc;
if(hsize==0)
{
/* put special characters at front of file */
sfwrite(hp->histfp,(char*)hist_stamp,2);
sfsync(hp->histfp);
}
/* initialize history list */
else
{
int first,last;
off_t mark,size = (HIST_MAX/4)+maxlines*HIST_LINE;
hp->histind = first = hist_nearend(hp,hp->histfp,hsize-size);
histinit = 1;
hist_eof(hp); /* this sets histind to last command */
if((hist_start = (last=(int)hp->histind)-maxlines) <=0)
hist_start = 1;
mark = hp->histmarker;
while(first > hist_start)
{
size += size;
first = hist_nearend(hp,hp->histfp,hsize-size);
hp->histind = first;
}
histinit = hist_start;
hist_eof(hp);
if(!histinit)
{
sfseek(hp->histfp,hp->histcnt=hsize,SEEK_SET);
hp->histind = last;
hp->histmarker = mark;
}
histinit = 0;
}
if(fname)
{
unlink(fname);
free((void*)fname);
}
if(hist_clean(fd) && hist_start>1 && hsize > HIST_MAX)
{
#ifdef DEBUG
sfprintf(sfstderr,"%d: hist_trim hsize=%d\n",getpid(),hsize);
sfsync(sfstderr);
#endif /* DEBUG */
hp = hist_trim(hp,(int)hp->histind-maxlines);
}
sfdisc(hp->histfp,&hp->histdisc);
#if KSHELL
(HISTCUR)->nvalue.lp = (&hp->histind);
#endif /* KSHELL */
sh_timeradd(1000L*(HIST_RECENT-30), 1, hist_touch, (void*)hp->histname);
#if SHOPT_ACCTFILE
if(sh_isstate(SH_INTERACTIVE))
acctinit(hp);
#endif /* SHOPT_ACCTFILE */
#if SHOPT_AUDIT
{
char buff[SF_BUFSIZE];
hp->auditfp = 0;
if(sh_isstate(SH_INTERACTIVE) && (hp->auditmask=sh_checkaudit(hp,SHOPT_AUDITFILE, buff, sizeof(buff))))
{
if((fd=sh_open(buff,O_BINARY|O_WRONLY|O_APPEND|O_CREAT,S_IRUSR|S_IWUSR))>=0 && fd < 10)
{
int n;
if((n = sh_fcntl(fd,F_DUPFD, 10)) >= 0)
{
sh_close(fd);
fd = n;
}
}
if(fd>=0)
{
fcntl(fd,F_SETFD,FD_CLOEXEC);
hp->tty = strdup(ttyname(2));
hp->auditfp = sfnew((Sfio_t*)0,NULL,-1,fd,SF_WRITE);
}
}
}
#endif
return(1);
}
static int whence(Shell_t *shp,char **argv, register int flags)
{
register const char *name;
register Namval_t *np;
register const char *cp;
register int aflag,r=0;
register const char *msg;
int tofree;
Dt_t *root;
Namval_t *nq;
char *notused;
Pathcomp_t *pp=0;
int notrack = 1;
if(flags&Q_FLAG)
flags &= ~A_FLAG;
while(name= *argv++)
{
tofree=0;
aflag = ((flags&A_FLAG)!=0);
cp = 0;
np = 0;
if(flags&P_FLAG)
goto search;
if(flags&Q_FLAG)
goto bltins;
/* reserved words first */
if(sh_lookup(name,shtab_reserved))
{
sfprintf(sfstdout,"%s%s\n",name,(flags&V_FLAG)?sh_translate(is_reserved):"");
if(!aflag)
continue;
aflag++;
}
/* non-tracked aliases */
if((np=nv_search(name,shp->alias_tree,0))
&& !nv_isnull(np) && !(notrack=nv_isattr(np,NV_TAGGED))
&& (cp=nv_getval(np)))
{
if(flags&V_FLAG)
{
if(nv_isattr(np,NV_EXPORT))
msg = sh_translate(is_xalias);
else
msg = sh_translate(is_alias);
sfprintf(sfstdout,msg,name);
}
sfputr(sfstdout,sh_fmtq(cp),'\n');
if(!aflag)
continue;
cp = 0;
aflag++;
}
/* built-ins and functions next */
bltins:
root = (flags&F_FLAG)?shp->bltin_tree:shp->fun_tree;
if(np= nv_bfsearch(name, root, &nq, ¬used))
{
if(is_abuiltin(np) && nv_isnull(np))
goto search;
cp = "";
if(flags&V_FLAG)
{
if(nv_isnull(np))
cp = sh_translate(is_ufunction);
else if(is_abuiltin(np))
{
if(nv_isattr(np,BLT_SPC))
cp = sh_translate(is_spcbuiltin);
else
cp = sh_translate(is_builtin);
}
else
cp = sh_translate(is_function);
}
if(flags&Q_FLAG)
continue;
sfprintf(sfstdout,"%s%s\n",name,cp);
if(!aflag)
continue;
cp = 0;
aflag++;
}
search:
if(sh_isstate(SH_DEFPATH))
{
cp=0;
notrack=1;
}
do
{
if(path_search(shp,name,&pp,2+(aflag>1)))
{
cp = name;
if((flags&P_FLAG) && *cp!='/')
cp = 0;
}
else
{
cp = stakptr(PATH_OFFSET);
if(*cp==0)
cp = 0;
else if(*cp!='/')
{
cp = path_fullname(shp,cp);
tofree=1;
}
}
if(flags&Q_FLAG)
{
pp = 0;
r |= !cp;
}
else if(cp)
{
if(flags&V_FLAG)
{
if(*cp!= '/')
{
if(!np && (np=nv_search(name,shp->track_tree,0)))
sfprintf(sfstdout,"%s %s %s/%s\n",name,sh_translate(is_talias),path_pwd(shp,0),cp);
else if(!np || nv_isnull(np))
sfprintf(sfstdout,"%s%s\n",name,sh_translate(is_ufunction));
continue;
}
sfputr(sfstdout,sh_fmtq(name),' ');
/* built-in version of program */
if(*cp=='/' && (np=nv_search(cp,shp->bltin_tree,0)))
msg = sh_translate(is_builtver);
/* tracked aliases next */
else if(aflag>1 || !notrack || strchr(name,'/'))
msg = sh_translate("is");
else
msg = sh_translate(is_talias);
sfputr(sfstdout,msg,' ');
}
sfputr(sfstdout,sh_fmtq(cp),'\n');
if(aflag)
{
if(aflag<=1)
aflag++;
if (pp)
pp = pp->next;
}
else
pp = 0;
if(tofree)
{
free((char*)cp);
tofree = 0;
}
}
else if(aflag<=1)
{
r |= 1;
if(flags&V_FLAG)
errormsg(SH_DICT,ERROR_exit(0),e_found,sh_fmtq(name));
}
} while(pp);
}
return(r);
}
int hist_expand(const char *ln, char **xp)
{
int off, /* stack offset */
q, /* quotation flags */
p, /* flag */
c, /* current char */
flag=0; /* HIST_* flags */
Sfoff_t n, /* history line number, counter, etc. */
i, /* counter */
w[2]; /* word range */
char *sp, /* stack pointer */
*cp, /* current char in ln */
*str, /* search string */
*evp, /* event/word designator string, for error msgs */
*cc=0, /* copy of current line up to cp; temp ptr */
hc[3], /* default histchars */
*qc="\'\"`"; /* quote characters */
Sfio_t *ref=0, /* line referenced by event designator */
*tmp=0, /* temporary line buffer */
*tmp2=0;/* temporary line buffer */
Histloc_t hl; /* history location */
static Namval_t *np = 0; /* histchars variable */
static struct subst sb = {0,0}; /* substition strings */
static Sfio_t *wm=0; /* word match from !?string? event designator */
if(!wm)
wm = sfopen(NULL, NULL, "swr");
hc[0] = '!';
hc[1] = '^';
hc[2] = 0;
if((np = nv_open("histchars",sh.var_tree,0)) && (cp = nv_getval(np)))
{
if(cp[0])
{
hc[0] = cp[0];
if(cp[1])
{
hc[1] = cp[1];
if(cp[2])
hc[2] = cp[2];
}
}
}
/* save shell stack */
if(off = staktell())
sp = stakfreeze(0);
cp = (char*)ln;
while(cp && *cp)
{
/* read until event/quick substitution/comment designator */
if((*cp != hc[0] && *cp != hc[1] && *cp != hc[2])
|| (*cp == hc[1] && cp != ln))
{
if(*cp == '\\') /* skip escaped designators */
stakputc(*cp++);
else if(*cp == '\'') /* skip quoted designators */
{
do
stakputc(*cp);
while(*++cp && *cp != '\'');
}
stakputc(*cp++);
continue;
}
if(hc[2] && *cp == hc[2]) /* history comment designator, skip rest of line */
{
stakputc(*cp++);
stakputs(cp);
DONE();
}
n = -1;
str = 0;
flag &= HIST_EVENT; /* save event flag for returning later */
evp = cp;
ref = 0;
if(*cp == hc[1]) /* shortcut substitution */
{
flag |= HIST_QUICKSUBST;
goto getline;
}
if(*cp == hc[0] && *(cp+1) == hc[0]) /* refer to line -1 */
{
cp += 2;
goto getline;
}
switch(c = *++cp) {
case ' ':
case '\t':
case '\n':
case '\0':
case '=':
case '(':
stakputc(hc[0]);
continue;
case '#': /* the line up to current position */
flag |= HIST_HASH;
cp++;
n = staktell(); /* terminate string and dup */
stakputc('\0');
cc = strdup(stakptr(0));
stakseek(n); /* remove null byte again */
ref = sfopen(ref, cc, "s"); /* open as file */
n = 0; /* skip history file referencing */
break;
case '-': /* back reference by number */
if(!isdigit(*(cp+1)))
goto string_event;
cp++;
case '0': /* reference by number */
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
n = 0;
while(isdigit(*cp))
n = n * 10 + (*cp++) - '0';
if(c == '-')
n = -n;
break;
case '$':
n = -1;
case ':':
break;
case '?':
cp++;
flag |= HIST_QUESTION;
string_event:
default:
/* read until end of string or word designator/modifier */
str = cp;
while(*cp)
{
cp++;
if((!(flag&HIST_QUESTION) &&
(*cp == ':' || isspace(*cp)
|| *cp == '^' || *cp == '$'
|| *cp == '*' || *cp == '-'
|| *cp == '%')
)
|| ((flag&HIST_QUESTION) && (*cp == '?' || *cp == '\n')))
{
c = *cp;
*cp = '\0';
}
}
break;
}
getline:
flag |= HIST_EVENT;
if(str) /* !string or !?string? event designator */
{
/* search history for string */
hl = hist_find(shgd->hist_ptr, str,
shgd->hist_ptr->histind,
flag&HIST_QUESTION, -1);
if((n = hl.hist_command) == -1)
n = 0; /* not found */
}
if(n)
{
if(n < 0) /* determine index for backref */
n = shgd->hist_ptr->histind + n;
/* search and use history file if found */
if(n > 0 && hist_seek(shgd->hist_ptr, n) != -1)
ref = shgd->hist_ptr->histfp;
}
if(!ref)
{
/* string not found or command # out of range */
c = *cp;
*cp = '\0';
errormsg(SH_DICT, ERROR_ERROR, "%s: event not found", evp);
*cp = c;
DONE();
}
if(str) /* string search: restore orig. line */
{
if(flag&HIST_QUESTION)
*cp++ = c; /* skip second question mark */
else
*cp = c;
}
/* colon introduces either word designators or modifiers */
if(*(evp = cp) == ':')
cp++;
w[0] = 0; /* -1 means last word, -2 means match from !?string? */
w[1] = -1; /* -1 means last word, -2 means suppress last word */
if(flag & HIST_QUICKSUBST) /* shortcut substitution */
goto getsel;
n = 0;
while(n < 2)
{
switch(c = *cp++) {
case '^': /* first word */
if(n == 0)
{
w[0] = w[1] = 1;
goto skip;
}
else
goto skip2;
case '$': /* last word */
w[n] = -1;
goto skip;
case '%': /* match from !?string? event designator */
if(n == 0)
{
if(!str)
{
w[0] = 0;
w[1] = -1;
ref = wm;
}
else
{
w[0] = -2;
w[1] = sftell(ref) + hl.hist_char;
}
sfseek(wm, 0, SEEK_SET);
goto skip;
}
default:
skip2:
cp--;
n = 2;
break;
case '*': /* until last word */
if(n == 0)
w[0] = 1;
w[1] = -1;
skip:
flag |= HIST_WORDDSGN;
n = 2;
break;
case '-': /* until last word or specified index */
w[1] = -2;
flag |= HIST_WORDDSGN;
n = 1;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': /* specify index */
if((*evp == ':') || w[1] == -2)
{
w[n] = c - '0';
while(isdigit(c=*cp++))
w[n] = w[n] * 10 + c - '0';
flag |= HIST_WORDDSGN;
if(n == 0)
w[1] = w[0];
n++;
}
else
n = 2;
cp--;
break;
}
}
if(w[0] != -2 && w[1] > 0 && w[0] > w[1])
{
c = *cp;
*cp = '\0';
errormsg(SH_DICT, ERROR_ERROR, "%s: bad word specifier", evp);
*cp = c;
DONE();
}
/* no valid word designator after colon, rewind */
if(!(flag & HIST_WORDDSGN) && (*evp == ':'))
cp = evp;
getsel:
/* open temp buffer, let sfio do the (re)allocation */
tmp = sfopen(NULL, NULL, "swr");
/* push selected words into buffer, squash
whitespace into single blank or a newline */
n = i = q = 0;
while((c = sfgetc(ref)) > 0)
{
if(isspace(c))
{
flag |= (c == '\n' ? HIST_NEWLINE : 0);
continue;
}
if(n >= w[0] && ((w[0] != -2) ? (w[1] < 0 || n <= w[1]) : 1))
{
if(w[0] < 0)
sfseek(tmp, 0, SEEK_SET);
else
i = sftell(tmp);
if(i > 0)
sfputc(tmp, flag & HIST_NEWLINE ? '\n' : ' ');
flag &= ~HIST_NEWLINE;
p = 1;
}
else
p = 0;
do
{
cc = strchr(qc, c);
q ^= cc ? 1<<(int)(cc - qc) : 0;
if(p)
sfputc(tmp, c);
}
while((c = sfgetc(ref)) > 0 && (!isspace(c) || q));
if(w[0] == -2 && sftell(ref) > w[1])
break;
flag |= (c == '\n' ? HIST_NEWLINE : 0);
n++;
}
if(w[0] != -2 && w[1] >= 0 && w[1] >= n)
{
c = *cp;
*cp = '\0';
errormsg(SH_DICT, ERROR_ERROR, "%s: bad word specifier", evp);
*cp = c;
DONE();
}
else if(w[1] == -2) /* skip last word */
sfseek(tmp, i, SEEK_SET);
/* remove trailing newline */
if(sftell(tmp))
{
sfseek(tmp, -1, SEEK_CUR);
if(sfgetc(tmp) == '\n')
sfungetc(tmp, '\n');
}
sfputc(tmp, '\0');
if(str)
{
if(wm)
sfclose(wm);
wm = tmp;
}
if(cc && (flag&HIST_HASH))
{
/* close !# temp file */
sfclose(ref);
flag &= ~HIST_HASH;
free(cc);
cc = 0;
}
evp = cp;
/* selected line/words are now in buffer, now go for the modifiers */
while(*cp == ':' || (flag & HIST_QUICKSUBST))
{
if(flag & HIST_QUICKSUBST)
{
flag &= ~HIST_QUICKSUBST;
c = 's';
cp--;
}
else
c = *++cp;
sfseek(tmp, 0, SEEK_SET);
tmp2 = sfopen(tmp2, NULL, "swr");
if(c == 'g') /* global substitution */
{
flag |= HIST_GLOBALSUBST;
c = *++cp;
}
if(cc = strchr(modifiers, c))
flag |= mod_flags[cc - modifiers];
else
{
errormsg(SH_DICT, ERROR_ERROR, "%c: unrecognized history modifier", c);
DONE();
}
if(c == 'h' || c == 'r') /* head or base */
{
n = -1;
while((c = sfgetc(tmp)) > 0)
{ /* remember position of / or . */
if((c == '/' && *cp == 'h') || (c == '.' && *cp == 'r'))
n = sftell(tmp2);
sfputc(tmp2, c);
}
if(n > 0)
{ /* rewind to last / or . */
sfseek(tmp2, n, SEEK_SET);
/* end string there */
sfputc(tmp2, '\0');
}
}
else if(c == 't' || c == 'e') /* tail or suffix */
{
n = 0;
while((c = sfgetc(tmp)) > 0)
{ /* remember position of / or . */
if((c == '/' && *cp == 't') || (c == '.' && *cp == 'e'))
n = sftell(tmp);
}
/* rewind to last / or . */
sfseek(tmp, n, SEEK_SET);
/* copy from there on */
while((c = sfgetc(tmp)) > 0)
sfputc(tmp2, c);
}
else if(c == 's' || c == '&')
{
cp++;
if(c == 's')
{
/* preset old with match from !?string? */
if(!sb.str[0] && wm)
sb.str[0] = strdup(sfsetbuf(wm, (Void_t*)1, 0));
cp = parse_subst(cp, &sb);
}
if(!sb.str[0] || !sb.str[1])
{
c = *cp;
*cp = '\0';
errormsg(SH_DICT, ERROR_ERROR,
"%s%s: no previous substitution",
(flag & HIST_QUICKSUBST) ? ":s" : "",
evp);
*cp = c;
DONE();
}
/* need pointer for strstr() */
str = sfsetbuf(tmp, (Void_t*)1, 0);
flag |= HIST_SUBSTITUTE;
while(flag & HIST_SUBSTITUTE)
{
/* find string */
if(cc = strstr(str, sb.str[0]))
{ /* replace it */
c = *cc;
*cc = '\0';
sfputr(tmp2, str, -1);
sfputr(tmp2, sb.str[1], -1);
*cc = c;
str = cc + strlen(sb.str[0]);
}
else if(!sftell(tmp2))
{ /* not successfull */
c = *cp;
*cp = '\0';
errormsg(SH_DICT, ERROR_ERROR,
"%s%s: substitution failed",
(flag & HIST_QUICKSUBST) ? ":s" : "",
evp);
*cp = c;
DONE();
}
/* loop if g modifier specified */
if(!cc || !(flag & HIST_GLOBALSUBST))
flag &= ~HIST_SUBSTITUTE;
}
/* output rest of line */
sfputr(tmp2, str, -1);
if(*cp)
cp--;
}
if(sftell(tmp2))
{ /* if any substitions done, swap buffers */
if(wm != tmp)
sfclose(tmp);
tmp = tmp2;
tmp2 = 0;
}
cc = 0;
if(*cp)
cp++;
}
/* flush temporary buffer to stack */
if(tmp)
{
sfseek(tmp, 0, SEEK_SET);
if(flag & HIST_QUOTE)
stakputc('\'');
while((c = sfgetc(tmp)) > 0)
{
if(isspace(c))
{
flag = flag & ~HIST_NEWLINE;
/* squash white space to either a
blank or a newline */
do
flag |= (c == '\n' ? HIST_NEWLINE : 0);
while((c = sfgetc(tmp)) > 0 && isspace(c));
sfungetc(tmp, c);
c = (flag & HIST_NEWLINE) ? '\n' : ' ';
if(flag & HIST_QUOTE_BR)
{
stakputc('\'');
stakputc(c);
stakputc('\'');
}
else
stakputc(c);
}
else if((c == '\'') && (flag & HIST_QUOTE))
{
stakputc('\'');
stakputc('\\');
stakputc(c);
stakputc('\'');
}
else
stakputc(c);
}
if(flag & HIST_QUOTE)
stakputc('\'');
}
}
stakputc('\0');
done:
if(cc && (flag&HIST_HASH))
{
/* close !# temp file */
sfclose(ref);
free(cc);
cc = 0;
}
/* error? */
if(staktell() && !(flag & HIST_ERROR))
*xp = strdup(stakfreeze(1));
/* restore shell stack */
if(off)
stakset(sp,off);
else
stakseek(0);
/* drop temporary files */
if(tmp && tmp != wm)
sfclose(tmp);
if(tmp2)
sfclose(tmp2);
return (flag & HIST_ERROR ? HIST_ERROR : flag & HIST_FLAG_RETURN_MASK);
}
int b_hist(int argc,char *argv[], void *extra)
{
register History_t *hp;
register char *arg;
register int flag,fdo;
register Shell_t *shp = ((Shbltin_t*)extra)->shp;
Sfio_t *outfile;
char *fname;
int range[2], incr, index2, indx= -1;
char *edit = 0; /* name of editor */
char *replace = 0; /* replace old=new */
int lflag = 0, nflag = 0, rflag = 0;
#if SHOPT_HISTEXPAND
int pflag = 0;
#endif
Histloc_t location;
NOT_USED(argc);
if(!sh_histinit((void*)shp))
errormsg(SH_DICT,ERROR_system(1),e_histopen);
hp = shp->gd->hist_ptr;
while((flag = optget(argv,sh_opthist))) switch(flag)
{
case 'e':
edit = opt_info.arg;
break;
case 'n':
nflag++;
break;
case 'l':
lflag++;
break;
case 'r':
rflag++;
break;
case 's':
edit = "-";
break;
#if SHOPT_HISTEXPAND
case 'p':
pflag++;
break;
#endif
case 'N':
if(indx<=0)
{
if((flag = hist_max(hp) - opt_info.num-1) < 0)
flag = 1;
range[++indx] = flag;
break;
}
case ':':
errormsg(SH_DICT,2, "%s", opt_info.arg);
break;
case '?':
errormsg(SH_DICT,ERROR_usage(2), "%s", opt_info.arg);
break;
}
if(error_info.errors)
errormsg(SH_DICT,ERROR_usage(2),"%s",optusage((char*)0));
argv += (opt_info.index-1);
#if SHOPT_HISTEXPAND
if(pflag)
{
hist_cancel(hp);
pflag = 0;
while(arg=argv[1])
{
flag = hist_expand(arg,&replace);
if(!(flag & HIST_ERROR))
sfputr(sfstdout, replace, '\n');
else
pflag = 1;
if(replace)
free(replace);
argv++;
}
return pflag;
}
#endif
flag = indx;
while(flag<1 && (arg=argv[1]))
{
/* look for old=new argument */
if(!replace && strchr(arg+1,'='))
{
replace = arg;
argv++;
continue;
}
else if(isdigit(*arg) || *arg == '-')
{
/* see if completely numeric */
do arg++;
while(isdigit(*arg));
if(*arg==0)
{
arg = argv[1];
range[++flag] = (int)strtol(arg, (char**)0, 10);
if(*arg == '-')
range[flag] += (hist_max(hp)-1);
argv++;
continue;
}
}
/* search for last line starting with string */
location = hist_find(hp,argv[1],hist_max(hp)-1,0,-1);
if((range[++flag] = location.hist_command) < 0)
errormsg(SH_DICT,ERROR_exit(1),e_found,argv[1]);
argv++;
}
if(flag <0)
{
/* set default starting range */
if(lflag)
{
flag = hist_max(hp)-16;
if(flag<1)
flag = 1;
}
else
flag = hist_max(hp)-2;
range[0] = flag;
flag = 0;
}
index2 = hist_min(hp);
if(range[0]<index2)
range[0] = index2;
if(flag==0)
/* set default termination range */
range[1] = ((lflag && !edit)?hist_max(hp)-1:range[0]);
if(range[1]>=(flag=(hist_max(hp) - !lflag)))
range[1] = flag;
/* check for valid ranges */
if(range[1]<index2 || range[0]>=flag)
errormsg(SH_DICT,ERROR_exit(1),e_badrange,range[0],range[1]);
if(edit && *edit=='-' && range[0]!=range[1])
errormsg(SH_DICT,ERROR_exit(1),e_eneedsarg);
/* now list commands from range[rflag] to range[1-rflag] */
incr = 1;
flag = rflag>0;
if(range[1-flag] < range[flag])
incr = -1;
if(lflag)
{
outfile = sfstdout;
arg = "\n\t";
}
else
{
if(!(fname=pathtmp(NIL(char*),0,0,NIL(int*))))
errormsg(SH_DICT,ERROR_exit(1),e_create,"");
if((fdo=open(fname,O_CREAT|O_RDWR,S_IRUSR|S_IWUSR)) < 0)
errormsg(SH_DICT,ERROR_system(1),e_create,fname);
outfile= sfnew(NIL(Sfio_t*),shp->outbuff,IOBSIZE,fdo,SF_WRITE);
arg = "\n";
nflag++;
}
while(1)
{
if(nflag==0)
sfprintf(outfile,"%d\t",range[flag]);
else if(lflag)
sfputc(outfile,'\t');
hist_list(shp->gd->hist_ptr,outfile,hist_tell(shp->gd->hist_ptr,range[flag]),0,arg);
if(lflag)
sh_sigcheck(shp);
if(range[flag] == range[1-flag])
break;
range[flag] += incr;
}
if(lflag)
return(0);
sfclose(outfile);
hist_eof(hp);
arg = edit;
if(!arg && !(arg=nv_getval(sh_scoped(shp,HISTEDIT))) && !(arg=nv_getval(sh_scoped(shp,FCEDNOD))))
arg = (char*)e_defedit;
#ifdef apollo
/*
* Code to support the FC using the pad editor.
* Exampled of how to use: HISTEDIT=pad
*/
if (strcmp (arg, "pad") == 0)
{
extern int pad_create(char*);
sh_close(fdo);
fdo = pad_create(fname);
pad_wait(fdo);
unlink(fname);
strcat(fname, ".bak");
unlink(fname);
lseek(fdo,(off_t)0,SEEK_SET);
}
else
{
#endif /* apollo */
if(*arg != '-')
{
char *com[3];
com[0] = arg;
com[1] = fname;
com[2] = 0;
error_info.errors = sh_eval(sh_sfeval(com),0);
}
fdo = sh_chkopen(fname);
unlink(fname);
free((void*)fname);
#ifdef apollo
}
#endif /* apollo */
/* don't history fc itself unless forked */
error_info.flags |= ERROR_SILENT;
if(!sh_isstate(SH_FORKED))
hist_cancel(hp);
sh_onstate(SH_HISTORY);
sh_onstate(SH_VERBOSE); /* echo lines as read */
if(replace)
hist_subst(error_info.id,fdo,replace);
else if(error_info.errors == 0)
{
char buff[IOBSIZE+1];
Sfio_t *iop = sfnew(NIL(Sfio_t*),buff,IOBSIZE,fdo,SF_READ);
/* read in and run the command */
if(shp->hist_depth++ > HIST_RECURSE)
errormsg(SH_DICT,ERROR_exit(1),e_toodeep,"history");
sh_eval(iop,1);
shp->hist_depth--;
}
static void genvalue(Sfio_t *out, Shclass_t *sp, int indent, Namval_t *npar)
{
Shfield_t *fp = sp->fields;
Namval_t *np, **nodes= (Namval_t**)(sp+1);
register int i,isarray;
if(out)
{
sfwrite(out,"(\n",2);
indent++;
}
for(i=0; i < sp->nelem; i++,fp++)
{
#if 0
/* handle recursive case */
#endif
if(!(np=nodes[i]) && out)
np = sh_newnode(fp,npar);
if(np)
{
isarray=0;
if(nv_isattr(np,NV_ARRAY))
{
isarray=1;
if(array_elem(nv_arrayptr(np))==0)
isarray=2;
else
nv_putsub(np,(char*)0,ARRAY_SCAN);
}
sfnputc(out,'\t',indent);
sfputr(out,fp->name,(isarray==2?'\n':'='));
if(isarray)
{
if(isarray==2)
continue;
sfwrite(out,"(\n",2);
sfnputc(out,'\t',++indent);
}
while(1)
{
char *fmtq;
if(isarray)
{
sfprintf(out,"[%s]",sh_fmtq(nv_getsub(np)));
sfputc(out,'=');
}
if(!(fmtq=nv_getval(np)) || !(fmtq=sh_fmtq(fmtq)))
fmtq = "";
sfputr(out,fmtq,'\n');
if(!nv_nextsub(np))
break;
sfnputc(out,'\t',indent);
}
if(isarray)
{
sfnputc(out,'\t',--indent);
sfwrite(out,")\n",2);
}
}
}
if(out)
{
if(indent>1)
sfnputc(out,'\t',indent-1);
sfputc(out,')');
}
}
int sh_main(int ac, char *av[], Shinit_f userinit)
{
register char *name;
register int fdin;
register Sfio_t *iop;
register Shell_t *shp;
struct stat statb;
int i, rshflag; /* set for restricted shell */
char *command;
free(malloc(64*1024));
#ifdef _lib_sigvec
/* This is to clear mask that may be left on by rlogin */
clearsigmask(SIGALRM);
clearsigmask(SIGHUP);
clearsigmask(SIGCHLD);
#endif /* _lib_sigvec */
#ifdef _hdr_nc
_NutConf(_NC_SET_SUFFIXED_SEARCHING, 1);
#endif /* _hdr_nc */
fixargs(av,0);
shp = sh_init(ac,av,userinit);
time(&mailtime);
if(rshflag=sh_isoption(SH_RESTRICTED))
sh_offoption(SH_RESTRICTED);
if(sigsetjmp(*((sigjmp_buf*)shp->jmpbuffer),0))
{
/* begin script execution here */
sh_reinit((char**)0);
shp->gd->pid = getpid();
shp->gd->ppid = getppid();
}
shp->fn_depth = shp->dot_depth = 0;
command = error_info.id;
/* set pidname '$$' */
srand(shp->gd->pid&0x7fff);
if(nv_isnull(PS4NOD))
nv_putval(PS4NOD,e_traceprompt,NV_RDONLY);
path_pwd(shp,1);
iop = (Sfio_t*)0;
#if SHOPT_BRACEPAT
sh_onoption(SH_BRACEEXPAND);
#endif
if((beenhere++)==0)
{
sh_onstate(SH_PROFILE);
((Lex_t*)shp->lex_context)->nonstandard = 0;
if(shp->gd->ppid==1)
shp->login_sh++;
if(shp->login_sh >= 2)
sh_onoption(SH_LOGIN_SHELL);
/* decide whether shell is interactive */
if(!sh_isoption(SH_INTERACTIVE) && !sh_isoption(SH_TFLAG) && !sh_isoption(SH_CFLAG) &&
sh_isoption(SH_SFLAG) && tty_check(0) && tty_check(ERRIO))
sh_onoption(SH_INTERACTIVE);
if(sh_isoption(SH_INTERACTIVE))
{
sh_onoption(SH_BGNICE);
sh_onoption(SH_RC);
}
if(!sh_isoption(SH_RC) && (sh_isoption(SH_BASH) && !sh_isoption(SH_POSIX)
#if SHOPT_REMOTE
|| !fstat(0, &statb) && REMOTE(statb.st_mode)
#endif
))
sh_onoption(SH_RC);
for(i=0; i<elementsof(shp->offoptions.v); i++)
shp->options.v[i] &= ~shp->offoptions.v[i];
if(sh_isoption(SH_INTERACTIVE))
{
#ifdef SIGXCPU
signal(SIGXCPU,SIG_DFL);
#endif /* SIGXCPU */
#ifdef SIGXFSZ
signal(SIGXFSZ,SIG_DFL);
#endif /* SIGXFSZ */
sh_onoption(SH_MONITOR);
}
job_init(shp,sh_isoption(SH_LOGIN_SHELL));
if(sh_isoption(SH_LOGIN_SHELL))
{
/* system profile */
sh_source(shp, iop, e_sysprofile);
if(!sh_isoption(SH_NOUSRPROFILE) && !sh_isoption(SH_PRIVILEGED))
{
char **files = shp->gd->login_files;
while ((name = *files++) && !sh_source(shp, iop, sh_mactry(shp,name)));
}
}
/* make sure PWD is set up correctly */
path_pwd(shp,1);
if(!sh_isoption(SH_NOEXEC))
{
if(!sh_isoption(SH_NOUSRPROFILE) && !sh_isoption(SH_PRIVILEGED) && sh_isoption(SH_RC))
{
#if SHOPT_BASH
if(sh_isoption(SH_BASH) && !sh_isoption(SH_POSIX))
{
#if SHOPT_SYSRC
sh_source(shp, iop, e_bash_sysrc);
#endif
sh_source(shp, iop, shp->gd->rcfile ? shp->gd->rcfile : sh_mactry(shp,(char*)e_bash_rc));
}
else
#endif
{
if(name = sh_mactry(shp,nv_getval(ENVNOD)))
name = *name ? strdup(name) : (char*)0;
#if SHOPT_SYSRC
if(!strmatch(name, "?(.)/./*"))
sh_source(shp, iop, e_sysrc);
#endif
if(name)
{
sh_source(shp, iop, name);
free(name);
}
}
}
else if(sh_isoption(SH_INTERACTIVE) && sh_isoption(SH_PRIVILEGED))
sh_source(shp, iop, e_suidprofile);
}
shp->st.cmdname = error_info.id = command;
sh_offstate(SH_PROFILE);
if(rshflag)
sh_onoption(SH_RESTRICTED);
/* open input file if specified */
if(shp->comdiv)
{
shell_c:
iop = sfnew(NIL(Sfio_t*),shp->comdiv,strlen(shp->comdiv),0,SF_STRING|SF_READ);
}
int b_enum(int argc, char **argv, Shbltin_t *context) {
bool pflag = false, iflag = false;
int i, n;
ssize_t sz = -1;
Namval_t *np, *tp, *mp;
Namarr_t *ap;
char *cp;
const char *sp;
struct Enum *ep;
Shell_t *shp = context->shp;
struct {
Optdisc_t opt;
Namval_t *np;
} optdisc;
if (cmdinit(argc, argv, context, ERROR_NOTIFY)) return -1;
while ((n = optget(argv, enum_usage))) {
switch (n) {
case 'p': {
pflag = true;
break;
}
case 'i': {
iflag = true;
break;
}
case ':': {
errormsg(SH_DICT, 2, "%s", opt_info.arg);
break;
}
case '?': {
errormsg(SH_DICT, ERROR_usage(2), "%s", opt_info.arg);
__builtin_unreachable();
}
default: { break; }
}
}
argv += opt_info.index;
argc -= opt_info.index;
if (error_info.errors || argc != 1) {
error(ERROR_USAGE | 2, "%s", optusage(NULL));
return 1;
}
while ((cp = *argv++)) {
np = nv_open(cp, shp->var_tree, NV_VARNAME | NV_NOADD);
if (!np || !(ap = nv_arrayptr(np)) || ap->fun || ap->nelem < 2) {
error(ERROR_exit(1), "%s must name an array containing at least two elements", cp);
}
n = stktell(shp->stk);
sfprintf(shp->stk, "%s.%s%c", NV_CLASS, np->nvname, 0);
tp = nv_open(stkptr(shp->stk, n), shp->var_tree, NV_VARNAME);
if (pflag) {
sh_outenum(shp, sfstdout, tp);
continue;
}
stkseek(shp->stk, n);
n = ap->nelem;
i = 0;
nv_onattr(tp, NV_UINT16);
nv_putval(tp, (char *)&i, NV_INTEGER);
nv_putsub(np, NULL, 0L, ARRAY_SCAN);
do {
sz += strlen(nv_getval(np));
} while (nv_nextsub(np));
ep = calloc(1, sizeof(struct Enum));
if (!ep) {
error(ERROR_system(1), "out of space");
__builtin_unreachable();
}
ep->nelem = n;
mp = nv_namptr(ep->node, 0);
mp->nvshell = shp;
nv_setsize(mp, 10);
nv_onattr(mp, NV_UINT16);
ep->iflag = iflag;
ep->values = malloc(n * sizeof(*ep->values));
nv_putsub(np, NULL, 0L, ARRAY_SCAN);
i = 0;
do {
sp = nv_getval(np);
ep->values[i++] = strdup(sp);
} while (nv_nextsub(np));
assert(n == i);
ep->namfun.dsize = sizeof(struct Enum);
ep->namfun.disc = &ENUM_disc;
ep->namfun.type = tp;
nv_onattr(tp, NV_RDONLY);
nv_disc(tp, &ep->namfun, DISC_OP_FIRST);
memset(&optdisc, 0, sizeof(optdisc));
optdisc.opt.infof = enuminfo;
optdisc.np = tp;
nv_addtype(tp, enum_type, &optdisc, sizeof(optdisc));
nv_onattr(np, NV_LTOU | NV_UTOL);
}
nv_open(0, shp->var_tree, 0);
return error_info.errors != 0;
}
//
// Open the history file. If HISTNAME is not given and userid==0 then no history file. If login_sh
// and HISTFILE is longer than HIST_MAX bytes then it is cleaned up.
//
// hist_open() returns 1, if history file is opened.
//
int sh_histinit(void *sh_context) {
Shell_t *shp = sh_context;
int fd;
History_t *hp;
char *histname;
char *fname = NULL;
int histmask, maxlines, hist_start = 0;
char *cp;
off_t hsize = 0;
shgd->hist_ptr = hist_ptr;
if (shgd->hist_ptr) return 1;
if (!(histname = nv_getval(HISTFILE))) {
int offset = stktell(shp->stk);
cp = nv_getval(HOME);
if (cp) sfputr(shp->stk, cp, -1);
sfputr(shp->stk, hist_fname, 0);
stkseek(shp->stk, offset);
histname = stkptr(shp->stk, offset);
}
#if 0
// TODO: Figure out if this should be enabled. Originally excluded via `#ifdef future`.
if (hp = wasopen) {
// Reuse history file if same name.
wasopen = 0;
shgd->hist_ptr = hist_ptr = hp;
if (strcmp(histname, hp->histname) == 0) {
return 1;
} else {
hist_free();
}
}
#endif // future
retry:
cp = path_relative(shp, histname);
if (!histinit) histmode = S_IRUSR | S_IWUSR;
if ((fd = open(cp, O_BINARY | O_APPEND | O_RDWR | O_CREAT | O_CLOEXEC, histmode)) >= 0) {
hsize = lseek(fd, (off_t)0, SEEK_END);
}
if ((unsigned)fd < 10) {
int n;
if ((n = sh_fcntl(fd, F_DUPFD_CLOEXEC, 10)) >= 0) {
sh_close(fd);
fd = n;
}
}
// Make sure that file has history file format.
if (hsize && hist_check(fd)) {
sh_close(fd);
hsize = 0;
if (unlink(cp) >= 0) goto retry;
fd = -1;
}
// Don't allow root a history_file in /tmp.
if (fd < 0 && shgd->userid) {
fname = ast_temp_file(NULL, NULL, &fd, O_APPEND | O_CLOEXEC);
if (!fname) return 0;
}
if (fd < 0) return 0;
// Set the file to close-on-exec.
(void)fcntl(fd, F_SETFD, FD_CLOEXEC);
cp = nv_getval(HISTSIZE);
if (cp) {
maxlines = (unsigned)strtol(cp, NULL, 10);
} else {
maxlines = HIST_DFLT;
}
for (histmask = 16; histmask <= maxlines; histmask <<= 1) {
; // empty loop
}
histmask -= 1;
hp = calloc(1, sizeof(History_t) + histmask * sizeof(off_t));
if (!hp) {
sh_close(fd);
return 0;
}
shgd->hist_ptr = hist_ptr = hp;
hp->histshell = shp;
hp->histsize = maxlines;
hp->histmask = histmask;
hp->histfp = sfnew(NULL, NULL, HIST_BSIZE, fd, SF_READ | SF_WRITE | SF_APPENDWR | SF_SHARE);
hp->histind = 1;
hp->histcmds[1] = 2;
hp->histcnt = 2;
hp->histname = strdup(histname);
hp->histdisc = hist_disc;
if (hsize == 0) {
// Put special characters at front of file.
sfwrite(hp->histfp, (char *)hist_stamp, 2);
sfsync(hp->histfp);
} else {
// Initialize history list.
int first, last;
off_t mark, size = (HIST_MAX / 4) + maxlines * HIST_LINE;
hp->histind = first = hist_nearend(hp, hp->histfp, hsize - size);
histinit = 1;
hist_eof(hp); // this sets histind to last command
if ((hist_start = (last = (int)hp->histind) - maxlines) <= 0) hist_start = 1;
mark = hp->histmarker;
while (first > hist_start) {
size += size;
first = hist_nearend(hp, hp->histfp, hsize - size);
hp->histind = first;
}
histinit = hist_start;
hist_eof(hp);
if (!histinit) {
sfseek(hp->histfp, hp->histcnt = hsize, SEEK_SET);
hp->histind = last;
hp->histmarker = mark;
}
histinit = 0;
}
if (fname) {
unlink(fname);
free(fname);
}
if (hist_clean(fd) && hist_start > 1 && hsize > HIST_MAX) {
#ifdef DEBUG
sfprintf(sfstderr, "%d: hist_trim hsize=%d\n", getpid(), hsize);
sfsync(sfstderr);
#endif // DEBUG
hp = hist_trim(hp, (int)hp->histind - maxlines);
}
sfdisc(hp->histfp, &hp->histdisc);
STORE_VT((HISTCUR)->nvalue, i32p, &hp->histind);
sh_timeradd(1000L * (HIST_RECENT - 30), 1, hist_touch, hp->histname);
hp->auditfp = NULL;
char buff[SF_BUFSIZE];
if (!sh_isstate(shp, SH_INTERACTIVE)) return 1;
hp->auditmask = sh_checkaudit(hp, AUDIT_FILE, buff, sizeof(buff));
if (!hp->auditmask) return 1;
if ((fd = sh_open(buff, O_BINARY | O_WRONLY | O_APPEND | O_CREAT | O_CLOEXEC,
S_IRUSR | S_IWUSR)) >= 0 &&
fd < 10) {
int n;
if ((n = sh_fcntl(fd, F_DUPFD_CLOEXEC, 10)) >= 0) {
sh_close(fd);
fd = n;
}
}
if (fd >= 0) {
(void)fcntl(fd, F_SETFD, FD_CLOEXEC);
hp->tty = strdup(isatty(2) ? ttyname(2) : "notty");
hp->auditfp = sfnew(NULL, NULL, -1, fd, SF_WRITE);
}
return 1;
}
int path_expand(Shell_t *shp, const char *pattern, struct argnod **arghead) {
glob_t gdata;
struct argnod *ap;
glob_t *gp = &gdata;
int flags, extra = 0;
#if SHOPT_BASH
int off;
char *sp, *cp, *cp2;
#endif
sh_stats(STAT_GLOBS);
memset(gp, 0, sizeof(gdata));
flags = GLOB_GROUP | GLOB_AUGMENTED | GLOB_NOCHECK | GLOB_NOSORT | GLOB_STACK | GLOB_LIST |
GLOB_DISC;
if (sh_isoption(shp, SH_MARKDIRS)) flags |= GLOB_MARK;
if (sh_isoption(shp, SH_GLOBSTARS)) flags |= GLOB_STARSTAR;
#if SHOPT_BASH
#if 0
if(sh_isoption(shp,SH_BASH) && !sh_isoption(shp,SH_EXTGLOB))
flags &= ~GLOB_AUGMENTED;
#endif
if (sh_isoption(shp, SH_NULLGLOB)) flags &= ~GLOB_NOCHECK;
if (sh_isoption(shp, SH_NOCASEGLOB)) flags |= GLOB_ICASE;
#endif
if (sh_isstate(shp, SH_COMPLETE)) {
extra += scantree(shp, shp->alias_tree, pattern, arghead);
extra += scantree(shp, shp->fun_tree, pattern, arghead);
gp->gl_nextdir = nextdir;
flags |= GLOB_COMPLETE;
flags &= ~GLOB_NOCHECK;
}
#if SHOPT_BASH
off = stktell(shp->stk);
if (off) sp = stkfreeze(shp->stk, 0);
if (sh_isoption(shp, SH_BASH)) {
// For bash, FIGNORE is a colon separated list of suffixes to ignore
// when doing filename/command completion. GLOBIGNORE is similar to ksh
// FIGNORE, but colon separated instead of being an augmented shell
// pattern. Generate shell patterns out of those here.
if (sh_isstate(shp, SH_FCOMPLETE)) {
cp = nv_getval(sh_scoped(shp, FIGNORENOD));
} else {
static Namval_t *GLOBIGNORENOD;
if (!GLOBIGNORENOD) GLOBIGNORENOD = nv_open("GLOBIGNORE", shp->var_tree, 0);
cp = nv_getval(sh_scoped(shp, GLOBIGNORENOD));
}
if (cp) {
flags |= GLOB_AUGMENTED;
sfputr(shp->stk, "@(", -1);
if (!sh_isstate(shp, SH_FCOMPLETE)) {
sfputr(shp->stk, cp, -1);
for (cp = stkptr(shp->stk, off); *cp; cp++) {
if (*cp == ':') *cp = '|';
}
} else {
cp2 = strtok(cp, ":");
if (!cp2) cp2 = cp;
do {
sfputc(shp->stk, '*');
sfputr(shp->stk, cp2, -1);
cp2 = strtok(NULL, ":");
if (cp2) {
*(cp2 - 1) = ':';
sfputc(shp->stk, '|');
}
} while (cp2);
}
sfputc(shp->stk, ')');
gp->gl_fignore = stkfreeze(shp->stk, 1);
} else if (!sh_isstate(shp, SH_FCOMPLETE) && sh_isoption(shp, SH_DOTGLOB)) {
gp->gl_fignore = "";
}
} else
#endif
gp->gl_fignore = nv_getval(sh_scoped(shp, FIGNORENOD));
if (suflen) gp->gl_suffix = sufstr;
gp->gl_intr = &shp->trapnote;
suflen = 0;
if (strncmp(pattern, "~(N", 3) == 0) flags &= ~GLOB_NOCHECK;
ast_glob(pattern, flags, 0, gp);
#if SHOPT_BASH
if (off) {
stkset(shp->stk, sp, off);
} else {
stkseek(shp->stk, 0);
}
#endif
sh_sigcheck(shp);
for (ap = (struct argnod *)gp->gl_list; ap; ap = ap->argnxt.ap) {
ap->argchn.ap = ap->argnxt.ap;
if (!ap->argnxt.ap) ap->argchn.ap = *arghead;
}
if (gp->gl_list) *arghead = (struct argnod *)gp->gl_list;
return gp->gl_pathc + extra;
}
