diff options
Diffstat (limited to 'source/ap/ash/patches')
21 files changed, 6218 insertions, 0 deletions
diff --git a/source/ap/ash/patches/ash-builtin.patch b/source/ap/ash/patches/ash-builtin.patch new file mode 100644 index 000000000..b812e6375 --- /dev/null +++ b/source/ap/ash/patches/ash-builtin.patch @@ -0,0 +1,843 @@ +diff -urN netbsd-sh/builtins.def ash-0.3.7.orig/builtins.def +--- netbsd-sh/builtins.def Mon Apr 10 13:02:58 2000 ++++ ash-0.3.7.orig/builtins.def Mon Apr 23 22:16:46 2001 +@@ -49,12 +49,13 @@ + # + # NOTE: bltincmd must come first! + +-bltincmd command ++bltincmd builtin + #alloccmd alloc + bgcmd -j bg + breakcmd break continue + #catfcmd catf + cdcmd cd chdir ++commandcmd command + dotcmd . + echocmd echo + evalcmd eval +diff -urN netbsd-sh/eval.c ash-0.3.7.orig/eval.c +--- netbsd-sh/eval.c Tue May 23 12:03:18 2000 ++++ ash-0.3.7.orig/eval.c Mon Apr 23 22:16:46 2001 +@@ -45,7 +45,9 @@ + #endif + #endif /* not lint */ + ++#include <sys/types.h> + #include <signal.h> ++#include <malloc.h> + #include <unistd.h> + + /* +@@ -101,6 +103,8 @@ + STATIC void evalpipe __P((union node *)); + STATIC void evalcommand __P((union node *, int, struct backcmd *)); + STATIC void prehash __P((union node *)); ++STATIC int is_assignment_builtin __P((const char *)); ++STATIC const char *get_standard_path __P((void)); + + + /* +@@ -257,6 +261,11 @@ + evalcase(n, flags); + break; + case NDEFUN: ++ if (is_special_builtin(n->narg.text)) { ++ outfmt(out2, "%s is a special built-in\n", n->narg.text); ++ exitstatus = 1; ++ break; ++ } + defun(n->narg.text, n->narg.next); + exitstatus = 0; + break; +@@ -497,9 +507,14 @@ + close(0); + copyfd(prevfd, 0); + close(prevfd); ++ if (pip[0] == 0) { ++ pip[0] = -1; ++ } + } + if (pip[1] >= 0) { +- close(pip[0]); ++ if (pip[0] >= 0) { ++ close(pip[0]); ++ } + if (pip[1] != 1) { + close(1); + copyfd(pip[1], 1); +@@ -607,6 +622,7 @@ + int argc; + char **envp; + int varflag; ++ int pseudovarflag; + struct strlist *sp; + int mode; + int pip[2]; +@@ -619,12 +635,17 @@ + struct localvar *volatile savelocalvars; + volatile int e; + char *lastarg; ++ int not_special; ++ const char *path; ++ const char *standard_path; + #if __GNUC__ + /* Avoid longjmp clobbering */ + (void) &argv; + (void) &argc; + (void) &lastarg; + (void) &flags; ++ (void) ¬_special; ++ (void) &standard_path; + #endif + + /* First expand the arguments. */ +@@ -632,21 +653,31 @@ + setstackmark(&smark); + arglist.lastp = &arglist.list; + varlist.lastp = &varlist.list; ++ arglist.list = 0; + varflag = 1; ++ pseudovarflag = 0; + oexitstatus = exitstatus; + exitstatus = 0; ++ not_special = 0; ++ path = pathval(); ++ standard_path = NULL; + for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) { + char *p = argp->narg.text; +- if (varflag && is_name(*p)) { ++ if ((varflag || pseudovarflag) && is_name(*p)) { + do { + p++; + } while (is_in_name(*p)); + if (*p == '=') { +- expandarg(argp, &varlist, EXP_VARTILDE); ++ if (varflag) ++ expandarg(argp, &varlist, EXP_VARTILDE); ++ else ++ expandarg(argp, &arglist, EXP_VARTILDE); + continue; + } + } + expandarg(argp, &arglist, EXP_FULL | EXP_TILDE); ++ if (varflag && arglist.list && is_assignment_builtin(arglist.list->text)) ++ pseudovarflag = 1; + varflag = 0; + } + *arglist.lastp = NULL; +@@ -688,37 +719,75 @@ + cmdentry.u.index = BLTINCMD; + } else { + static const char PATH[] = "PATH="; +- const char *path = pathval(); ++ const char *oldpath = NULL; ++ int findflag = DO_ERR; + + /* + * Modify the command lookup path, if a PATH= assignment + * is present + */ + for (sp = varlist.list ; sp ; sp = sp->next) +- if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0) ++ if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0) { + path = sp->text + sizeof(PATH) - 1; +- +- find_command(argv[0], &cmdentry, DO_ERR, path); +- if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */ +- exitstatus = 127; +- flushout(&errout); +- return; +- } +- /* implement the bltin builtin here */ +- if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) { +- for (;;) { ++ findflag |= DO_BRUTE; ++ } ++ for(;;) { ++ find_command(argv[0], &cmdentry, findflag, path); ++ if (oldpath) { ++ path = oldpath; ++ oldpath = NULL; ++ } ++ if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */ ++ exitstatus = 127; ++ flushout(&errout); ++ goto out; ++ } ++ /* implement the bltin builtin here */ ++ if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) { ++ not_special = 1; ++ for(;;) { ++ argv++; ++ if (--argc == 0) ++ break; ++ if ((cmdentry.u.index = find_builtin(*argv)) < 0) { ++ outfmt(&errout, "%s: not found\n", *argv); ++ exitstatus = 127; ++ flushout(&errout); ++ goto out; ++ } ++ if (cmdentry.u.index != BLTINCMD) ++ break; ++ } ++ } ++ if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == COMMANDCMD) { ++ not_special = 1; + argv++; +- if (--argc == 0) +- break; +- if ((cmdentry.u.index = find_builtin(*argv)) < 0) { +- outfmt(&errout, "%s: not found\n", *argv); +- exitstatus = 127; +- flushout(&errout); +- return; ++ if (--argc == 0) { ++ exitstatus = 0; ++ goto out; + } +- if (cmdentry.u.index != BLTINCMD) +- break; ++ if (*argv[0] == '-') { ++ if (!equal(argv[0], "-p")) { ++ argv--; ++ argc++; ++ break; ++ } ++ argv++; ++ if (--argc == 0) { ++ exitstatus = 0; ++ goto out; ++ } ++ if (!standard_path) { ++ standard_path = get_standard_path(); ++ } ++ oldpath = path; ++ path = standard_path; ++ findflag |= DO_BRUTE; ++ } ++ findflag |= DO_NOFUN; ++ continue; + } ++ break; + } + } + +@@ -756,13 +825,12 @@ + #ifdef DEBUG + trputs("Shell function: "); trargs(argv); + #endif ++ exitstatus = oexitstatus; + redirect(cmd->ncmd.redirect, REDIR_PUSH); + saveparam = shellparam; + shellparam.malloc = 0; +- shellparam.reset = 1; + shellparam.nparam = argc - 1; + shellparam.p = argv + 1; +- shellparam.optnext = NULL; + INTOFF; + savelocalvars = localvars; + localvars = NULL; +@@ -772,6 +840,8 @@ + freeparam((volatile struct shparam *) + &saveparam); + } else { ++ saveparam.optind = shellparam.optind; ++ saveparam.optoff = shellparam.optoff; + freeparam(&shellparam); + shellparam = saveparam; + } +@@ -790,6 +860,8 @@ + INTOFF; + poplocalvars(); + localvars = savelocalvars; ++ saveparam.optind = shellparam.optind; ++ saveparam.optoff = shellparam.optoff; + freeparam(&shellparam); + shellparam = saveparam; + handler = savehandler; +@@ -832,6 +908,8 @@ + out1 = &output; + out2 = &errout; + freestdout(); ++ if (!not_special && is_special_builtin(commandname)) ++ listsetvar(cmdenviron); + cmdenviron = NULL; + if (e != EXSHELLPROC) { + commandname = savecmdname; +@@ -867,7 +953,7 @@ + for (sp = varlist.list ; sp ; sp = sp->next) + setvareq(sp->text, VEXPORT|VSTACK); + envp = environment(); +- shellexec(argv, envp, pathval(), cmdentry.u.index); ++ shellexec(argv, envp, path, cmdentry.u.index); + } + goto out; + +@@ -1025,4 +1111,49 @@ + shellexec(argv + 1, environment(), pathval(), 0); + } + return 0; ++} ++ ++STATIC int ++is_assignment_builtin (command) ++ const char *command; ++{ ++ static const char *assignment_builtins[] = { ++ "alias", "declare", "export", "local", "readonly", "typeset", ++ (char *)NULL ++ }; ++ int i; ++ ++ for (i = 0; assignment_builtins[i]; i++) ++ if (strcmp(command, assignment_builtins[i]) == 0) return 1; ++ return 0; ++} ++ ++int ++is_special_builtin(name) ++ const char *name; ++{ ++ static const char *special_builtins[] = { ++ "break", ":", ".", "continue", "eval", "exec", "exit", ++ "export", "readonly", "return", "set", "shift", "times", ++ "trap", "unset", (char *)NULL ++ }; ++ int i; ++ ++ if (!name) return 0; ++ for (i = 0; special_builtins[i]; i++) ++ if (equal(name, special_builtins[i])) return 1; ++ return 0; ++} ++ ++STATIC const char * ++get_standard_path() ++{ ++ char *p; ++ size_t len; ++ ++ len = confstr(_CS_PATH, NULL, 0); ++ p = stalloc(len + 2); ++ *p = '\0'; ++ confstr(_CS_PATH, p, len); ++ return p; + } +diff -urN netbsd-sh/eval.h ash-0.3.7.orig/eval.h +--- netbsd-sh/eval.h Fri Jan 28 13:03:00 2000 ++++ ash-0.3.7.orig/eval.h Mon Apr 23 22:16:46 2001 +@@ -61,6 +61,7 @@ + int falsecmd __P((int, char **)); + int truecmd __P((int, char **)); + int execcmd __P((int, char **)); ++int is_special_builtin __P((const char *)); + + /* in_function returns nonzero if we are currently evaluating a function */ + #define in_function() funcnest +diff -urN netbsd-sh/exec.c ash-0.3.7.orig/exec.c +--- netbsd-sh/exec.c Fri Jan 12 17:50:35 2001 ++++ ash-0.3.7.orig/exec.c Mon Apr 23 22:16:46 2001 +@@ -51,6 +51,7 @@ + #include <fcntl.h> + #include <errno.h> + #include <stdlib.h> ++#include <sysexits.h> + + /* + * When commands are first encountered, they are entered in a hash table. +@@ -108,6 +109,9 @@ + STATIC void clearcmdentry __P((int)); + STATIC struct tblentry *cmdlookup __P((char *, int)); + STATIC void delete_cmd_entry __P((void)); ++STATIC int describe_command __P((char *, int)); ++STATIC int path_change __P((const char *, int *)); ++STATIC int is_regular_builtin __P((const char *)); + + + +@@ -164,7 +172,7 @@ + char **envp; + { + int e; +-#ifndef BSD ++#if !defined(BSD) && !defined(linux) + char *p; + #endif + +@@ -180,7 +188,7 @@ + initshellproc(); + setinputfile(cmd, 0); + commandname = arg0 = savestr(argv[0]); +-#ifndef BSD ++#if !defined(BSD) && !defined(linux) + pgetc(); pungetc(); /* fill up input buffer */ + p = parsenextc; + if (parsenleft > 2 && p[0] == '#' && p[1] == '!') { +@@ -195,7 +203,7 @@ + } + + +-#ifndef BSD ++#if !defined(BSD) && !defined(linux) + /* + * Execute an interpreter introduced by "#!", for systems where this + * feature has not been built into the kernel. If the interpreter is +@@ -351,27 +359,29 @@ + if (*argptr == NULL) { + for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) { + for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { +- printentry(cmdp, verbose); ++ if (cmdp->cmdtype != CMDBUILTIN) { ++ printentry(cmdp, verbose); ++ } + } + } + return 0; + } ++ c = 0; + while ((name = *argptr) != NULL) { + if ((cmdp = cmdlookup(name, 0)) != NULL + && (cmdp->cmdtype == CMDNORMAL + || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))) + delete_cmd_entry(); + find_command(name, &entry, DO_ERR, pathval()); +- if (verbose) { +- if (entry.cmdtype != CMDUNKNOWN) { /* if no error msg */ +- cmdp = cmdlookup(name, 0); +- printentry(cmdp, verbose); +- } ++ if (entry.cmdtype == CMDUNKNOWN) c = 1; ++ else if (verbose) { ++ cmdp = cmdlookup(name, 0); ++ if (cmdp) printentry(cmdp, verbose); + flushall(); + } + argptr++; + } +- return 0; ++ return c; + } + + +@@ -435,6 +445,10 @@ + struct stat statb; + int e; + int i; ++ int bltin; ++ int firstchange; ++ int updatetbl; ++ int regular; + + /* If name contains a slash, don't use the hash table */ + if (strchr(name, '/') != NULL) { +@@ -459,12 +473,54 @@ + return; + } + ++ updatetbl = 1; ++ if (act & DO_BRUTE) { ++ firstchange = path_change(path, &bltin); ++ } else { ++ bltin = builtinloc; ++ firstchange = 9999; ++ } ++ + /* If name is in the table, and not invalidated by cd, we're done */ +- if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) +- goto success; ++ if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) { ++ if (cmdp->cmdtype == CMDFUNCTION) { ++ if (act & DO_NOFUN) { ++ updatetbl = 0; ++ } else { ++ goto success; ++ } ++ } else if (act & DO_BRUTE) { ++ if ((cmdp->cmdtype == CMDNORMAL && ++ cmdp->param.index >= firstchange) || ++ (cmdp->cmdtype == CMDBUILTIN && ++ ((builtinloc < 0 && bltin >= 0) ? ++ bltin : builtinloc) >= firstchange)) { ++ /* need to recompute the entry */ ++ } else { ++ goto success; ++ } ++ } else { ++ goto success; ++ } ++ } ++ ++ if ((regular = is_regular_builtin(name))) { ++ if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) { ++ goto success; ++ } ++ } else if (act & DO_BRUTE) { ++ if (firstchange == 0) { ++ updatetbl = 0; ++ } ++ } + + /* If %builtin not in path, check for builtin next */ +- if (builtinloc < 0 && (i = find_builtin(name)) >= 0) { ++ if ((bltin < 0 || regular) && (i = find_builtin(name)) >= 0) { ++ if (!updatetbl) { ++ entry->cmdtype = CMDBUILTIN; ++ entry->u.index = i; ++ return; ++ } + INTOFF; + cmdp = cmdlookup(name, 1); + cmdp->cmdtype = CMDBUILTIN; +@@ -475,7 +531,7 @@ + + /* We have to search path. */ + prev = -1; /* where to start */ +- if (cmdp) { /* doing a rehash */ ++ if (cmdp && cmdp->rehash) { /* doing a rehash */ + if (cmdp->cmdtype == CMDBUILTIN) + prev = builtinloc; + else +@@ -488,26 +544,38 @@ + while ((fullname = padvance(&path, name)) != NULL) { + stunalloc(fullname); + idx++; ++ if (idx >= firstchange) { ++ updatetbl = 0; ++ } + if (pathopt) { + if (prefix("builtin", pathopt)) { +- if ((i = find_builtin(name)) < 0) +- goto loop; +- INTOFF; +- cmdp = cmdlookup(name, 1); +- cmdp->cmdtype = CMDBUILTIN; +- cmdp->param.index = i; +- INTON; +- goto success; +- } else if (prefix("func", pathopt)) { ++ if ((i = find_builtin(name)) >= 0) { ++ if (!updatetbl) { ++ entry->cmdtype = CMDBUILTIN; ++ entry->u.index = i; ++ return; ++ } ++ INTOFF; ++ cmdp = cmdlookup(name, 1); ++ cmdp->cmdtype = CMDBUILTIN; ++ cmdp->param.index = i; ++ INTON; ++ goto success; ++ } else { ++ continue; ++ } ++ } else if (!(act & DO_NOFUN) && ++ prefix("func", pathopt)) { + /* handled below */ + } else { +- goto loop; /* ignore unimplemented options */ ++ continue; /* ignore unimplemented options */ + } + } + /* if rehash, don't redo absolute path names */ +- if (fullname[0] == '/' && idx <= prev) { ++ if (fullname[0] == '/' && idx <= prev && ++ idx < firstchange) { + if (idx < prev) +- goto loop; ++ continue; + TRACE(("searchexec \"%s\": no change\n", name)); + goto success; + } +@@ -522,7 +590,7 @@ + } + e = EACCES; /* if we fail, this will be the error */ + if (!S_ISREG(statb.st_mode)) +- goto loop; ++ continue; + if (pathopt) { /* this is a %func directory */ + stalloc(strlen(fullname) + 1); + readcmdfile(fullname); +@@ -544,6 +612,13 @@ + } + #endif + TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname)); ++ /* If we aren't called with DO_BRUTE and cmdp is set, it must ++ be a function and we're being called with DO_NOFUN */ ++ if (!updatetbl) { ++ entry->cmdtype = CMDNORMAL; ++ entry->u.index = idx; ++ return; ++ } + INTOFF; + cmdp = cmdlookup(name, 1); + cmdp->cmdtype = CMDNORMAL; +@@ -553,7 +628,7 @@ + } + + /* We failed. If there was an entry for this command, delete it */ +- if (cmdp) ++ if (cmdp && updatetbl) + delete_cmd_entry(); + if (act & DO_ERR) + outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC)); +@@ -618,37 +693,12 @@ + changepath(newval) + const char *newval; + { +- const char *old, *new; +- int idx; + int firstchange; + int bltin; + +- old = pathval(); +- new = newval; +- firstchange = 9999; /* assume no change */ +- idx = 0; +- bltin = -1; +- for (;;) { +- if (*old != *new) { +- firstchange = idx; +- if ((*old == '\0' && *new == ':') +- || (*old == ':' && *new == '\0')) +- firstchange++; +- old = new; /* ignore subsequent differences */ +- } +- if (*new == '\0') +- break; +- if (*new == '%' && bltin < 0 && prefix("builtin", new + 1)) +- bltin = idx; +- if (*new == ':') { +- idx++; +- } +- new++, old++; +- } ++ firstchange = path_change(newval, &bltin); + if (builtinloc < 0 && bltin >= 0) + builtinloc = bltin; /* zap builtins */ +- if (builtinloc >= 0 && bltin < 0) +- firstchange = 0; + clearcmdentry(firstchange); + builtinloc = bltin; + } +@@ -838,11 +888,9 @@ + { + struct cmdentry entry; + +- INTOFF; + entry.cmdtype = CMDFUNCTION; + entry.u.func = copyfunc(func); + addcmdentry(name, &entry); +- INTON; + } + + +@@ -944,4 +992,190 @@ + } + } + return err; ++} ++ ++STATIC int ++describe_command(command, verbose) ++ char *command; ++ int verbose; ++{ ++ struct cmdentry entry; ++ struct tblentry *cmdp; ++ char **pp; ++ struct alias *ap; ++ extern char *const parsekwd[]; ++ ++ for (pp = (char **)parsekwd; *pp; pp++) ++ if (**pp == *command && equal(*pp, command)) ++ break; ++ ++ if (*pp) { ++ if (verbose) { ++ out1fmt("%s is a reserved word\n", command); ++ } else { ++ out1fmt("%s\n", command); ++ } ++ return 0; ++ } ++ ++ /* Then look at the aliases */ ++ if ((ap = lookupalias(command, 1)) != NULL) { ++ if (verbose) { ++ out1fmt("%s is aliased to `%s'\n", command, ap->val); ++ } else { ++ out1fmt("alias %s='%s'\n", command, ap->val); ++ } ++ return 0; ++ } ++ ++ /* Then check if it is a tracked alias */ ++ if ((cmdp = cmdlookup(command, 0)) != NULL) { ++ entry.cmdtype = cmdp->cmdtype; ++ entry.u = cmdp->param; ++ } ++ else { ++ /* Finally use brute force */ ++ find_command(command, &entry, DO_ABS, pathval()); ++ } ++ ++ switch (entry.cmdtype) { ++ case CMDNORMAL: { ++ int j = entry.u.index; ++ const char *path = pathval(); ++ char *name; ++ if (j == -1) ++ name = command; ++ else { ++ do { ++ name = padvance(&path, command); ++ stunalloc(name); ++ } while (--j >= 0); ++ } ++ if (verbose) { ++ out1fmt("%s is %s\n", command, name); ++ } else { ++ out1fmt("%s\n", name); ++ } ++ break; ++ } ++ case CMDFUNCTION: ++ if (verbose) { ++ out1fmt("%s is a function\n", command); ++ } else { ++ out1fmt("%s\n", command); ++ } ++ break; ++ case CMDBUILTIN: ++ if (verbose) { ++ if (is_special_builtin(command)) { ++ out1fmt("%s is a special built-in utility\n", command); ++ } else { ++ out1fmt("%s is a built-in utility\n", command); ++ } ++ } else { ++ out1fmt("%s\n", command); ++ } ++ break; ++ default: ++ outfmt(out2, "%s not found\n", command); ++ return 127; ++ } ++ ++ return 0; ++} ++ ++int ++commandcmd(argc, argv) ++ int argc; ++ char **argv; ++{ ++ int c; ++ int default_path = 0; ++ int verify_only = 0; ++ int verbose_verify_only = 0; ++ ++ while ((c = nextopt("pvV")) != '\0') ++ switch (c) { ++ case 'p': ++ default_path = 1; ++ break; ++ case 'v': ++ verify_only = 1; ++ break; ++ case 'V': ++ verbose_verify_only = 1; ++ break; ++ default: ++ outfmt(out2, ++"command: nextopt returned character code 0%o\n", c); ++ return EX_SOFTWARE; ++ } ++ ++ if (default_path + verify_only + verbose_verify_only > 1 || ++ !*argptr) { ++ outfmt(out2, ++"command [-p] command [arg ...]\n"); ++ outfmt(out2, ++"command {-v|-V} command\n"); ++ return EX_USAGE; ++ } ++ ++ if (verify_only || verbose_verify_only) { ++ return describe_command(*argptr, verbose_verify_only); ++ } ++ ++ return 0; ++} ++ ++STATIC int ++path_change(newval, bltin) ++ const char *newval; ++ int *bltin; ++{ ++ const char *old, *new; ++ int idx; ++ int firstchange; ++ ++ old = pathval(); ++ new = newval; ++ firstchange = 9999; /* assume no change */ ++ idx = 0; ++ *bltin = -1; ++ for (;;) { ++ if (*old != *new) { ++ firstchange = idx; ++ if ((*old == '\0' && *new == ':') ++ || (*old == ':' && *new == '\0')) ++ firstchange++; ++ old = new; /* ignore subsequent differences */ ++ } ++ if (*new == '\0') ++ break; ++ if (*new == '%' && *bltin < 0 && prefix("builtin", new + 1)) ++ *bltin = idx; ++ if (*new == ':') { ++ idx++; ++ } ++ new++, old++; ++ } ++ if (builtinloc >= 0 && *bltin < 0) ++ firstchange = 0; ++ return firstchange; ++} ++ ++STATIC int ++is_regular_builtin(name) ++ const char *name; ++{ ++ static const char *regular_builtins[] = { ++ "alias", "bg", "cd", "command", "false", "fc", "fg", ++ "getopts", "jobs", "kill", "newgrp", "read", "true", ++ "umask", "unalias", "wait", (char *)NULL ++ }; ++ int i; ++ ++ if (!name) return 0; ++ for (i = 0; regular_builtins[i]; i++) ++ if (equal(name, regular_builtins[i])) return 1; ++ return 0; + } +diff -urN netbsd-sh/exec.h ash-0.3.7.orig/exec.h +--- netbsd-sh/exec.h Tue May 23 12:03:19 2000 ++++ ash-0.3.7.orig/exec.h Mon Apr 23 22:16:46 2001 +@@ -56,6 +56,8 @@ + + #define DO_ERR 1 /* find_command prints errors */ + #define DO_ABS 2 /* find_command checks absolute paths */ ++#define DO_NOFUN 4 /* find_command ignores functions */ ++#define DO_BRUTE 8 /* find_command ignores hash table */ + + extern const char *pathopt; /* set by padvance */ + extern int exerrno; /* last exec error */ +@@ -74,3 +76,4 @@ + void defun __P((char *, union node *)); + int unsetfunc __P((char *)); + int typecmd __P((int, char **)); ++int commandcmd __P((int, char **)); + diff --git a/source/ap/ash/patches/ash-debian.patch b/source/ap/ash/patches/ash-debian.patch new file mode 100644 index 000000000..d3e79bfcd --- /dev/null +++ b/source/ap/ash/patches/ash-debian.patch @@ -0,0 +1,702 @@ +diff -urN netbsd-sh/debian/README.debian ash-0.3.7.orig/debian/README.debian +--- netbsd-sh/debian/README.debian Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/README.debian Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,14 @@ ++ash for DEBIAN ++---------------------- ++ ++This is a very simple port of ash taken from NetBSD-current on 1997/06/18. The ++file setmode.c was taken from src/libc/gen and is needed since the Linux libc ++does provide getmode(3) or setmode(3). History editing is disabled to avoid ++code bloat. This also means that building the package is possible without the ++BSD libedit. ++ ++This port is preriodically revised to keep up to date with NetBSD's current ++release. ++ ++Herbert Xu <herbert@debian.org> ++$Id: README.debian,v 1.6 2000/08/04 11:33:48 herbert Exp $ +diff -urN netbsd-sh/debian/ash-medium.README.Debian ash-0.3.7.orig/debian/ash-medium.README.Debian +--- netbsd-sh/debian/ash-medium.README.Debian Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/ash-medium.README.Debian Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,14 @@ ++ash for DEBIAN ++---------------------- ++ ++This is a very simple port of ash taken from NetBSD-current on 1997/06/18. The ++file setmode.c was taken from src/libc/gen and is needed since the Linux libc ++does provide getmode(3) or setmode(3). History editing is disabled to avoid ++code bloat. This also means that building the package is possible without the ++BSD libedit. ++ ++This port is preriodically revised to keep up to date with NetBSD's current ++release. ++ ++Herbert Xu <herbert@debian.org> ++$Id: ash-medium.README.Debian,v 1.1 2000/08/04 11:49:01 herbert Exp $ +diff -urN netbsd-sh/debian/ash-medium.dirs ash-0.3.7.orig/debian/ash-medium.dirs +--- netbsd-sh/debian/ash-medium.dirs Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/ash-medium.dirs Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,2 @@ ++usr/bin ++usr/share/man/man1 +diff -urN netbsd-sh/debian/ash-udeb.dirs ash-0.3.7.orig/debian/ash-udeb.dirs +--- netbsd-sh/debian/ash-udeb.dirs Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/ash-udeb.dirs Mon Apr 23 22:16:46 2001 +@@ -0,0 +1 @@ ++bin +diff -urN netbsd-sh/debian/bsdyacc ash-0.3.7.orig/debian/bsdyacc +--- netbsd-sh/debian/bsdyacc Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/bsdyacc Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,20 @@ ++#!/bin/sh -e ++ ++if echo "$@" | grep -q -- -o; then ++ OUTPUT=$(echo "$@" | ++ sed 's/.*-o[[:blank:]]\+\([^[:blank:]]\+\)\.c.*/\1/') ++ OPTIONS=$(echo "$@" | ++ sed 's/\(.*\)-o[[:blank:]]\+[^[:blank:]]\+\(.*\)/\1\2/') ++ NEW=1 ++else ++ OUTPUT=$(echo "$@" | ++ sed -e 's/.*[[:blank:]]\+\([^[:blank:]]\+\)\.y.*/\1/') ++ OPTIONS="$@" ++ NEW=0 ++fi ++ ++byacc $OPTIONS ++if [ $NEW = 1 ]; then ++ mv y.tab.c $OUTPUT.c ++fi ++mv y.tab.h $OUTPUT.h +diff -urN netbsd-sh/debian/changelog ash-0.3.7.orig/debian/changelog +--- netbsd-sh/debian/changelog Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/changelog Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,429 @@ ++ash (0.3.7-14) unstable; urgency=low ++ ++ * Removed predependency from udeb (closes: #81995). ++ * Added /bin/sh symlink to udeb (closes: #81967). ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 13 Jan 2001 15:23:21 +1100 ++ ++ash (0.3.7-13) unstable; urgency=low ++ ++ * Renamed the udeb to ash-udeb. ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 20 Dec 2000 19:32:34 +1100 ++ ++ash (0.3.7-12) unstable; urgency=low ++ ++ * Added support for udebs (Randolph Chung, closes: #79237). ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 16 Dec 2000 13:53:28 +1100 ++ ++ash (0.3.7-11) unstable; urgency=low ++ ++ * Preserve the previous exit status upon entering a function ++ (closes: #78374). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 3 Dec 2000 13:34:27 +1100 ++ ++ash (0.3.7-10) unstable; urgency=low ++ ++ * Merged changes for GNU from Igor Khavkine. ++ * Minimise the number of sigactions. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 3 Nov 2000 20:31:52 +1100 ++ ++ash (0.3.7-9) unstable; urgency=low ++ ++ * Predepend on the libraries. ++ * Always save fd 2 when it is redirected (closes: #75302). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 22 Oct 2000 08:40:40 +1100 ++ ++ash (0.3.7-8) unstable; urgency=high ++ ++ * More redirection fixes (closes: #73613). ++ ++ -- Herbert Xu <herbert@debian.org> Thu, 5 Oct 2000 18:22:17 +1100 ++ ++ash (0.3.7-7) unstable; urgency=high ++ ++ * Added missing break in redirection code (closes: #72956). ++ ++ -- Herbert Xu <herbert@debian.org> Tue, 3 Oct 2000 07:58:04 +1100 ++ ++ash (0.3.7-6) unstable; urgency=low ++ ++ * command -[vV] no longer displays an error message on stdout. ++ * Redirecting to /proc/self/fd/* now works (closes: #72852). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 1 Oct 2000 12:56:39 +1100 ++ ++ash (0.3.7-5) unstable; urgency=low ++ ++ * Implemented set -a. ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 30 Sep 2000 16:00:33 +1100 ++ ++ash (0.3.7-4) unstable; urgency=low ++ ++ * Added build-time dependency on debhelper (closes: #69920). ++ * Extended maximum length of arithmetic expansions to match 32-bit integers. ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 20 Sep 2000 14:28:16 +1100 ++ ++ash (0.3.7-3) unstable; urgency=low ++ ++ * Switch to the old globbing code since glob(3) is hopelessly broken ++ (closes: #69455). ++ ++ -- Herbert Xu <herbert@debian.org> Mon, 21 Aug 2000 20:37:15 +1000 ++ ++ash (0.3.7-2) unstable; urgency=low ++ ++ * Call glob(3) with GLOB_NOMAGIC (ouch). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 6 Aug 2000 17:47:08 +1000 ++ ++ash (0.3.7-1) unstable; urgency=low ++ ++ * NetBSD-current version as of 20000729. ++ * Use fnmatch(3) and glob(3). ++ * Fixed the use of backslashes in the pattern in parameter substitutions, ++ hopefully for the last time. ++ * Applied HETIO patch and built ash.medium (closes: #50788). Will do ash.big ++ when readline is fixed so that it doesn't leak anymore. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 4 Aug 2000 21:36:44 +1000 ++ ++ash (0.3.6-5) unstable; urgency=low ++ ++ * Fixed manpage entry for read with patch from Kevin Ryde (closes: #62500). ++ * Fixed a file descriptor leak for pipelines. ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 19 Apr 2000 18:56:20 +1000 ++ ++ash (0.3.6-4) unstable; urgency=low ++ ++ * Fixed the case of an empty command with redirections. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 7 Apr 2000 12:07:18 +1000 ++ ++ash (0.3.6-3) unstable; urgency=low ++ ++ * ! is now recognised correctly. ++ * Ash is now more strict on the syntax, e.g., a lone ! is no longer accepted ++ as an alternative to ! true. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 7 Apr 2000 10:46:06 +1000 ++ ++ash (0.3.6-2) unstable; urgency=low ++ ++ * Fixed a problem with fmtstr() which broke getopts. ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 2 Apr 2000 10:49:26 +1000 ++ ++ash (0.3.6-1) unstable; urgency=low ++ ++ * NetBSD-current version as of 20000326. ++ * Added a Build-Depends on groff (closes: #61041). ++ * Implemented noclobber (closes: #59028). ++ * Rewrote output.c to use stream IO. ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 1 Apr 2000 19:24:31 +1000 ++ ++ash (0.3.5-10) frozen unstable; urgency=low ++ ++ * Don't stat mail boxes in non-interactive mode (closes: #59213). ++ * Added an fflush(stdout) to the times builtin (closes: #59027). ++ * Documented the times builtin. ++ * Added source depends. ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 18 Mar 2000 18:58:44 +1100 ++ ++ash (0.3.5-9) unstable; urgency=low ++ ++ * Double quotes inside paramater substitutions inside double quotes are now ++ ignored as in bash (the originial behaviour was POSIX compliant too but ++ IMHO this one makes a little bit more sense). ++ This one broke mwm (but it was actually mwm's fault). ++ * Corrected backslash/CTLESC treatment for patterns in parameter ++ substitutions. ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 6 Nov 1999 18:13:19 +1100 ++ ++ash (0.3.5-8) unstable; urgency=low ++ ++ * Replaced use of echo -n in manual page with escape codes. ++ * Made FHS compliant (closes: #47978). ++ * Restored echo's option processing ability. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 22 Oct 1999 10:20:58 +1000 ++ ++ash (0.3.5-7) unstable; urgency=low ++ ++ * echo no longer supports options. ++ * Don't quote patterns inside parameter substitutions enclosed by double ++ quotes (closes: #47842). ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 20 Oct 1999 20:28:14 +1000 ++ ++ash (0.3.5-6) unstable; urgency=low ++ ++ * Use getcwd() instead of /bin/pwd -- Zack Weinberg (closes: #46981). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 10 Oct 1999 16:31:49 +1000 ++ ++ash (0.3.5-5) unstable; urgency=low ++ ++ * Only test for -e on simple commands (fixes #44559). ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 8 Sep 1999 22:18:27 +1000 ++ ++ash (0.3.5-4) unstable; urgency=low ++ ++ * Don't wait for stopped children if job control is disabled (fixes #42814). ++ * Allow an option '(' in a case statement (fixes #42364). ++ ++ -- Herbert Xu <herbert@debian.org> Thu, 12 Aug 1999 23:30:30 +1000 ++ ++ash (0.3.5-3) unstable; urgency=low ++ ++ * OK, the fix to the esoteric problem in 0.3.5-1 actually breaks VSASSIGN ++ and VSQUESTION, they should work properly now (fixes #41327). ++ ++ -- Herbert Xu <herbert@debian.org> Thu, 15 Jul 1999 22:47:13 +1000 ++ ++ash (0.3.5-2) unstable; urgency=low ++ ++ * PATH search and execution is now correct. ++ * hash no longer shows builtins. ++ * Added kill builtin. ++ * New description from James R. van Zandt reformatted by Josip Rodin. ++ ++ -- Herbert Xu <herbert@debian.org> Mon, 12 Jul 1999 18:51:42 +1000 ++ ++ash (0.3.5-1) unstable; urgency=low ++ ++ * New upstream release. ++ * Adapted to new pmake (fixes #38737). ++ * Fixed behvaiour of backslashes preceding a closing brace for a parameter ++ substituion inside double quotes (even bash messes this one up :). ++ * Fixed command (fixes #34639). ++ * Fixed a pipe bug where stdin may be wrongly closed (fixes #35452). ++ * Revamped getopts (fixes #39694). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 4 Jul 1999 12:19:01 +1000 ++ ++ash (0.3.4-7) unstable; urgency=low ++ ++ * Fixed a glibc 2.1 compatitibility problem. ++ * Fixed a PWD inconsistency that stuffed up the kernel compilation. ++ ++ -- Herbert Xu <herbert@debian.org> Mon, 17 May 1999 23:14:57 +1000 ++ ++ash (0.3.4-6) unstable; urgency=low ++ ++ * Fixed incorrect -e test due to the last bug fix (fixes #26509). ++ ++ -- Herbert Xu <herbert@debian.org> Tue, 8 Sep 1998 10:02:46 +1000 ++ ++ash (0.3.4-5) unstable; urgency=low ++ ++ * Use test_eaccess from bash instead of access(2) (fixes #26110). ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 26 Aug 1998 21:22:49 +1000 ++ ++ash (0.3.4-4) unstable; urgency=low ++ ++ * Only upload to unstable. ++ ++ -- Herbert Xu <herbert@debian.org> Tue, 5 May 1998 18:01:02 +1000 ++ ++ash (0.3.4-3) frozen unstable; urgency=low ++ ++ * Applied sparc patch (fixes #21562). ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 1 May 1998 19:48:13 +1000 ++ ++ash (0.3.4-2) frozen unstable; urgency=low ++ ++ * Fixed the incorrect trap fixes (fixes #20363). ++ ++ -- Herbert Xu <herbert@debian.org> Thu, 16 Apr 1998 21:07:10 +1000 ++ ++ash (0.3.4-1) unstable; urgency=low ++ ++ * New upstream release. ++ * Reverted word splitting change in 0.3.2-1 since the fix was broken and ++ major work (the quote removal is done too quickly at the moment) is needed ++ to fix it properly. ++ * Fixed more trap noncompliance. ++ ++ -- Herbert Xu <herbert@debian.org> Thu, 19 Mar 1998 22:59:12 +1100 ++ ++ash (0.3.2-5) unstable; urgency=low ++ ++ * Fixed a bug when doing pattern matching in parameter expansions. ++ ++ -- Herbert Xu <herbert@debian.org> Tue, 10 Mar 1998 21:25:40 +1100 ++ ++ash (0.3.2-4) unstable; urgency=low ++ ++ * Allow ] to be quoted in bracket expressions (fixes #17533). ++ * Move dh_fixperms to second last spot (fixes #18267). ++ * Don't do field splitting in evalfor. ++ ++ -- Herbert Xu <herbert@debian.org> Tue, 17 Feb 1998 13:32:09 +1100 ++ ++ash (0.3.2-3) unstable; urgency=low ++ ++ * Fixed stupid core dump. ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 11 Feb 1998 21:33:55 +1100 ++ ++ash (0.3.2-2) unstable; urgency=low ++ ++ * Hack for special builtins (fixes #18055). ++ * Hack for command. ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 11 Feb 1998 21:19:46 +1100 ++ ++ash (0.3.2-1) unstable; urgency=low ++ ++ * NetBSD-current version as of 19980209. ++ * Fixed a word splitting problem after parameter expansion thanks to Alexey ++ Marinichev. ++ * Converted to debhelper (fixes #14612, #15005). ++ ++ -- Herbert Xu <herbert@debian.org> Mon, 9 Feb 1998 16:53:48 +1100 ++ ++ash (0.3.1-20) unstable; urgency=low ++ ++ * Fixed -e problem with eval. ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 7 Dec 1997 20:19:00 +1100 ++ ++ash (0.3.1-19) unstable; urgency=low ++ ++ * Fixed -e problem with command substitution. ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 7 Dec 1997 19:44:49 +1100 ++ ++ash (0.3.1-18) unstable; urgency=low ++ ++ * Do not link with ncurses (#15485). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 30 Nov 1997 12:00:11 +1100 ++ ++ash (0.3.1-17) unstable; urgency=low ++ ++ * Set PATH like bash (#15238). ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 26 Nov 1997 16:17:27 +1100 ++ ++ash (0.3.1-16) unstable; urgency=low ++ ++ * Fixed incorrect assignment builtin code. ++ ++ -- Herbert Xu <herbert@debian.org> Mon, 24 Nov 1997 16:19:10 +1100 ++ ++ash (0.3.1-15) unstable; urgency=low ++ ++ * hash now returns error codes (needed by the Linux kernel). ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 23 Nov 1997 21:37:08 +1100 ++ ++ash (0.3.1-14) unstable; urgency=low ++ ++ * Disabled word-splitting for assignment builtins. ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 23 Nov 1997 12:45:15 +1100 ++ ++ash (0.3.1-13) unstable; urgency=low ++ ++ * ! is now recognised even after &&/||. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 21 Nov 1997 22:09:05 +1100 ++ ++ash (0.3.1-12) unstable; urgency=low ++ ++ * More fixes to the handling of SIGINT when forking. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 14 Nov 1997 15:14:32 +1100 ++ ++ash (0.3.1-11) unstable; urgency=low ++ ++ * Ignore SIGINT when forking non-interactively. ++ ++ -- Herbert Xu <herbert@debian.org> Mon, 3 Nov 1997 12:00:02 +1100 ++ ++ash (0.3.1-10) unstable; urgency=low ++ ++ * echo now handles options correctly. ++ * echo nolonger returns 0 if erorrs occured while writing to stdout. ++ * New code from GNU echo merged. ++ * Error messages from test now work. ++ ++ -- Herbert Xu <herbert@debian.org> Wed, 8 Oct 1997 21:47:13 +1000 ++ ++ash (0.3.1-9) unstable; urgency=low ++ ++ * ! is recognised at pipeline level like bash. ++ ++ -- Herbert Xu <herbert@debian.org> Mon, 15 Sep 1997 23:13:45 +1000 ++ ++ash (0.3.1-8) unstable; urgency=medium ++ ++ * Old patch regarding SIGCHLD in again. ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 31 Aug 1997 11:20:27 +1000 ++ ++ash (0.3.1-7) unstable; urgency=low ++ ++ * /bin/sh -e is behaving even better now (for loops within conditionals). ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 23 Aug 1997 22:08:19 +1000 ++ ++ash (0.3.1-6) unstable; urgency=low ++ ++ * /bin/sh -e is behaving better now. ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 23 Aug 1997 13:16:26 +1000 ++ ++ash (0.3.1-5) unstable; urgency=low ++ ++ * hash -v /dir/command doesn't coredump anymore. ++ * type /dir/command now works correctly. ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 1 Aug 1997 20:48:19 +1000 ++ ++ash (0.3.1-4) unstable; urgency=low ++ ++ * trap now understands symbolic signal names. ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 26 Jul 1997 14:04:46 +1000 ++ ++ash (0.3.1-3) unstable; urgency=low ++ ++ * Added the builtin test command. ++ ++ -- Herbert Xu <herbert@debian.org> Sun, 20 Jul 1997 15:00:14 +1000 ++ ++ash (0.3.1-2) unstable; urgency=medium ++ ++ * Fixed a coredump involving $*. ++ ++ -- Herbert Xu <herbert@debian.org> Sat, 19 Jul 1997 12:03:02 +1000 ++ ++ash (0.3.1-1) unstable; urgency=medium ++ ++ * NetBSD-current version as of 19970715. ++ * Fixed a "use after free" bug (#11294). ++ ++ -- Herbert Xu <herbert@debian.org> Fri, 18 Jul 1997 13:48:09 +1000 ++ ++ash (0.3-1) unstable; urgency=low ++ ++ * Initial Release. ++ ++ -- Herbert Xu <herbert@debian.org> Thu, 19 Jun 1997 19:29:16 +1000 ++ +diff -urN netbsd-sh/debian/control ash-0.3.7.orig/debian/control +--- netbsd-sh/debian/control Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/control Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,69 @@ ++Source: ash ++Section: shells ++Priority: optional ++Maintainer: Herbert Xu <herbert@debian.org> ++Build-Depends: byacc, debhelper, flex, pmake, groff ++Standards-Version: 3.2.1 ++ ++Package: ash ++Architecture: any ++Pre-Depends: ${shlibs:Depends} ++Description: NetBSD /bin/sh ++ "ash" is a POSIX compliant shell that is much smaller than "bash". ++ We take advantage of that by making it the shell on the installation ++ root floppy, where space is at a premium. ++ . ++ It can be usefully installed as /bin/sh (because it executes scripts ++ somewhat faster than "bash"), or as the default shell either of root ++ or of a second user with a userid of 0 (because it depends on fewer ++ libraries, and is therefore less likely to be affected by an upgrade ++ problem or a disk failure). It is also useful for checking that a ++ script uses only POSIX syntax. ++ . ++ "bash" is a better shell for most users, since it has some nice ++ features absent from "ash", and is a required part of the system. ++ ++Package: ash-medium ++Architecture: any ++Pre-Depends: ${shlibs:Depends} ++Priority: extra ++Description: NetBSD /bin/sh with HETIO ++ This is a slightly bigger version of the standard ash package with a ++ hack that provides primitive history support. It may be useful on ++ boot floppies where space is at a premium, yet users still need the ++ ability to access previous commands in the same session. If you're ++ not a boot floppies maintainer, you should probably go for ash, ++ ash.big (not yet available), or bash. ++ . ++ "ash" is a POSIX compliant shell that is much smaller than "bash". ++ We take advantage of that by making it the shell on the installation ++ root floppy, where space is at a premium. ++ . ++ It can be usefully installed as /bin/sh (because it executes scripts ++ somewhat faster than "bash"), or as the default shell either of root ++ or of a second user with a userid of 0 (because it depends on fewer ++ libraries, and is therefore less likely to be affected by an upgrade ++ problem or a disk failure). It is also useful for checking that a ++ script uses only POSIX syntax. ++ . ++ "bash" is a better shell for most users, since it has some nice ++ features absent from "ash", and is a required part of the system. ++ ++Package: ash-udeb ++Architecture: any ++Section: debian-installer ++Description: NetBSD /bin/sh for boot floppies ++ "ash" is a POSIX compliant shell that is much smaller than "bash". ++ We take advantage of that by making it the shell on the installation ++ root floppy, where space is at a premium. ++ . ++ It can be usefully installed as /bin/sh (because it executes scripts ++ somewhat faster than "bash"), or as the default shell either of root ++ or of a second user with a userid of 0 (because it depends on fewer ++ libraries, and is therefore less likely to be affected by an upgrade ++ problem or a disk failure). It is also useful for checking that a ++ script uses only POSIX syntax. ++ . ++ "bash" is a better shell for most users, since it has some nice ++ features absent from "ash", and is a required part of the system. ++ +diff -urN netbsd-sh/debian/copyright ash-0.3.7.orig/debian/copyright +--- netbsd-sh/debian/copyright Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/copyright Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,18 @@ ++This package was debianized by Mark W. Eichin eichin@kitten.gen.ma.us on ++Mon, 24 Feb 1997 16:00:16 -0500. ++ ++This package was re-ported from NetBSD and debianized by ++Herbert Xu herbert@debian.org on Thu, 19 Jun 1997 19:29:16 +1000. ++ ++It was downloaded from ftp.netbsd.org. ++ ++Copyright: ++ ++Copyright (c) 1991, 1993 ++ The Regents of the University of California. All rights reserved. ++ ++This code is derived from software contributed to Berkeley by Kenneth Almquist. ++ ++Please refer to /usr/share/common-licenses/BSD for details. ++ ++$Id: copyright,v 1.3 2000/08/04 11:48:49 herbert Exp $ +diff -urN netbsd-sh/debian/dirs ash-0.3.7.orig/debian/dirs +--- netbsd-sh/debian/dirs Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/dirs Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,2 @@ ++bin ++usr/share/man/man1 +diff -urN netbsd-sh/debian/rules ash-0.3.7.orig/debian/rules +--- netbsd-sh/debian/rules Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/debian/rules Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,92 @@ ++#!/usr/bin/make -f ++# $Id: rules,v 1.22 2001/01/13 04:23:49 herbert Exp $ ++ ++# Uncomment this to turn on verbose mode. ++#export DH_VERBOSE=1 ++CDEF = -g -O2 -Wall -DBSD=1 -DSMALL -D_GNU_SOURCE \ ++ -DGLOB_BROKEN \ ++ -D__COPYRIGHT\(x\)= -D__RCSID\(x\)= -D_DIAGASSERT\(x\)= ++CDEFSM = -Os -fomit-frame-pointer -Wall -DBSD=1 -DSMALL -D_GNU_SOURCE \ ++ -DGLOB_BROKEN \ ++ -D__COPYRIGHT\(x\)= -D__RCSID\(x\)= -D_DIAGASSERT\(x\)= ++ ++sh.hetio: ++ chmod u+x debian/bsdyacc ++ rm -f *.o ++ pmake CFLAGS='$(CDEF)' HETIO= YACC=`pwd`/debian/bsdyacc ++ mv sh sh.hetio ++ ++sh: ++ chmod u+x debian/bsdyacc ++ rm -f *.o ++ pmake CFLAGS='$(CDEF)' YACC=`pwd`/debian/bsdyacc ++ ++sh.udeb: ++ chmod u+x debian/bsdyacc ++ rm -f *.o ++ pmake CFLAGS='$(CDEFSM)' YACC=`pwd`/debian/bsdyacc ++ mv sh sh.udeb ++ ++build: build-stamp ++build-stamp: sh.hetio sh.udeb sh ++ dh_testdir ++ ++ touch build-stamp ++ ++clean: ++ dh_testdir ++ dh_testroot ++ rm -f build-stamp ++ ++ pmake clean HETIO= ++ rm -f sh.cat1 mksignames signames.h sh.hetio sh.udeb ++ ++ dh_clean ++ ++# Build architecture-independent files here. ++binary-indep: build ++# We have nothing to do by default. ++ ++# Build architecture-dependent files here. ++binary-arch: build ++# dh_testversion ++ dh_testdir ++ dh_testroot ++ dh_clean -k ++ dh_installdirs ++ ++ install sh debian/tmp/bin/ash ++ install -m 644 sh.1 debian/tmp/usr/share/man/man1/ash.1 ++ install sh.hetio debian/ash-medium/usr/bin/ash.medium ++ install -m 644 sh.1 debian/ash-medium/usr/share/man/man1/ash.medium.1 ++ install sh.udeb debian/ash-udeb/bin/ash ++ ln -s ash debian/ash-udeb/bin/sh ++ ++ dh_installdocs -Nash-udeb ++ dh_installexamples ++ dh_installmenu ++# dh_installinit ++ dh_installcron ++# dh_installmanpages ++# dh_undocumented ++ dh_installchangelogs -Nash-udeb ++ dh_strip ++ dh_compress ++ dh_fixperms ++ dh_suidregister ++ dh_installdeb -Nash-udeb ++ dh_shlibdeps ++ dh_gencontrol ++# dh_makeshlibs ++ dh_md5sums ++ dh_builddeb ++ for i in ../ash-udeb_*.deb; do mv $$i $${i%deb}udeb; done ++ sed '/^[^ ]*\.udeb/d; s/^\(ash-udeb_[^ ]*\.\)deb/\1udeb/' \ ++ debian/files > debian/files.new ++ mv debian/files.new debian/files ++ ++source diff: ++ @echo >&2 'source and diff are obsolete - use dpkg-source -b'; false ++ ++binary: binary-indep binary-arch ++.PHONY: build clean binary-indep binary-arch binary + diff --git a/source/ap/ash/patches/ash-echo.patch b/source/ap/ash/patches/ash-echo.patch new file mode 100644 index 000000000..89d93472f --- /dev/null +++ b/source/ap/ash/patches/ash-echo.patch @@ -0,0 +1,91 @@ +diff -urN netbsd-sh/bltin/echo.c ash-0.3.7.orig/bltin/echo.c +--- netbsd-sh/bltin/echo.c Sun Nov 3 13:06:22 1996 ++++ ash-0.3.7.orig/bltin/echo.c Mon Apr 23 22:16:46 2001 +@@ -44,7 +44,13 @@ + + #define main echocmd + ++#ifdef _GNU_SOURCE ++#include <stdio.h> ++ ++#include "../mystring.h" ++#else + #include "bltin.h" ++#endif + + /* #define eflag 1 */ + +@@ -53,7 +59,6 @@ + register char **ap; + register char *p; + register char c; +- int count; + int nflag = 0; + #ifndef eflag + int eflag = 0; +@@ -62,21 +67,26 @@ + ap = argv; + if (argc) + ap++; +- if ((p = *ap) != NULL) { ++ while ((p = *ap) != NULL && *p == '-') { + if (equal(p, "-n")) { +- nflag++; +- ap++; ++ nflag = 1; + } else if (equal(p, "-e")) { + #ifndef eflag +- eflag++; ++ eflag = 1; ++#endif ++ } else if (equal(p, "-E")) { ++#ifndef eflag ++ eflag = 0; + #endif +- ap++; + } ++ else break; ++ ap++; + } + while ((p = *ap++) != NULL) { + while ((c = *p++) != '\0') { + if (c == '\\' && eflag) { +- switch (*p++) { ++ switch (c = *p++) { ++ case 'a': c = '\007'; break; + case 'b': c = '\b'; break; + case 'c': return 0; /* exit */ + case 'f': c = '\f'; break; +@@ -85,11 +95,13 @@ + case 't': c = '\t'; break; + case 'v': c = '\v'; break; + case '\\': break; /* c = '\\' */ +- case '0': +- c = 0; +- count = 3; +- while (--count >= 0 && (unsigned)(*p - '0') < 8) +- c = (c << 3) + (*p++ - '0'); ++ case '0': case '1': case '2': case '3': ++ case '4': case '5': case '6': case '7': ++ c -= '0'; ++ if (*p >= '0' && *p <= '7') ++ c = c * 8 + (*p++ - '0'); ++ if (*p >= '0' && *p <= '7') ++ c = c * 8 + (*p++ - '0'); + break; + default: + p--; +@@ -103,5 +115,12 @@ + } + if (! nflag) + putchar('\n'); ++#ifdef _GNU_SOURCE ++ fflush(stdout); ++ if (ferror(stdout)) { ++ clearerr(stdout); ++ return 1; ++ } ++#endif + return 0; + } + diff --git a/source/ap/ash/patches/ash-freebsd.patch b/source/ap/ash/patches/ash-freebsd.patch new file mode 100644 index 000000000..b0b114470 --- /dev/null +++ b/source/ap/ash/patches/ash-freebsd.patch @@ -0,0 +1,60 @@ +diff -ur ash-0.4.0/bltin/echo.c ash-0.4.0+free/bltin/echo.c +--- ash-0.4.0/bltin/echo.c Tue Apr 24 02:03:56 2001 ++++ ash-0.4.0+free/bltin/echo.c Tue Apr 24 01:43:15 2001 +@@ -89,6 +89,7 @@ + case 'a': c = '\007'; break; + case 'b': c = '\b'; break; + case 'c': return 0; /* exit */ ++ case 'e': c = '\033'; break; + case 'f': c = '\f'; break; + case 'n': c = '\n'; break; + case 'r': c = '\r'; break; +diff -ur ash-0.4.0/cd.c ash-0.4.0+free/cd.c +--- ash-0.4.0/cd.c Tue Apr 24 02:03:56 2001 ++++ ash-0.4.0+free/cd.c Tue Apr 24 01:43:57 2001 +@@ -244,6 +244,7 @@ + curdir = NULL; + getpwd(); + setvar("PWD", curdir, VEXPORT|VTEXTFIXED); ++ setvar("OLDPWD", prevdir, VEXPORT|VTEXTFIXED); + INTON; + return; + } +@@ -275,6 +276,7 @@ + prevdir = curdir; + curdir = savestr(stackblock()); + setvar("PWD", curdir, VEXPORT|VTEXTFIXED); ++ setvar("OLDPWD", prevdir, VEXPORT|VTEXTFIXED); + INTON; + } + +diff -ur ash-0.4.0/main.c ash-0.4.0+free/main.c +--- ash-0.4.0/main.c Tue Apr 24 02:03:57 2001 ++++ ash-0.4.0+free/main.c Tue Apr 24 02:03:26 2001 +@@ -115,6 +115,9 @@ + struct stackmark smark; + volatile int state; + char *shinit; ++ int priviliged; ++ ++ priviliged = getuid() != geteuid() || getgid() != getegid(); + + #if PROFILE + monitor(4, etext, profile_buf, sizeof profile_buf, 50); +@@ -188,11 +191,14 @@ + read_profile("/etc/profile"); + state1: + state = 2; +- read_profile(".profile"); ++ if (priviliged == 0) ++ read_profile(".profile"); ++ else ++ read_profile("/etc/suid_profile"); + } + state2: + state = 3; +- if (getuid() == geteuid() && getgid() == getegid()) { ++ if (iflag && !priviliged) { + if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') { + state = 3; + read_profile(shinit); diff --git a/source/ap/ash/patches/ash-getcwd.patch b/source/ap/ash/patches/ash-getcwd.patch new file mode 100644 index 000000000..f98f487e3 --- /dev/null +++ b/source/ap/ash/patches/ash-getcwd.patch @@ -0,0 +1,13 @@ +diff -urN netbsd-sh/cd.c ash-0.3.7.orig/cd.c +--- netbsd-sh/cd.c Fri Jul 9 13:02:05 1999 ++++ ash-0.3.7.orig/cd.c Mon Apr 23 22:16:46 2001 +@@ -319,7 +319,7 @@ + * c implementation of getcwd, that does not open a pipe to + * /bin/pwd. + */ +-#if defined(__NetBSD__) || defined(__SVR4) ++#if defined(__NetBSD__) || defined(__SVR4) || defined(__GLIBC__) + + if (getcwd(buf, sizeof(buf)) == NULL) { + char *pwd = getenv("PWD"); + diff --git a/source/ap/ash/patches/ash-getopt.patch b/source/ap/ash/patches/ash-getopt.patch new file mode 100644 index 000000000..df88ba0df --- /dev/null +++ b/source/ap/ash/patches/ash-getopt.patch @@ -0,0 +1,198 @@ +diff -urN netbsd-sh/options.c ash-0.3.7.orig/options.c +--- netbsd-sh/options.c Fri Jul 9 13:02:07 1999 ++++ ash-0.3.7.orig/options.c Mon Apr 23 22:16:46 2001 +@@ -79,7 +79,7 @@ + STATIC void options __P((int)); + STATIC void minus_o __P((char *, int)); + STATIC void setoption __P((int, int)); +-STATIC int getopts __P((char *, char *, char **, char ***, char **)); ++STATIC int getopts __P((char *, char *, char **, int *, int *)); + + + /* +@@ -118,7 +118,8 @@ + arg0 = *argptr++; + + shellparam.p = argptr; +- shellparam.reset = 1; ++ shellparam.optind = 1; ++ shellparam.optoff = -1; + /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */ + while (*argptr) { + shellparam.nparam++; +@@ -282,7 +283,8 @@ + shellparam.malloc = 1; + shellparam.nparam = nparam; + shellparam.p = newparam; +- shellparam.optnext = NULL; ++ shellparam.optind = 1; ++ shellparam.optoff = -1; + } + + +@@ -330,7 +332,8 @@ + } + ap2 = shellparam.p; + while ((*ap2++ = *ap1++) != NULL); +- shellparam.optnext = NULL; ++ shellparam.optind = 1; ++ shellparam.optoff = -1; + INTON; + return 0; + } +@@ -363,10 +366,8 @@ + getoptsreset(value) + const char *value; + { +- if (number(value) == 1) { +- shellparam.optnext = NULL; +- shellparam.reset = 1; +- } ++ shellparam.optind = number(value); ++ shellparam.optoff = -1; + } + + /* +@@ -385,50 +386,58 @@ + + if (argc < 3) + error("Usage: getopts optstring var [arg]"); +- else if (argc == 3) ++ else if (argc == 3) { + optbase = shellparam.p; +- else ++ if (shellparam.optind > shellparam.nparam + 1) { ++ shellparam.optind = 1; ++ shellparam.optoff = -1; ++ } ++ } ++ else { + optbase = &argv[3]; +- +- if (shellparam.reset == 1) { +- shellparam.optnext = optbase; +- shellparam.optptr = NULL; +- shellparam.reset = 0; ++ if (shellparam.optind > argc - 2) { ++ shellparam.optind = 1; ++ shellparam.optoff = -1; ++ } + } + +- return getopts(argv[1], argv[2], optbase, &shellparam.optnext, +- &shellparam.optptr); ++ return getopts(argv[1], argv[2], optbase, &shellparam.optind, ++ &shellparam.optoff); + } + + STATIC int +-getopts(optstr, optvar, optfirst, optnext, optpptr) ++getopts(optstr, optvar, optfirst, optind, optoff) + char *optstr; + char *optvar; + char **optfirst; +- char ***optnext; +- char **optpptr; ++ int *optind; ++ int *optoff; + { + char *p, *q; + char c = '?'; + int done = 0; +- int ind = 0; + int err = 0; + char s[10]; ++ char **optnext = optfirst + *optind - 1; + +- if ((p = *optpptr) == NULL || *p == '\0') { ++ if (*optind <= 1 || *optoff < 0 || !(*(optnext - 1)) || ++ strlen(*(optnext - 1)) < *optoff) ++ p = NULL; ++ else ++ p = *(optnext - 1) + *optoff; ++ if (p == NULL || *p == '\0') { + /* Current word is done, advance */ +- if (*optnext == NULL) ++ if (optnext == NULL) + return 1; +- p = **optnext; ++ p = *optnext; + if (p == NULL || *p != '-' || *++p == '\0') { + atend: +- ind = *optnext - optfirst + 1; +- *optnext = NULL; ++ *optind = optnext - optfirst + 1; + p = NULL; + done = 1; + goto out; + } +- (*optnext)++; ++ optnext++; + if (p[0] == '-' && p[1] == '\0') /* check for "--" */ + goto atend; + } +@@ -453,7 +462,7 @@ + } + + if (*++q == ':') { +- if (*p == '\0' && (p = **optnext) == NULL) { ++ if (*p == '\0' && (p = *optnext) == NULL) { + if (optstr[0] == ':') { + s[0] = c; + s[1] = '\0'; +@@ -468,30 +477,29 @@ + goto bad; + } + +- if (p == **optnext) +- (*optnext)++; ++ if (p == *optnext) ++ optnext++; + setvarsafe("OPTARG", p, 0); + p = NULL; + } + else + setvarsafe("OPTARG", "", 0); +- ind = *optnext - optfirst + 1; ++ *optind = optnext - optfirst + 1; + goto out; + + bad: +- ind = 1; +- *optnext = NULL; ++ *optind = 1; + p = NULL; + out: +- *optpptr = p; +- fmtstr(s, sizeof(s), "%d", ind); ++ *optoff = p ? p - *(optnext - 1) : -1; ++ fmtstr(s, sizeof(s), "%d", *optind); + err |= setvarsafe("OPTIND", s, VNOFUNC); + s[0] = c; + s[1] = '\0'; + err |= setvarsafe(optvar, s, 0); + if (err) { +- *optnext = NULL; +- *optpptr = NULL; ++ *optind = 1; ++ *optoff = -1; + flushall(); + exraise(EXERROR); + } +diff -urN netbsd-sh/options.h ash-0.3.7.orig/options.h +--- netbsd-sh/options.h Fri Jul 9 13:02:07 1999 ++++ ash-0.3.7.orig/options.h Mon Apr 23 22:16:46 2001 +@@ -41,10 +41,9 @@ + struct shparam { + int nparam; /* # of positional parameters (without $0) */ + unsigned char malloc; /* if parameter list dynamically allocated */ +- unsigned char reset; /* if getopts has been reset */ + char **p; /* parameter list */ +- char **optnext; /* next parameter to be processed by getopts */ +- char *optptr; /* used by getopts */ ++ int optind; /* next parameter to be processed by getopts */ ++ int optoff; /* used by getopts */ + }; + + + diff --git a/source/ap/ash/patches/ash-glob.patch b/source/ap/ash/patches/ash-glob.patch new file mode 100644 index 000000000..70013536e --- /dev/null +++ b/source/ap/ash/patches/ash-glob.patch @@ -0,0 +1,445 @@ +diff -urN netbsd-sh/expand.c ash-0.3.7.orig/expand.c +--- netbsd-sh/expand.c Tue Mar 14 13:03:45 2000 ++++ ash-0.3.7.orig/expand.c Mon Apr 23 22:16:46 2001 +@@ -54,6 +54,10 @@ + #include <pwd.h> + #include <stdlib.h> + #include <stdio.h> ++#if defined(__GLIBC__) && !defined(GLOB_BROKEN) ++#include <fnmatch.h> ++#include <glob.h> ++#endif + + /* + * Routines to expand arguments to commands. We have to deal with +@@ -102,17 +106,30 @@ + STATIC int subevalvar __P((char *, char *, int, int, int, int)); + STATIC char *evalvar __P((char *, int)); + STATIC int varisset __P((char *, int)); ++STATIC char *strtodest __P((char *, int, int)); + STATIC void varvalue __P((char *, int, int)); + STATIC void recordregion __P((int, int, int)); + STATIC void removerecordregions __P((int)); + STATIC void ifsbreakup __P((char *, struct arglist *)); + STATIC void ifsfree __P((void)); + STATIC void expandmeta __P((struct strlist *, int)); ++#if defined(__GLIBC__) && !defined(GLOB_BROKEN) ++STATIC const char *preglob __P((const char *)); ++STATIC void addglob __P((const glob_t *)); ++#else + STATIC void expmeta __P((char *, char *)); ++#endif + STATIC void addfname __P((char *)); ++#if defined(__GLIBC__) && !defined(GLOB_BROKEN) ++STATIC int patmatch __P((char *, char *, int)); ++STATIC int patmatch2 __P((char *, char *, int)); ++STATIC char * _rmescapes __P((char *, int)); ++#else + STATIC struct strlist *expsort __P((struct strlist *)); + STATIC struct strlist *msort __P((struct strlist *, int)); + STATIC int pmatch __P((char *, char *, int)); ++#define patmatch2 patmatch ++#endif + STATIC char *cvtnum __P((int, char *)); + + /* +@@ -371,7 +388,7 @@ + * have to rescan starting from the beginning since CTLESC + * characters have to be processed left to right. + */ +- CHECKSTRSPACE(8, expdest); ++ CHECKSTRSPACE(10, expdest); + USTPUTC('\0', expdest); + start = stackblock(); + p = expdest - 1; +@@ -393,7 +410,7 @@ + if (quotes) + rmescapes(p+2); + result = arith(p+2); +- fmtstr(p, 10, "%d", result); ++ fmtstr(p, 12, "%d", result); + + while (*p++) + ; +@@ -503,7 +520,7 @@ + int amount; + + herefd = -1; +- argstr(p, 0); ++ argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0); + STACKSTRNUL(expdest); + herefd = saveherefd; + argbackq = saveargbackq; +@@ -535,7 +552,7 @@ + for (loc = startp; loc < str; loc++) { + c = *loc; + *loc = '\0'; +- if (patmatch(str, startp, varflags & VSQUOTE)) ++ if (patmatch2(str, startp, varflags & VSQUOTE)) + goto recordleft; + *loc = c; + if ((varflags & VSQUOTE) && *loc == CTLESC) +@@ -547,7 +564,7 @@ + for (loc = str - 1; loc >= startp;) { + c = *loc; + *loc = '\0'; +- if (patmatch(str, startp, varflags & VSQUOTE)) ++ if (patmatch2(str, startp, varflags & VSQUOTE)) + goto recordleft; + *loc = c; + loc--; +@@ -564,7 +581,7 @@ + + case VSTRIMRIGHT: + for (loc = str - 1; loc >= startp;) { +- if (patmatch(str, loc, varflags & VSQUOTE)) ++ if (patmatch2(str, loc, varflags & VSQUOTE)) + goto recordright; + loc--; + if ((varflags & VSQUOTE) && loc > startp && +@@ -580,7 +597,7 @@ + + case VSTRIMRIGHTMAX: + for (loc = startp; loc < str - 1; loc++) { +- if (patmatch(str, loc, varflags & VSQUOTE)) ++ if (patmatch2(str, loc, varflags & VSQUOTE)) + goto recordright; + if ((varflags & VSQUOTE) && *loc == CTLESC) + loc++; +@@ -819,6 +836,34 @@ + + + /* ++ * Put a string on the stack. ++ */ ++ ++STATIC char * ++strtodest(p, quoted, allow_split) ++ char *p; ++ int quoted; ++ int allow_split; ++{ ++ char const *syntax; ++ ++ if (allow_split) { ++ syntax = quoted ? DQSYNTAX : BASESYNTAX; ++ while (*p) { ++ if (syntax[(int) *p] == CCTL) ++ STPUTC(CTLESC, expdest); ++ STPUTC(*p++, expdest); ++ } ++ } else ++ while (*p) ++ STPUTC(*p++, expdest); ++ ++ return p; ++} ++ ++ ++ ++/* + * Add the value of a specialized variable to the stack string. + */ + +@@ -834,22 +879,6 @@ + extern int oexitstatus; + char sep; + char **ap; +- char const *syntax; +- +-#define STRTODEST(p) \ +- do {\ +- if (allow_split) { \ +- syntax = quoted? DQSYNTAX : BASESYNTAX; \ +- while (*p) { \ +- if (syntax[(int)*p] == CCTL) \ +- STPUTC(CTLESC, expdest); \ +- STPUTC(*p++, expdest); \ +- } \ +- } else \ +- while (*p) \ +- STPUTC(*p++, expdest); \ +- } while (0) +- + + switch (*name) { + case '$': +@@ -875,7 +904,7 @@ + case '@': + if (allow_split && quoted) { + for (ap = shellparam.p ; (p = *ap++) != NULL ; ) { +- STRTODEST(p); ++ p = strtodest(p, quoted, allow_split); + if (*ap) + STPUTC('\0', expdest); + } +@@ -888,21 +917,20 @@ + else + sep = ' '; + for (ap = shellparam.p ; (p = *ap++) != NULL ; ) { +- STRTODEST(p); ++ p = strtodest(p, quoted, allow_split); + if (*ap && sep) + STPUTC(sep, expdest); + } + break; + case '0': +- p = arg0; +- STRTODEST(p); ++ p = strtodest(arg0, quoted, allow_split); + break; + default: + if (is_digit(*name)) { + num = atoi(name); + if (num > 0 && num <= shellparam.nparam) { +- p = shellparam.p[num - 1]; +- STRTODEST(p); ++ p = strtodest(shellparam.p[num - 1], quoted, ++ allow_split); + } + } + break; +@@ -1054,6 +1082,98 @@ + * should be escapes. The results are stored in the list exparg. + */ + ++#if defined(__GLIBC__) && !defined(GLOB_BROKEN) ++STATIC void ++expandmeta(str, flag) ++ struct strlist *str; ++ int flag; ++{ ++ const char *p; ++ glob_t pglob; ++ /* TODO - EXP_REDIR */ ++ ++ while (str) { ++ if (fflag) ++ goto nometa; ++ p = preglob(str->text); ++ INTOFF; ++ switch (glob(p, GLOB_NOMAGIC, 0, &pglob)) { ++ case 0: ++ if (!(pglob.gl_flags & GLOB_MAGCHAR)) ++ goto nometa2; ++ addglob(&pglob); ++ globfree(&pglob); ++ INTON; ++ break; ++ case GLOB_NOMATCH: ++nometa2: ++ globfree(&pglob); ++ INTON; ++nometa: ++ *exparg.lastp = str; ++ rmescapes(str->text); ++ exparg.lastp = &str->next; ++ break; ++ default: /* GLOB_NOSPACE */ ++ error("Out of space"); ++ } ++ str = str->next; ++ } ++} ++ ++ ++/* ++ * Prepare the string for glob(3). ++ */ ++ ++STATIC const char * ++preglob(str) ++ const char *str; ++{ ++ const char *p; ++ char *q, *r; ++ size_t len; ++ ++ p = str; ++ while (*p != CTLQUOTEMARK && *p != CTLESC) { ++ if (*p++ == '\0') ++ return str; ++ } ++ len = p - str; ++ q = r = stalloc(strlen(str) + 1); ++ if (len > 0) { ++ memcpy(q, str, len); ++ q += len; ++ } ++ do { ++ if (*p == CTLQUOTEMARK) ++ continue; ++ if (*p == CTLESC) { ++ if (*++p != '/') ++ *q++ = '\\'; ++ } ++ *q++ = *p; ++ } while (*++p); ++ *q = '\0'; ++ return r; ++} ++ ++ ++/* ++ * Add the result of glob(3) to the list. ++ */ ++ ++STATIC void ++addglob(pglob) ++ const glob_t *pglob; ++{ ++ char **p = pglob->gl_pathv; ++ ++ do { ++ addfname(*p); ++ } while (*++p); ++} ++#else + char *expdir; + + +@@ -1238,6 +1358,7 @@ + if (! atend) + endname[-1] = '/'; + } ++#endif + + + /* +@@ -1260,6 +1381,7 @@ + } + + ++#if !(defined(__GLIBC__) && !defined(GLOB_BROKEN)) + /* + * Sort the results of file name expansion. It calculates the number of + * strings to sort and then calls msort (short for merge sort) to do the +@@ -1321,6 +1443,7 @@ + } + return list; + } ++#endif + + + +@@ -1328,6 +1451,39 @@ + * Returns true if the pattern matches the string. + */ + ++#if defined(__GLIBC__) && !defined(GLOB_BROKEN) ++STATIC int ++patmatch(pattern, string, squoted) ++ char *pattern; ++ char *string; ++ int squoted; /* string might have quote chars */ ++ { ++ const char *p; ++ char *q; ++ ++ p = preglob(pattern); ++ q = squoted ? _rmescapes(string, 1) : string; ++ ++ return !fnmatch(p, q, 0); ++} ++ ++ ++STATIC int ++patmatch2(pattern, string, squoted) ++ char *pattern; ++ char *string; ++ int squoted; /* string might have quote chars */ ++ { ++ char *p; ++ int res; ++ ++ sstrnleft--; ++ p = grabstackstr(expdest); ++ res = patmatch(pattern, string, squoted); ++ ungrabstackstr(p, expdest); ++ return res; ++} ++#else + int + patmatch(pattern, string, squoted) + char *pattern; +@@ -1462,6 +1618,7 @@ + return 0; + return 1; + } ++#endif + + + +@@ -1469,6 +1626,50 @@ + * Remove any CTLESC characters from a string. + */ + ++#if defined(__GLIBC__) && !defined(GLOB_BROKEN) ++void ++rmescapes(str) ++ char *str; ++{ ++ _rmescapes(str, 0); ++} ++ ++ ++STATIC char * ++_rmescapes(str, flag) ++ char *str; ++ int flag; ++{ ++ char *p, *q, *r; ++ ++ p = str; ++ while (*p != CTLESC && *p != CTLQUOTEMARK) { ++ if (*p++ == '\0') ++ return str; ++ } ++ q = p; ++ r = str; ++ if (flag) { ++ size_t len = p - str; ++ q = r = stalloc(strlen(p) + len + 1); ++ if (len > 0) { ++ memcpy(q, str, len); ++ q += len; ++ } ++ } ++ while (*p) { ++ if (*p == CTLQUOTEMARK) { ++ p++; ++ continue; ++ } ++ if (*p == CTLESC) ++ p++; ++ *q++ = *p++; ++ } ++ *q = '\0'; ++ return r; ++} ++#else + void + rmescapes(str) + char *str; +@@ -1492,6 +1693,7 @@ + } + *q = '\0'; + } ++#endif + + + + +diff -urN netbsd-sh/expand.h ash-0.3.7.orig/expand.h +--- netbsd-sh/expand.h Fri Jul 9 13:02:06 1999 ++++ ash-0.3.7.orig/expand.h Mon Apr 23 22:16:46 2001 +@@ -64,7 +64,9 @@ + void expandhere __P((union node *, int)); + void expandarg __P((union node *, struct arglist *, int)); + void expari __P((int)); ++#if !(defined(__GLIBC__) && !defined(GLOB_BROKEN)) + int patmatch __P((char *, char *, int)); ++#endif + void rmescapes __P((char *)); + int casematch __P((union node *, char *)); + diff --git a/source/ap/ash/patches/ash-hetio.patch b/source/ap/ash/patches/ash-hetio.patch new file mode 100644 index 000000000..c416cde53 --- /dev/null +++ b/source/ap/ash/patches/ash-hetio.patch @@ -0,0 +1,559 @@ +diff -urN ash-0.4.0/Makefile ash-0.4.0-/Makefile +--- ash-0.4.0/Makefile Tue Apr 24 00:57:33 2001 ++++ ash-0.4.0-/Makefile Tue Apr 24 00:59:53 2001 +@@ -7,7 +7,7 @@ + SHSRCS= alias.c cd.c echo.c error.c eval.c exec.c expand.c \ + histedit.c input.c jobs.c mail.c main.c memalloc.c miscbltin.c \ + mystring.c options.c parser.c redir.c show.c trap.c output.c var.c \ +- test.c setmode.c test.c ++ test.c setmode.c test.c hetio.c + GENSRCS=builtins.c builtins.h init.c nodes.c arith.c arith.h lex.yy.c \ + nodes.h syntax.c syntax.h token.h signames.c + SRCS= ${SHSRCS} ${GENSRCS} +@@ -17,12 +17,13 @@ + mystring.o options.o output.o parser.o redir.o show.o \ + trap.o var.o bltin/test.o signames.o \ + builtins.o init.o nodes.o syntax.o arith.o lex.yy.o \ +- setmode.o bltin/times.o ++ setmode.o bltin/times.o hetio.o + + OPT_FLAGS=-O2 -g + LDFLAGS=-g + CFLAGS=$(OPT_FLAGS) -DSHELL -I. -DNO_HISTORY -DBSD=1 -DSMALL -D_GNU_SOURCE \ +- -DGLOB_BROKEN -D__COPYRIGHT\(x\)= -D__RCSID\(x\)= -D_DIAGASSERT\(x\)= ++ -DGLOB_BROKEN -D__COPYRIGHT\(x\)= -D__RCSID\(x\)= -D_DIAGASSERT\(x\)= \ ++ -DHETIO + + all: $(PROG) + +diff -urN ash-0.4.0/hetio.c ash-0.4.0-/hetio.c +--- ash-0.4.0/hetio.c Thu Jan 1 01:00:00 1970 ++++ ash-0.4.0-/hetio.c Tue Apr 24 01:06:59 2001 +@@ -0,0 +1,377 @@ ++/* ++ * Termios command line History and Editting for NetBSD sh (ash) ++ * Copyright (c) 1999 ++ * Main code: Adam Rogoyski <rogoyski@cs.utexas.edu> ++ * Etc: Dave Cinege <dcinege@psychosis.com> ++ * ++ * You may use this code as you wish, so long as the original author(s) ++ * are attributed in any redistributions of the source code. ++ * This code is 'as is' with no warranty. ++ * This code may safely be consumed by a BSD or GPL license. ++ * ++ * v 0.5 19990328 Initial release ++ * ++ * Future plans: Simple file and path name completion. (like BASH) ++ * ++ */ ++ ++/* ++Usage and Known bugs: ++ Terminal key codes are not extensive, and more will probably ++ need to be added. This version was created on Debian GNU/Linux 2.x. ++ Delete, Backspace, Home, End, and the arrow keys were tested ++ to work in an Xterm and console. Ctrl-A also works as Home. ++ Ctrl-E also works as End. The binary size increase is <3K. ++ ++ Editting will not display correctly for lines greater then the ++ terminal width. (more then one line.) However, history will. ++*/ ++ ++#include <stdio.h> ++#include <unistd.h> ++#include <stdlib.h> ++#include <string.h> ++#include <termios.h> ++#include <ctype.h> ++#include <sys/ioctl.h> ++ ++#include "input.h" ++#include "output.h" ++ ++#ifdef HETIO ++ ++#include "hetio.h" ++ ++ ++#define MAX_HISTORY 15 /* Maximum length of the linked list for the command line history */ ++ ++#define ESC 27 ++#define DEL 127 ++ ++static struct history *his_front = NULL; /* First element in command line list */ ++static struct history *his_end = NULL; /* Last element in command line list */ ++static struct termios old_term, new_term; /* Current termio and the previous termio before starting ash */ ++ ++static int history_counter = 0; /* Number of commands in history list */ ++static int reset_term = 0; /* Set to true if the terminal needs to be reset upon exit */ ++static int hetio_inter = 0; ++ ++struct history ++{ ++ char *s; ++ struct history *p; ++ struct history *n; ++}; ++ ++ ++void input_delete (int); ++void input_home (int *); ++void input_end (int *, int); ++void input_backspace (int *, int *); ++ ++ ++ ++void hetio_init(void) ++{ ++ hetio_inter = 1; ++} ++ ++ ++void hetio_reset_term(void) ++{ ++ if (reset_term) ++ tcsetattr(1, TCSANOW, &old_term); ++} ++ ++ ++void setIO(struct termios *new, struct termios *old) /* Set terminal IO to canonical mode, and save old term settings. */ ++{ ++ tcgetattr(0, old); ++ memcpy(new, old, sizeof(*new)); ++ new->c_cc[VMIN] = 1; ++ new->c_cc[VTIME] = 0; ++ new->c_lflag &= ~ICANON; /* unbuffered input */ ++ new->c_lflag &= ~ECHO; ++ tcsetattr(0, TCSANOW, new); ++} ++ ++void input_home(int *cursor) /* Command line input routines */ ++{ ++ while (*cursor > 0) { ++ out1c('\b'); ++ --*cursor; ++ } ++ flushout(&output); ++} ++ ++ ++void input_delete(int cursor) ++{ ++ int j = 0; ++ ++ memmove(parsenextc + cursor, parsenextc + cursor + 1, ++ BUFSIZ - cursor - 1); ++ for (j = cursor; j < (BUFSIZ - 1); j++) { ++ if (!*(parsenextc + j)) ++ break; ++ else ++ out1c(*(parsenextc + j)); ++ } ++ ++ out1str(" \b"); ++ ++ while (j-- > cursor) ++ out1c('\b'); ++ flushout(&output); ++} ++ ++ ++void input_end(int *cursor, int len) ++{ ++ while (*cursor < len) { ++ out1str("\033[C"); ++ ++*cursor; ++ } ++ flushout(&output); ++} ++ ++ ++void ++input_backspace(int *cursor, int *len) ++{ ++ int j = 0; ++ ++ if (*cursor > 0) { ++ out1str("\b \b"); ++ --*cursor; ++ memmove(parsenextc + *cursor, parsenextc + *cursor + 1, ++ BUFSIZ - *cursor + 1); ++ ++ for (j = *cursor; j < (BUFSIZ - 1); j++) { ++ if (!*(parsenextc + j)) ++ break; ++ else ++ out1c(*(parsenextc + j)); ++ } ++ ++ out1str(" \b"); ++ ++ while (j-- > *cursor) ++ out1c('\b'); ++ ++ --*len; ++ flushout(&output); ++ } ++} ++ ++int hetio_read_input(int fd) ++{ ++ int nr = 0; ++ ++ if (!hetio_inter) { /* Are we an interactive shell? */ ++ return -255; ++ } else { ++ int len = 0; ++ int j = 0; ++ int cursor = 0; ++ int break_out = 0; ++ int ret = 0; ++ char c = 0; ++ struct history *hp = his_end; ++ ++ if (!reset_term) { ++ setIO(&new_term, &old_term); ++ reset_term = 1; ++ } else { ++ tcsetattr(0, TCSANOW, &new_term); ++ } ++ ++ memset(parsenextc, 0, BUFSIZ); ++ ++ while (1) { ++ if ((ret = read(fd, &c, 1)) < 1) ++ return ret; ++ ++ switch (c) { ++ case 1: /* Control-A Beginning of line */ ++ input_home(&cursor); ++ break; ++ case 5: /* Control-E EOL */ ++ input_end(&cursor, len); ++ break; ++ case 4: /* Control-D */ ++#ifndef CTRL_D_DELETE ++ return 0; ++#else ++ if (cursor != len) { ++ input_delete(cursor); ++ len--; ++ } ++ break; ++#endif ++ case '\b': /* Backspace */ ++ case DEL: ++ input_backspace(&cursor, &len); ++ break; ++ case '\n': /* Enter */ ++ *(parsenextc + len++ + 1) = c; ++ out1c(c); ++ flushout(&output); ++ break_out = 1; ++ break; ++ case ESC: /* escape sequence follows */ ++ if ((ret = read(fd, &c, 1)) < 1) ++ return ret; ++ ++ if (c == '[' || c == 'O' ) { /* 91 */ ++ if ((ret = read(fd, &c, 1)) < 1) ++ return ret; ++ ++ switch (c) { ++ case 'A': ++ if (hp && hp->p) { /* Up */ ++ hp = hp->p; ++ goto hop; ++ } ++ break; ++ case 'B': ++ if (hp && hp->n && hp->n->s) { /* Down */ ++ hp = hp->n; ++ goto hop; ++ } ++ break; ++ ++hop: /* hop */ ++ len = strlen(parsenextc); ++ ++ for (; cursor > 0; cursor--) /* return to begining of line */ ++ out1c('\b'); ++ ++ for (j = 0; j < len; j++) /* erase old command */ ++ out1c(' '); ++ ++ for (j = len; j > 0; j--) /* return to begining of line */ ++ out1c('\b'); ++ ++ strcpy (parsenextc, hp->s); /* write new command */ ++ len = strlen (hp->s); ++ out1str(parsenextc); ++ flushout(&output); ++ cursor = len; ++ break; ++ case 'C': /* Right */ ++ if (cursor < len) { ++ out1str("\033[C"); ++ cursor++; ++ flushout(&output); ++ } ++ break; ++ case 'D': /* Left */ ++ if (cursor > 0) { ++ out1str("\033[D"); ++ cursor--; ++ flushout(&output); ++ } ++ break; ++ case '3': /* Delete */ ++ if (cursor != len) { ++ input_delete(cursor); ++ len--; ++ } ++ break; ++ case 'H': /* Home (xterm) */ ++ case '1': /* Home (Ctrl-A) */ ++ input_home(&cursor); ++ break; ++ case 'F': /* End (xterm_ */ ++ case '4': /* End (Ctrl-E) */ ++ input_end(&cursor, len); ++ break; ++ } ++ if (c == '1' || c == '3' || c == '4') ++ if ((ret = read(fd, &c, 1)) < 1) ++ return ret; /* read 126 (~) */ ++ } ++ ++ c = 0; ++ break; ++ ++ default: /* If it's regular input, do the normal thing */ ++ ++ if (!isprint(c)) /* Skip non-printable characters */ ++ break; ++ ++ if (len >= (BUFSIZ - 2)) /* Need to leave space for enter */ ++ break; ++ ++ len++; ++ ++ if (cursor == (len - 1)) { /* Append if at the end of the line */ ++ *(parsenextc + cursor) = c; ++ } else { /* Insert otherwise */ ++ memmove(parsenextc + cursor + 1, parsenextc + cursor, ++ len - cursor - 1); ++ ++ *(parsenextc + cursor) = c; ++ ++ for (j = cursor; j < len; j++) ++ out1c(*(parsenextc + j)); ++ for (; j > cursor; j--) ++ out1str("\033[D"); ++ } ++ ++ cursor++; ++ out1c(c); ++ flushout(&output); ++ break; ++ } ++ ++ if (break_out) /* Enter is the command terminator, no more input. */ ++ break; ++ } ++ ++ nr = len + 1; ++ tcsetattr(0, TCSANOW, &old_term); ++ ++ ++ if (*(parsenextc)) { /* Handle command history log */ ++ struct history *h = his_end; ++ ++ if (!h) { /* No previous history */ ++ h = his_front = malloc(sizeof (struct history)); ++ h->n = malloc(sizeof (struct history)); ++ h->p = NULL; ++ h->s = strdup(parsenextc); ++ ++ h->n->p = h; ++ h->n->n = NULL; ++ h->n->s = NULL; ++ his_end = h->n; ++ history_counter++; ++ } else { /* Add a new history command */ ++ ++ h->n = malloc(sizeof (struct history)); ++ ++ h->n->p = h; ++ h->n->n = NULL; ++ h->n->s = NULL; ++ h->s = strdup(parsenextc); ++ his_end = h->n; ++ ++ if (history_counter >= MAX_HISTORY) { /* After max history, remove the last known command */ ++ struct history *p = his_front->n; ++ ++ p->p = NULL; ++ free(his_front->s); ++ free(his_front); ++ his_front = p; ++ } else { ++ history_counter++; ++ } ++ } ++ } ++ } ++ ++ return nr; ++} ++#endif +diff -urN ash-0.4.0/hetio.h ash-0.4.0-/hetio.h +--- ash-0.4.0/hetio.h Thu Jan 1 01:00:00 1970 ++++ ash-0.4.0-/hetio.h Tue Apr 24 00:13:57 2001 +@@ -0,0 +1,22 @@ ++/* ++ * Termios command line History and Editting for NetBSD sh (ash) ++ * Copyright (c) 1999 ++ * Main code: Adam Rogoyski <rogoyski@cs.utexas.edu> ++ * Etc: Dave Cinege <dcinege@psychosis.com> ++ * ++ * You may use this code as you wish, so long as the original author(s) ++ * are attributed in any redistributions of the source code. ++ * This code is 'as is' with no warranty. ++ * This code may safely be consumed by a BSD or GPL license. ++ * ++ * v 0.5 19990328 Initial release ++ * ++ * Future plans: Simple file and path name completion. (like BASH) ++ * ++ */ ++ ++void hetio_init(void); ++int hetio_read_input(int fd); ++void hetio_reset_term(void); ++ ++extern int hetio_inter; +diff -urN ash-0.4.0/histedit.c ash-0.4.0-/histedit.c +--- ash-0.4.0/histedit.c Fri Jan 12 17:50:35 2001 ++++ ash-0.4.0-/histedit.c Tue Apr 24 00:13:57 2001 +@@ -60,9 +60,9 @@ + #include "main.h" + #include "output.h" + #include "mystring.h" +-#include "myhistedit.h" + #include "error.h" + #ifndef SMALL ++#include "myhistedit.h" + #include "eval.h" + #include "memalloc.h" + +@@ -219,7 +219,11 @@ + if (argc == 1) + error("missing history argument"); + ++#ifdef __GLIBC__ ++ optind = 1; ++#else + optreset = 1; optind = 1; /* initialize getopt */ ++#endif + while (not_fcnumber(argv[optind]) && + (ch = getopt(argc, argv, ":e:lnrs")) != -1) + switch ((char)ch) { +diff -urN ash-0.4.0/input.c ash-0.4.0-/input.c +--- ash-0.4.0/input.c Tue May 23 12:03:19 2000 ++++ ash-0.4.0-/input.c Tue Apr 24 00:13:57 2001 +@@ -66,7 +66,13 @@ + #include "error.h" + #include "alias.h" + #include "parser.h" ++#ifndef SMALL + #include "myhistedit.h" ++#endif ++ ++#ifdef HETIO ++#include "hetio.h" ++#endif + + #define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */ + +@@ -108,7 +114,9 @@ + int init_editline = 0; /* editline library initialized? */ + int whichprompt; /* 1 == PS1, 2 == PS2 */ + ++#ifndef SMALL + EditLine *el; /* cookie for editline package */ ++#endif + + STATIC void pushfile __P((void)); + static int preadfd __P((void)); +@@ -197,6 +205,11 @@ + (void) strcpy(buf, rl_cp); + } + } else ++#endif ++ ++#ifdef HETIO ++ nr = hetio_read_input(parsefile->fd); ++ if (nr == -255) + #endif + nr = read(parsefile->fd, buf, BUFSIZ - 1); + +diff -urN ash-0.4.0/main.c ash-0.4.0-/main.c +--- ash-0.4.0/main.c Tue Apr 24 00:57:33 2001 ++++ ash-0.4.0-/main.c Tue Apr 24 00:13:57 2001 +@@ -79,6 +79,10 @@ + #include "exec.h" + #include "cd.h" + ++#ifdef HETIO ++#include "hetio.h" ++#endif ++ + #define PROFILE 0 + + int rootpid; +@@ -242,6 +246,10 @@ + + TRACE(("cmdloop(%d) called\n", top)); + setstackmark(&smark); ++#ifdef HETIO ++ if(iflag && top) ++ hetio_init(); ++#endif + for (;;) { + if (pendingsigs) + dotrap(); +Binary files ash-0.4.0/mksignames and ash-0.4.0-/mksignames differ +diff -urN ash-0.4.0/trap.c ash-0.4.0-/trap.c +--- ash-0.4.0/trap.c Tue Apr 24 00:57:33 2001 ++++ ash-0.4.0-/trap.c Tue Apr 24 00:13:57 2001 +@@ -62,7 +62,11 @@ + #include "error.h" + #include "trap.h" + #include "mystring.h" ++#include "mail.h" + ++#ifdef HETIO ++#include "hetio.h" ++#endif + + /* + * Sigmode records the current value of the signal handlers for the various +@@ -341,6 +345,7 @@ + setsignal(SIGINT); + setsignal(SIGQUIT); + setsignal(SIGTERM); ++ chkmail(1); + is_interactive = on; + } + +@@ -358,6 +363,9 @@ + char *p; + + TRACE(("exitshell(%d) pid=%d\n", status, getpid())); ++#ifdef HETIO ++ hetio_reset_term(); ++#endif + if (setjmp(loc1.loc)) { + goto l1; + } diff --git a/source/ap/ash/patches/ash-jobs.patch b/source/ap/ash/patches/ash-jobs.patch new file mode 100644 index 000000000..9e89118f5 --- /dev/null +++ b/source/ap/ash/patches/ash-jobs.patch @@ -0,0 +1,108 @@ +diff -ur netbsd-sh/jobs.c netbsd-sh-/jobs.c +--- netbsd-sh/jobs.c Tue May 23 12:03:19 2000 ++++ netbsd-sh-/jobs.c Mon Apr 23 23:31:47 2001 +@@ -92,6 +92,7 @@ + int initialpgrp; /* pgrp of shell on invocation */ + short curjob; /* current job */ + #endif ++STATIC int intreceived; + + STATIC void restartjob __P((struct job *)); + STATIC void freejob __P((struct job *)); +@@ -101,8 +102,10 @@ + STATIC int waitproc __P((int, int *)); + STATIC void cmdtxt __P((union node *)); + STATIC void cmdputs __P((const char *)); ++STATIC void waitonint(int); + + ++#if JOBS + /* + * Turn job control on and off. + * +@@ -171,6 +174,7 @@ + } + jobctl = on; + } ++#endif + + + #ifdef mkinit +@@ -594,9 +598,6 @@ + TRACE(("Child shell %d\n", getpid())); + wasroot = rootshell; + rootshell = 0; +- for (i = njobs, p = jobtab ; --i >= 0 ; p++) +- if (p->used) +- freejob(p); + closescript(); + INTON; + clear_traps(); +@@ -642,6 +643,9 @@ + } + } + #endif ++ for (i = njobs, p = jobtab ; --i >= 0 ; p++) ++ if (p->used) ++ freejob(p); + if (wasroot && iflag) { + setsignal(SIGINT); + setsignal(SIGQUIT); +@@ -701,13 +705,33 @@ + #endif + int status; + int st; ++ struct sigaction act, oact; + + INTOFF; ++ intreceived = 0; ++#if JOBS ++ if (!jobctl) { ++#else ++ if (!iflag) { ++#endif ++ sigaction(SIGINT, 0, &act); ++ act.sa_handler = waitonint; ++ sigaction(SIGINT, &act, &oact); ++ } + TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1)); + while (jp->state == 0) { + dowait(1, jp); + } + #if JOBS ++ if (!jobctl) { ++#else ++ if (!iflag) { ++#endif ++ extern char *trap[]; ++ sigaction(SIGINT, &oact, 0); ++ if (intreceived && trap[SIGINT]) kill(getpid(), SIGINT); ++ } ++#if JOBS + if (jp->jobctl) { + #ifdef OLD_TTY_DRIVER + if (ioctl(2, TIOCSPGRP, (char *)&mypgrp) < 0) +@@ -896,10 +920,10 @@ + #ifdef BSD + int flags; + +-#if JOBS +- flags = WUNTRACED; +-#else + flags = 0; ++#if JOBS ++ if (jobctl) ++ flags |= WUNTRACED; + #endif + if (block == 0) + flags |= WNOHANG; +@@ -1139,4 +1163,9 @@ + } + } + cmdnextc = q; ++} ++ ++STATIC void waitonint(int sig) { ++ intreceived = 1; ++ return; + } diff --git a/source/ap/ash/patches/ash-kill.patch b/source/ap/ash/patches/ash-kill.patch new file mode 100644 index 000000000..f2972d94c --- /dev/null +++ b/source/ap/ash/patches/ash-kill.patch @@ -0,0 +1,675 @@ +diff -urN netbsd-sh/jobs.c ash-0.3.7.orig/jobs.c +--- netbsd-sh/jobs.c Tue May 23 12:03:19 2000 ++++ ash-0.3.7.orig/jobs.c Mon Apr 23 22:16:46 2001 +@@ -189,6 +193,94 @@ + + #if JOBS + int ++killcmd(argc, argv) ++ int argc; ++ char **argv; ++{ ++ extern char *signal_names[]; ++ int signo = -1; ++ int list = 0; ++ int i; ++ pid_t pid; ++ struct job *jp; ++ ++ if (argc <= 1) { ++ error( ++"Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n" ++"kill -l [exitstatus]" ++ ); ++ } ++ ++ if (*argv[1] == '-') { ++ signo = decode_signal(argv[1]+1); ++ if (signo < 0) { ++ int c; ++ ++ while ((c = nextopt("ls:")) != '\0') ++ switch (c) { ++ case 'l': ++ list = 1; ++ break; ++ case 's': ++ signo = decode_signal(optarg); ++ break; ++ default: ++ error( ++ "nextopt returned character code 0%o", c); ++ } ++ } else ++ argptr++; ++ } ++ ++ if (!list && signo < 0) ++ signo = SIGTERM; ++ ++ if ((signo < 0 || !*argptr) ^ list) { ++ error( ++"Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n" ++"kill -l [exitstatus]" ++ ); ++ } ++ ++ if (list) { ++ if (!*argptr) { ++ out1fmt("0\n"); ++ for (i = 1; i < NSIG; i++) { ++ if (strncmp(signal_names[i], "SIGJUNK(", 8) ++ == 0) ++ continue; ++ out1fmt("%s\n", signal_names[i] + 3); ++ } ++ return 0; ++ } ++ signo = atoi(*argptr); ++ if (signo > 128) ++ signo -= 128; ++ if (0 < signo && signo < NSIG) ++ out1fmt("%s\n", signal_names[signo] + 3); ++ else ++ error("invalid signal number or exit status: %s", ++ *argptr); ++ return 0; ++ } ++ ++ do { ++ if (**argptr == '%') { ++ jp = getjob(*argptr); ++ if (jp->jobctl == 0) ++ error("job %s not created under job control", ++ *argptr); ++ pid = -jp->ps[0].pid; ++ } else ++ pid = atoi(*argptr); ++ if (kill(pid, signo) != 0) ++ error("%s: %s", *argptr, strerror(errno)); ++ } while (*++argptr); ++ ++ return 0; ++} ++ ++int + fgcmd(argc, argv) + int argc; + char **argv; + +diff -urN netbsd-sh/jobs.h ash-0.3.7.orig/jobs.h +--- netbsd-sh/jobs.h Tue May 23 12:03:19 2000 ++++ ash-0.3.7.orig/jobs.h Mon Apr 23 22:16:46 2001 +@@ -80,6 +80,7 @@ + extern int job_warning; /* user was warned about stopped jobs */ + + void setjobctl __P((int)); ++int killcmd __P((int, char **)); + int fgcmd __P((int, char **)); + int bgcmd __P((int, char **)); + int jobscmd __P((int, char **)); +diff -urN netbsd-sh/builtins.def ash-0.3.7.orig/builtins.def +--- netbsd-sh/builtins.def Mon Apr 10 13:02:58 2000 ++++ ash-0.3.7.orig/builtins.def Mon Apr 23 22:16:46 2001 +@@ -70,6 +71,7 @@ + hashcmd hash + jobidcmd jobid + jobscmd jobs ++killcmd -j kill + #linecmd line + localcmd local + #nlechocmd nlecho +diff -urN netbsd-sh/mksignames.c ash-0.3.7.orig/mksignames.c +--- netbsd-sh/mksignames.c Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/mksignames.c Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,400 @@ ++/* signames.c -- Create and write `signames.c', which contains an array of ++ signal names. */ ++ ++/* Copyright (C) 1992 Free Software Foundation, Inc. ++ ++ This file is part of GNU Bash, the Bourne Again SHell. ++ ++ Bash is free software; you can redistribute it and/or modify it under ++ the terms of the GNU General Public License as published by the Free ++ Software Foundation; either version 2, or (at your option) any later ++ version. ++ ++ Bash is distributed in the hope that it will be useful, but WITHOUT ANY ++ WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ for more details. ++ ++ You should have received a copy of the GNU General Public License along ++ with Bash; see the file COPYING. If not, write to the Free Software ++ Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ ++ ++#include <stdio.h> ++#include <sys/types.h> ++#include <signal.h> ++#include <stdlib.h> ++ ++#if !defined (NSIG) ++# define NSIG 64 ++#endif ++ ++char *signal_names[2 * NSIG]; ++ ++char *progname; ++ ++#if defined (SIGRTMAX) || defined (SIGRTMIN) ++# define RTLEN 14 ++# define RTLIM 256 ++#endif ++ ++void ++initialize_signames () ++{ ++ register int i; ++#if defined (SIGRTMAX) || defined (SIGRTMIN) ++ int rtmin, rtmax, rtcnt; ++#endif ++ ++ for (i = 1; i < sizeof(signal_names)/sizeof(signal_names[0]); i++) ++ signal_names[i] = (char *)NULL; ++ ++ /* `signal' 0 is what we do on exit. */ ++ signal_names[0] = "EXIT"; ++ ++ /* Place signal names which can be aliases for more common signal ++ names first. This allows (for example) SIGABRT to overwrite SIGLOST. */ ++ ++ /* POSIX 1003.1b-1993 real time signals, but take care of incomplete ++ implementations. Acoording to the standard, both, SIGRTMIN and ++ SIGRTMAX must be defined, SIGRTMIN must be stricly less than ++ SIGRTMAX, and the difference must be at least 7, that is, there ++ must be at least eight distinct real time signals. */ ++ ++ /* The generated signal names are SIGRTMIN, SIGRTMIN+1, ..., ++ SIGRTMIN+x, SIGRTMAX-x, ..., SIGRTMAX-1, SIGRTMAX. If the number ++ of RT signals is odd, there is an extra SIGRTMIN+(x+1). ++ These names are the ones used by ksh and /usr/xpg4/bin/sh on SunOS5. */ ++ ++#if defined (SIGRTMIN) ++ rtmin = SIGRTMIN; ++ signal_names[rtmin] = "SIGRTMIN"; ++#endif ++ ++#if defined (SIGRTMAX) ++ rtmax = SIGRTMAX; ++ signal_names[rtmax] = "SIGRTMAX"; ++#endif ++ ++#if defined (SIGRTMAX) && defined (SIGRTMIN) ++ if (rtmax > rtmin) ++ { ++ rtcnt = (rtmax - rtmin - 1) / 2; ++ /* croak if there are too many RT signals */ ++ if (rtcnt >= RTLIM/2) ++ { ++ rtcnt = RTLIM/2-1; ++ fprintf(stderr, "%s: error: more than %i real time signals, fix `%s'\n", ++ progname, RTLIM, progname); ++ } ++ ++ for (i = 1; i <= rtcnt; i++) ++ { ++ signal_names[rtmin+i] = (char *)malloc(RTLEN); ++ sprintf (signal_names[rtmin+i], "SIGRTMIN+%d", i); ++ signal_names[rtmax-i] = (char *)malloc(RTLEN); ++ sprintf (signal_names[rtmax-i], "SIGRTMAX-%d", i); ++ } ++ ++ if (rtcnt < RTLIM/2-1 && rtcnt != (rtmax-rtmin)/2) ++ { ++ /* Need an extra RTMIN signal */ ++ signal_names[rtmin+rtcnt+1] = (char *)malloc(RTLEN); ++ sprintf (signal_names[rtmin+rtcnt+1], "SIGRTMIN+%d", rtcnt+1); ++ } ++ } ++#endif /* SIGRTMIN && SIGRTMAX */ ++ ++/* AIX */ ++#if defined (SIGLOST) /* resource lost (eg, record-lock lost) */ ++ signal_names[SIGLOST] = "SIGLOST"; ++#endif ++ ++#if defined (SIGMSG) /* HFT input data pending */ ++ signal_names[SIGMSG] = "SIGMSG"; ++#endif ++ ++#if defined (SIGDANGER) /* system crash imminent */ ++ signal_names[SIGDANGER] = "SIGDANGER"; ++#endif ++ ++#if defined (SIGMIGRATE) /* migrate process to another CPU */ ++ signal_names[SIGMIGRATE] = "SIGMIGRATE"; ++#endif ++ ++#if defined (SIGPRE) /* programming error */ ++ signal_names[SIGPRE] = "SIGPRE"; ++#endif ++ ++#if defined (SIGVIRT) /* AIX virtual time alarm */ ++ signal_names[SIGVIRT] = "SIGVIRT"; ++#endif ++ ++#if defined (SIGALRM1) /* m:n condition variables */ ++ signal_names[SIGALRM1] = "SIGALRM1"; ++#endif ++ ++#if defined (SIGWAITING) /* m:n scheduling */ ++ signal_names[SIGWAITING] = "SIGWAITING"; ++#endif ++ ++#if defined (SIGGRANT) /* HFT monitor mode granted */ ++ signal_names[SIGGRANT] = "SIGGRANT"; ++#endif ++ ++#if defined (SIGKAP) /* keep alive poll from native keyboard */ ++ signal_names[SIGKAP] = "SIGKAP"; ++#endif ++ ++#if defined (SIGRETRACT) /* HFT monitor mode retracted */ ++ signal_names[SIGRETRACT] = "SIGRETRACT"; ++#endif ++ ++#if defined (SIGSOUND) /* HFT sound sequence has completed */ ++ signal_names[SIGSOUND] = "SIGSOUND"; ++#endif ++ ++#if defined (SIGSAK) /* Secure Attention Key */ ++ signal_names[SIGSAK] = "SIGSAK"; ++#endif ++ ++/* SunOS5 */ ++#if defined (SIGLWP) /* special signal used by thread library */ ++ signal_names[SIGLWP] = "SIGLWP"; ++#endif ++ ++#if defined (SIGFREEZE) /* special signal used by CPR */ ++ signal_names[SIGFREEZE] = "SIGFREEZE"; ++#endif ++ ++#if defined (SIGTHAW) /* special signal used by CPR */ ++ signal_names[SIGTHAW] = "SIGTHAW"; ++#endif ++ ++#if defined (SIGCANCEL) /* thread cancellation signal used by libthread */ ++ signal_names[SIGCANCEL] = "SIGCANCEL"; ++#endif ++ ++/* HP-UX */ ++#if defined (SIGDIL) /* DIL signal (?) */ ++ signal_names[SIGDIL] = "SIGDIL"; ++#endif ++ ++/* System V */ ++#if defined (SIGCLD) /* Like SIGCHLD. */ ++ signal_names[SIGCLD] = "SIGCLD"; ++#endif ++ ++#if defined (SIGPWR) /* power state indication */ ++ signal_names[SIGPWR] = "SIGPWR"; ++#endif ++ ++#if defined (SIGPOLL) /* Pollable event (for streams) */ ++ signal_names[SIGPOLL] = "SIGPOLL"; ++#endif ++ ++/* Unknown */ ++#if defined (SIGWINDOW) ++ signal_names[SIGWINDOW] = "SIGWINDOW"; ++#endif ++ ++/* Common */ ++#if defined (SIGHUP) /* hangup */ ++ signal_names[SIGHUP] = "SIGHUP"; ++#endif ++ ++#if defined (SIGINT) /* interrupt */ ++ signal_names[SIGINT] = "SIGINT"; ++#endif ++ ++#if defined (SIGQUIT) /* quit */ ++ signal_names[SIGQUIT] = "SIGQUIT"; ++#endif ++ ++#if defined (SIGILL) /* illegal instruction (not reset when caught) */ ++ signal_names[SIGILL] = "SIGILL"; ++#endif ++ ++#if defined (SIGTRAP) /* trace trap (not reset when caught) */ ++ signal_names[SIGTRAP] = "SIGTRAP"; ++#endif ++ ++#if defined (SIGIOT) /* IOT instruction */ ++ signal_names[SIGIOT] = "SIGIOT"; ++#endif ++ ++#if defined (SIGABRT) /* Cause current process to dump core. */ ++ signal_names[SIGABRT] = "SIGABRT"; ++#endif ++ ++#if defined (SIGEMT) /* EMT instruction */ ++ signal_names[SIGEMT] = "SIGEMT"; ++#endif ++ ++#if defined (SIGFPE) /* floating point exception */ ++ signal_names[SIGFPE] = "SIGFPE"; ++#endif ++ ++#if defined (SIGKILL) /* kill (cannot be caught or ignored) */ ++ signal_names[SIGKILL] = "SIGKILL"; ++#endif ++ ++#if defined (SIGBUS) /* bus error */ ++ signal_names[SIGBUS] = "SIGBUS"; ++#endif ++ ++#if defined (SIGSEGV) /* segmentation violation */ ++ signal_names[SIGSEGV] = "SIGSEGV"; ++#endif ++ ++#if defined (SIGSYS) /* bad argument to system call */ ++ signal_names[SIGSYS] = "SIGSYS"; ++#endif ++ ++#if defined (SIGPIPE) /* write on a pipe with no one to read it */ ++ signal_names[SIGPIPE] = "SIGPIPE"; ++#endif ++ ++#if defined (SIGALRM) /* alarm clock */ ++ signal_names[SIGALRM] = "SIGALRM"; ++#endif ++ ++#if defined (SIGTERM) /* software termination signal from kill */ ++ signal_names[SIGTERM] = "SIGTERM"; ++#endif ++ ++#if defined (SIGURG) /* urgent condition on IO channel */ ++ signal_names[SIGURG] = "SIGURG"; ++#endif ++ ++#if defined (SIGSTOP) /* sendable stop signal not from tty */ ++ signal_names[SIGSTOP] = "SIGSTOP"; ++#endif ++ ++#if defined (SIGTSTP) /* stop signal from tty */ ++ signal_names[SIGTSTP] = "SIGTSTP"; ++#endif ++ ++#if defined (SIGCONT) /* continue a stopped process */ ++ signal_names[SIGCONT] = "SIGCONT"; ++#endif ++ ++#if defined (SIGCHLD) /* to parent on child stop or exit */ ++ signal_names[SIGCHLD] = "SIGCHLD"; ++#endif ++ ++#if defined (SIGTTIN) /* to readers pgrp upon background tty read */ ++ signal_names[SIGTTIN] = "SIGTTIN"; ++#endif ++ ++#if defined (SIGTTOU) /* like TTIN for output if (tp->t_local<OSTOP) */ ++ signal_names[SIGTTOU] = "SIGTTOU"; ++#endif ++ ++#if defined (SIGIO) /* input/output possible signal */ ++ signal_names[SIGIO] = "SIGIO"; ++#endif ++ ++#if defined (SIGXCPU) /* exceeded CPU time limit */ ++ signal_names[SIGXCPU] = "SIGXCPU"; ++#endif ++ ++#if defined (SIGXFSZ) /* exceeded file size limit */ ++ signal_names[SIGXFSZ] = "SIGXFSZ"; ++#endif ++ ++#if defined (SIGVTALRM) /* virtual time alarm */ ++ signal_names[SIGVTALRM] = "SIGVTALRM"; ++#endif ++ ++#if defined (SIGPROF) /* profiling time alarm */ ++ signal_names[SIGPROF] = "SIGPROF"; ++#endif ++ ++#if defined (SIGWINCH) /* window changed */ ++ signal_names[SIGWINCH] = "SIGWINCH"; ++#endif ++ ++/* 4.4 BSD */ ++#if defined (SIGINFO) && !defined (_SEQUENT_) /* information request */ ++ signal_names[SIGINFO] = "SIGINFO"; ++#endif ++ ++#if defined (SIGUSR1) /* user defined signal 1 */ ++ signal_names[SIGUSR1] = "SIGUSR1"; ++#endif ++ ++#if defined (SIGUSR2) /* user defined signal 2 */ ++ signal_names[SIGUSR2] = "SIGUSR2"; ++#endif ++ ++#if defined (SIGKILLTHR) /* BeOS: Kill Thread */ ++ signal_names[SIGKILLTHR] = "SIGKILLTHR"; ++#endif ++ ++ for (i = 0; i < NSIG; i++) ++ if (signal_names[i] == (char *)NULL) ++ { ++ signal_names[i] = (char *)malloc (18); ++ sprintf (signal_names[i], "SIGJUNK(%d)", i); ++ } ++ ++ signal_names[NSIG] = "DEBUG"; ++} ++ ++void ++write_signames (stream) ++ FILE *stream; ++{ ++ register int i; ++ ++ fprintf (stream, "/* This file was automatically created by %s.\n", ++ progname); ++ fprintf (stream, " Do not edit. Edit support/mksignames.c instead. */\n\n"); ++ fprintf (stream, "#include <signal.h>\n\n"); ++ fprintf (stream, ++ "/* A translation list so we can be polite to our users. */\n"); ++ fprintf (stream, "char *signal_names[NSIG + 2] = {\n"); ++ ++ for (i = 0; i <= NSIG; i++) ++ fprintf (stream, " \"%s\",\n", signal_names[i]); ++ ++ fprintf (stream, " (char *)0x0,\n"); ++ fprintf (stream, "};\n"); ++} ++ ++int ++main (argc, argv) ++ int argc; ++ char **argv; ++{ ++ char *stream_name; ++ FILE *stream; ++ ++ progname = argv[0]; ++ ++ if (argc == 1) ++ { ++ stream_name = "signames.c"; ++ } ++ else if (argc == 2) ++ { ++ stream_name = argv[1]; ++ } ++ else ++ { ++ fprintf (stderr, "Usage: %s [output-file]\n", progname); ++ exit (1); ++ } ++ ++ stream = fopen (stream_name, "w"); ++ if (!stream) ++ { ++ fprintf (stderr, "%s: %s: cannot open for writing\n", ++ progname, stream_name); ++ exit (2); ++ } ++ ++ initialize_signames (); ++ write_signames (stream); ++ exit (0); ++} +diff -urN netbsd-sh/trap.c ash-0.3.7.orig/trap.c +--- netbsd-sh/trap.c Tue May 23 12:03:19 2000 ++++ ash-0.3.7.orig/trap.c Mon Apr 23 22:16:46 2001 +@@ -84,7 +88,7 @@ + char gotsig[NSIG]; /* indicates specified signal received */ + int pendingsigs; /* indicates some signal received */ + +-static int getsigaction __P((int, sig_t *)); ++extern char *signal_names[]; + + /* + * The trap builtin. +@@ -107,16 +111,20 @@ + return 0; + } + ap = argv + 1; +- if (is_number(*ap)) ++ if (argc == 2) + action = NULL; + else + action = *ap++; + while (*ap) { +- if ((signo = number(*ap)) < 0 || signo > NSIG) ++ if ((signo = decode_signal(*ap)) < 0) + error("%s: bad trap", *ap); + INTOFF; +- if (action) +- action = savestr(action); ++ if (action) { ++ if (action[0] == '-' && action[1] == '\0') ++ action = NULL; ++ else ++ action = savestr(action); ++ } + if (trap[signo]) + ckfree(trap[signo]); + trap[signo] = action; +@@ -157,13 +165,13 @@ + * out what it should be set to. + */ + +-long ++void + setsignal(signo) + int signo; + { + int action; +- sig_t sigact = SIG_DFL; + char *t; ++ struct sigaction act; + + if ((t = trap[signo]) == NULL) + action = S_DFL; +@@ -206,15 +214,15 @@ + /* + * current setting unknown + */ +- if (!getsigaction(signo, &sigact)) { ++ if (sigaction(signo, 0, &act) == -1) { + /* + * Pretend it worked; maybe we should give a warning + * here, but other shells don't. We don't alter + * sigmode, so that we retry every time. + */ +- return 0; ++ return; + } +- if (sigact == SIG_IGN) { ++ if (act.sa_handler == SIG_IGN) { + if (mflag && (signo == SIGTSTP || + signo == SIGTTIN || signo == SIGTTOU)) { + *t = S_IGN; /* don't hard ignore these */ +@@ -225,31 +233,21 @@ + } + } + if (*t == S_HARD_IGN || *t == action) +- return 0; ++ return; + switch (action) { +- case S_DFL: sigact = SIG_DFL; break; +- case S_CATCH: sigact = onsig; break; +- case S_IGN: sigact = SIG_IGN; break; ++ case S_CATCH: ++ act.sa_handler = onsig; ++ break; ++ case S_IGN: ++ act.sa_handler = SIG_IGN; ++ break; ++ default: ++ act.sa_handler = SIG_DFL; + } + *t = action; +- siginterrupt(signo, 1); +- return (long)signal(signo, sigact); +-} +- +-/* +- * Return the current setting for sig w/o changing it. +- */ +-static int +-getsigaction(signo, sigact) +- int signo; +- sig_t *sigact; +-{ +- struct sigaction sa; +- +- if (sigaction(signo, (struct sigaction *)0, &sa) == -1) +- return 0; +- *sigact = (sig_t) sa.sa_handler; +- return 1; ++ act.sa_flags = 0; ++ sigemptyset(&act.sa_mask); ++ sigaction(signo, &act, 0); + } + + /* +@@ -382,4 +384,18 @@ + #endif + l2: _exit(status); + /* NOTREACHED */ ++} ++ ++int decode_signal(const char *string) ++{ ++ int signo; ++ ++ if (is_number(string)) return atoi(string); ++ ++ for (signo=0; signo < NSIG; signo++) ++ if (strcasecmp(string, signal_names[signo]) == 0 || ++ strcasecmp(string, &(signal_names[signo])[3]) == 0) ++ return signo; ++ ++ return -1; + } +diff -urN netbsd-sh/trap.h ash-0.3.7.orig/trap.h +--- netbsd-sh/trap.h Tue May 23 12:03:19 2000 ++++ ash-0.3.7.orig/trap.h Mon Apr 23 22:16:46 2001 +@@ -42,9 +42,10 @@ + + int trapcmd __P((int, char **)); + void clear_traps __P((void)); +-long setsignal __P((int)); ++void setsignal __P((int)); + void ignoresig __P((int)); + void onsig __P((int)); + void dotrap __P((void)); + void setinteractive __P((int)); + void exitshell __P((int)) __attribute__((noreturn)); ++int decode_signal __P((const char *)); diff --git a/source/ap/ash/patches/ash-makefile.patch b/source/ap/ash/patches/ash-makefile.patch new file mode 100644 index 000000000..c3b16a1f5 --- /dev/null +++ b/source/ap/ash/patches/ash-makefile.patch @@ -0,0 +1,115 @@ +diff -u ash-0.4.0/Makefile ash-0.4.0-/Makefile +--- ash-0.4.0/Makefile Fri Jan 12 17:50:34 2001 ++++ ash-0.4.0-/Makefile Tue Apr 24 00:49:56 2001 +@@ -7,56 +7,68 @@ + SHSRCS= alias.c cd.c echo.c error.c eval.c exec.c expand.c \ + histedit.c input.c jobs.c mail.c main.c memalloc.c miscbltin.c \ + mystring.c options.c parser.c redir.c show.c trap.c output.c var.c \ +- test.c +-GENSRCS=arith.c arith.h arith_lex.c builtins.c builtins.h init.c nodes.c \ +- nodes.h syntax.c syntax.h token.h ++ test.c setmode.c test.c ++GENSRCS=builtins.c builtins.h init.c nodes.c arith.c arith.h lex.yy.c \ ++ nodes.h syntax.c syntax.h token.h signames.c + SRCS= ${SHSRCS} ${GENSRCS} + +-LDADD+= -ll -ledit -ltermcap +-DPADD+= ${LIBL} ${LIBEDIT} ${LIBTERMCAP} ++OBJS=alias.o cd.o bltin/echo.o error.o eval.o exec.o expand.o \ ++ histedit.o input.o jobs.o mail.o main.o memalloc.o miscbltin.o \ ++ mystring.o options.o output.o parser.o redir.o show.o \ ++ trap.o var.o bltin/test.o signames.o \ ++ builtins.o init.o nodes.o syntax.o arith.o lex.yy.o \ ++ setmode.o bltin/times.o ++ ++OPT_FLAGS=-O2 -g ++LDFLAGS=-g ++CFLAGS=$(OPT_FLAGS) -DSHELL -I. -DNO_HISTORY -DBSD=1 -DSMALL -D_GNU_SOURCE \ ++ -DGLOB_BROKEN -D__COPYRIGHT\(x\)= -D__RCSID\(x\)= -D_DIAGASSERT\(x\)= ++ ++all: $(PROG) ++ ++$(PROG): build-tools $(GENSRCS) $(GENHDRS) $(OBJS) ++ $(CC) $(LDFLAGS) -o $(PROG) $(OBJS) $(LDLIBS) -lfl ++ ++lex.yy.c: arith_lex.l ++ flex -8 $< ++ ++CLEANFILES+= mkinit mkinit.o mknodes mknodes.o \ ++ mksyntax mksyntax.o ++ ++CLEANFILES+= ${GENSRCS} ${GENHDRS} ++ ++build-tools: mkinit mknodes mksyntax ++ ++.ORDER: builtins.c builtins.h ++builtins.c builtins.h: mkbuiltins builtins.def ++ sh mkbuiltins shell.h builtins.def `pwd` ++ ++INIT_DEPS = alias.c eval.c exec.c input.c jobs.c options.c parser.c \ ++ redir.c trap.c var.c output.c ++ ++init.c: mkinit $(INIT_DEPS) ++ ./mkinit $(INIT_DEPS) ++ ++mkinit: mkinit.o ++mknodes: mknodes.o ++mksyntax: mksyntax.o + +-LFLAGS= -8 # 8-bit lex scanner for arithmetic +-YFLAGS= -d +- +-CPPFLAGS+=-DSHELL -I. -I${.CURDIR} +- +-.PATH: ${.CURDIR}/bltin ${.CURDIR}/../../usr.bin/printf ${.CURDIR}/../test +- +-CLEANFILES+= mkinit mknodes mksyntax +-CLEANFILES+= ${GENSRCS} y.tab.h +- +-token.h: mktokens +- sh ${.ALLSRC} +- +-builtins.c builtins.h: mkbuiltins shell.h builtins.def +- sh ${.ALLSRC} ${.OBJDIR} +- +-init.c: mkinit ${SHSRCS} +- ./${.ALLSRC} ++signames.c: mksignames ++ ./mksignames + + nodes.c nodes.h: mknodes nodetypes nodes.c.pat +- ./${.ALLSRC} ++ ./mknodes ./nodetypes ./nodes.c.pat + + syntax.c syntax.h: mksyntax +- ./${.ALLSRC} +- +-mkinit: mkinit.c +- ${HOST_LINK.c} -o mkinit ${.IMPSRC} +- +-mknodes: mknodes.c +- ${HOST_LINK.c} -o mknodes ${.IMPSRC} ++ ./mksyntax + +-.if (${MACHINE_ARCH} == "powerpc") || \ +- (${MACHINE_ARCH} == "arm32") || \ +- (${MACHINE_ARCH} == "arm26") +-TARGET_CHARFLAG= -DTARGET_CHAR="u_int8_t" +-.else +-TARGET_CHARFLAG= -DTARGET_CHAR="int8_t" +-.endif ++arith.c arith.h: arith.y ++ yacc -d arith.y ++ mv y.tab.h arith.h ++ mv y.tab.c arith.c + +-mksyntax: mksyntax.c +- ${HOST_LINK.c} ${TARGET_CHARFLAG} -o mksyntax ${.IMPSRC} +- +-.include <bsd.prog.mk> ++token.h: mktokens ++ sh ./mktokens + +-${OBJS}: builtins.h nodes.h syntax.h token.h ++clean: ++ rm -f $(PROG) $(OBJS) $(CLEANFILES) core diff --git a/source/ap/ash/patches/ash-manpage.patch b/source/ap/ash/patches/ash-manpage.patch new file mode 100644 index 000000000..458367e79 --- /dev/null +++ b/source/ap/ash/patches/ash-manpage.patch @@ -0,0 +1,42 @@ +diff -urN netbsd-sh/sh.1 ash-0.3.7.orig/sh.1 +--- netbsd-sh/sh.1 Fri Jan 12 17:50:40 2001 ++++ ash-0.3.7.orig/sh.1 Mon Apr 23 22:16:46 2001 +@@ -649,7 +649,7 @@ + they were one program: + .Pp + .Bd -literal -offset indent +-{ echo -n \*q hello \*q ; echo \*q world" } > greeting ++{ echo \*q hello \\c\*q ; echo \*q world" } > greeting + .Ed + .Pp + .Ss Functions +@@ -1306,14 +1306,16 @@ + will continue to print the old name for the directory. + .It Xo read Op Fl p Ar prompt + .Op Fl r +-.Op Ar variable... ++.Ar variable... + .Xc + The prompt is printed if the + .Fl p + option is specified and the standard input is a terminal. Then a line is + read from the standard input. The trailing newline is deleted from the + line and the line is split as described in the section on word splitting +-above, and the pieces are assigned to the variables in order. If there are ++above, and the pieces are assigned to the variables in order. ++At least one variable must be specified. ++If there are + more pieces than variables, the remaining pieces (along with the + characters in + .Ev IFS +@@ -1394,6 +1396,9 @@ + by one. If there are zero positional parameters, + .Ic shift + does nothing. ++.It times ++Print the accumulated user and system times for the shell and for processes ++run from the shell. The return status is 0. + .It Xo trap + .Op Ar action + .Ar signal... + diff --git a/source/ap/ash/patches/ash-memout.patch b/source/ap/ash/patches/ash-memout.patch new file mode 100644 index 000000000..1bfedadaa --- /dev/null +++ b/source/ap/ash/patches/ash-memout.patch @@ -0,0 +1,333 @@ +diff -u ash-0.4.0/eval.c ash-0.4.0-/eval.c +--- ash-0.4.0/eval.c Tue Apr 24 00:53:12 2001 ++++ ash-0.4.0-/eval.c Tue Apr 24 00:13:57 2001 +@@ -879,9 +879,13 @@ + #endif + mode = (cmdentry.u.index == EXECCMD)? 0 : REDIR_PUSH; + if (flags == EV_BACKCMD) { ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ openmemout(); ++#else + memout.nleft = 0; + memout.nextc = memout.buf; + memout.bufsize = 64; ++#endif + mode |= REDIR_BACKQ; + } + redirect(cmd->ncmd.redirect, mode); +@@ -928,10 +932,18 @@ + if (cmdentry.u.index != EXECCMD) + popredir(); + if (flags == EV_BACKCMD) { ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ closememout(); ++#endif + backcmd->buf = memout.buf; ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ backcmd->nleft = memout.bufsize; ++#else + backcmd->nleft = memout.nextc - memout.buf; ++#endif + memout.buf = NULL; + } ++ cmdenviron = NULL; + } else { + #ifdef DEBUG + trputs("normal command: "); trargs(argv); +Common subdirectories: ash-0.4.0/funcs and ash-0.4.0-/funcs +diff -u ash-0.4.0/output.c ash-0.4.0-/output.c +--- ash-0.4.0/output.c Fri Jan 12 17:50:39 2001 ++++ ash-0.4.0-/output.c Tue Apr 24 00:43:44 2001 +@@ -65,6 +65,10 @@ + #include <errno.h> + #include <unistd.h> + #include <stdlib.h> ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++#undef CEOF /* get rid of the redefine warning */ ++#include <fcntl.h> ++#endif + + #include "shell.h" + #include "syntax.h" +@@ -79,9 +83,15 @@ + #define OUTPUT_ERR 01 /* error occurred on output */ + + ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++struct output output = {NULL, NULL, 0, NULL, 0, 1, 0}; ++struct output errout = {NULL, NULL, 0, NULL, 0, 2, 0}; ++struct output memout = {NULL, NULL, 0, NULL, 0, MEM_OUT, 0}; ++#else + struct output output = {NULL, 0, NULL, OUTBUFSIZ, 1, 0}; + struct output errout = {NULL, 0, NULL, 100, 2, 0}; + struct output memout = {NULL, 0, NULL, 0, MEM_OUT, 0}; ++#endif + struct output *out1 = &output; + struct output *out2 = &errout; + +@@ -92,9 +102,19 @@ + INCLUDE "output.h" + INCLUDE "memalloc.h" + ++INIT { ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ initstreams(); ++#endif ++} ++ + RESET { + out1 = &output; + out2 = &errout; ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ if (memout.stream != NULL) ++ closememout(); ++#endif + if (memout.buf != NULL) { + ckfree(memout.buf); + memout.buf = NULL; +@@ -124,33 +144,22 @@ + + + void +-out1str(p) +- const char *p; +- { +- outstr(p, out1); +-} +- +- +-void +-out2str(p) +- const char *p; +- { +- outstr(p, out2); +-} +- +- +-void + outstr(p, file) + const char *p; + struct output *file; + { ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ fputs(p, file->stream); ++#else + while (*p) + outc(*p++, file); ++#endif + if (file == out2) + flushout(file); + } + + ++#if !defined(_GNU_SOURCE) || defined(__UCLIBC__) + char out_junk[16]; + + +@@ -183,6 +192,7 @@ + } + dest->nleft--; + } ++#endif + + + void +@@ -192,11 +202,11 @@ + } + + ++#if !defined(_GNU_SOURCE) || defined(__UCLIBC__) + void + flushout(dest) + struct output *dest; + { +- + if (dest->buf == NULL || dest->nextc == dest->buf || dest->fd < 0) + return; + if (xwrite(dest->fd, dest->buf, dest->nextc - dest->buf) < 0) +@@ -204,6 +214,7 @@ + dest->nextc = dest->buf; + dest->nleft = dest->bufsize; + } ++#endif + + + void +@@ -264,6 +275,7 @@ + va_end(ap); + } + ++#if !defined(__GLIBC__) && !defined(__UCLIBC__) + void + #ifdef __STDC__ + dprintf(const char *fmt, ...) +@@ -285,6 +297,7 @@ + va_end(ap); + flushout(out2); + } ++#endif + + void + #ifdef __STDC__ +@@ -295,7 +308,9 @@ + #endif + { + va_list ap; ++#if !defined(_GNU_SOURCE) || defined(__UCLIBC__) + struct output strout; ++#endif + #ifndef __STDC__ + char *outbuf; + size_t length; +@@ -308,6 +323,9 @@ + #else + va_start(ap, fmt); + #endif ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ vsnprintf(outbuf, length, fmt, ap); ++#else + strout.nextc = outbuf; + strout.nleft = length; + strout.fd = BLOCK_OUT; +@@ -316,8 +334,10 @@ + outc('\0', &strout); + if (strout.flags & OUTPUT_ERR) + outbuf[length - 1] = '\0'; ++#endif + } + ++#if !defined(_GNU_SOURCE) || defined(__UCLIBC__) + /* + * Formatted output. This routine handles a subset of the printf formats: + * - Formats supported: d, u, o, p, X, s, and c. +@@ -534,7 +554,7 @@ + } + #endif /* !HAVE_VASPRINTF */ + } +- ++#endif + + + /* +@@ -544,7 +564,7 @@ + int + xwrite(fd, buf, nbytes) + int fd; +- char *buf; ++ const char *buf; + int nbytes; + { + int ntry; +@@ -570,6 +590,8 @@ + } + + ++ ++#ifdef notdef + /* + * Version of ioctl that retries after a signal is caught. + * XXX unused function +@@ -586,3 +608,27 @@ + while ((i = ioctl(fd, request, arg)) == -1 && errno == EINTR); + return i; + } ++#endif ++ ++ ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++void initstreams() { ++ output.stream = stdout; ++ errout.stream = stderr; ++} ++ ++ ++void ++openmemout() { ++ memout.stream = open_memstream(&memout.buf, &memout.bufsize); ++} ++ ++ ++void ++closememout() { ++ INTOFF; ++ fclose(memout.stream); ++ memout.stream = NULL; ++ INTON; ++} ++#endif +diff -u ash-0.4.0/output.h ash-0.4.0-/output.h +--- ash-0.4.0/output.h Sat Jan 31 19:28:11 1998 ++++ ash-0.4.0-/output.h Tue Apr 24 00:13:57 2001 +@@ -45,13 +45,19 @@ + #else + #include <varargs.h> + #endif ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++#include <stdio.h> ++#endif + + struct output { ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++ FILE *stream; ++#endif + char *nextc; + int nleft; + char *buf; + int bufsize; +- short fd; ++ int fd; + short flags; + }; + +@@ -61,29 +67,44 @@ + extern struct output *out1; + extern struct output *out2; + +-void open_mem __P((char *, int, struct output *)); +-void out1str __P((const char *)); +-void out2str __P((const char *)); + void outstr __P((const char *, struct output *)); ++#ifndef _GNU_SOURCE + void emptyoutbuf __P((struct output *)); ++#endif + void flushall __P((void)); ++#ifndef _GNU_SOURCE + void flushout __P((struct output *)); ++#endif + void freestdout __P((void)); + void outfmt __P((struct output *, const char *, ...)) + __attribute__((__format__(__printf__,2,3))); + void out1fmt __P((const char *, ...)) + __attribute__((__format__(__printf__,1,2))); ++#if !defined(__GLIBC__) && !defined(__UCLIBC__) + void dprintf __P((const char *, ...)) + __attribute__((__format__(__printf__,1,2))); ++#endif + void fmtstr __P((char *, size_t, const char *, ...)) + __attribute__((__format__(__printf__,3,4))); ++#ifndef _GNU_SOURCE + void doformat __P((struct output *, const char *, va_list)); +-int xwrite __P((int, char *, int)); +-int xioctl __P((int, unsigned long, char *)); ++#endif ++int xwrite __P((int, const char *, int)); ++#if defined(_GNU_SOURCE) && !defined(__UCLIBC__) ++void initstreams __P((void)); ++void openmemout __P((void)); ++void closememout __P((void)); + ++#define outc(c, o) putc(c, (o)->stream) ++#define flushout(o) fflush((o)->stream) ++#define doformat(d, f, a) vfprintf((d)->stream, f, a) ++#else + #define outc(c, file) (--(file)->nleft < 0? (emptyoutbuf(file), *(file)->nextc++ = (c)) : (*(file)->nextc++ = (c))) +-#define out1c(c) outc(c, out1); +-#define out2c(c) outc(c, out2); ++#endif ++#define out1c(c) outc(c, out1) ++#define out2c(c) outc(c, out2) ++#define out1str(s) outstr(s, out1) ++#define out2str(s) outstr(s, out2) + + #define OUTPUT_INCL + #endif diff --git a/source/ap/ash/patches/ash-misc.patch b/source/ap/ash/patches/ash-misc.patch new file mode 100644 index 000000000..9845a2325 --- /dev/null +++ b/source/ap/ash/patches/ash-misc.patch @@ -0,0 +1,122 @@ +diff -urN netbsd-sh/error.c ash-0.3.7.orig/error.c +--- netbsd-sh/error.c Fri Jan 12 17:50:35 2001 ++++ ash-0.3.7.orig/error.c Mon Apr 23 22:16:46 2001 +@@ -233,6 +233,7 @@ + { ENOTDIR, E_CREAT,"directory nonexistent" }, + { ENOTDIR, E_EXEC, "not found" }, + { EISDIR, ALL, "is a directory" }, ++ { EEXIST, E_CREAT,"file exists" }, + #ifdef notdef + { EMFILE, ALL, "too many open files" }, + #endif +diff -urN netbsd-sh/error.h ash-0.3.7.orig/error.h +--- netbsd-sh/error.h Fri Jul 9 13:02:05 1999 ++++ ash-0.3.7.orig/error.h Mon Apr 23 22:16:46 2001 +@@ -102,7 +102,7 @@ + * so we use _setjmp instead. + */ + +-#if defined(BSD) && !defined(__SVR4) ++#if defined(BSD) && !defined(__SVR4) && !defined(__GLIBC__) + #define setjmp(jmploc) _setjmp(jmploc) + #define longjmp(jmploc, val) _longjmp(jmploc, val) + #endif +diff -urN netbsd-sh/bltin/bltin.h ash-0.3.7.orig/bltin/bltin.h +--- netbsd-sh/bltin/bltin.h Sat Jul 5 13:12:37 1997 ++++ ash-0.3.7.orig/bltin/bltin.h Mon Apr 23 22:16:46 2001 +@@ -46,8 +46,10 @@ + + #include "../shell.h" + #include "../mystring.h" ++#include "../memalloc.h" + #ifdef SHELL + #include "../output.h" ++#ifndef _GNU_SOURCE + #define stdout out1 + #define stderr out2 + #define printf out1fmt +@@ -56,12 +58,13 @@ + #define fprintf outfmt + #define fputs outstr + #define fflush flushout +-#define INITARGS(argv) + #define warnx(a, b, c) { \ + char buf[64]; \ + (void)snprintf(buf, sizeof(buf), a, b, c); \ + error("%s", buf); \ + } ++#endif ++#define INITARGS(argv) + + #else + #undef NULL +diff -urN netbsd-sh/main.c ash-0.3.7.orig/main.c +--- netbsd-sh/main.c Fri Jan 12 17:50:36 2001 ++++ ash-0.3.7.orig/main.c Mon Apr 23 22:16:46 2001 +@@ -115,6 +119,9 @@ + #if PROFILE + monitor(4, etext, profile_buf, sizeof profile_buf, 50); + #endif ++#if defined(linux) || defined(__GNU__) ++ signal(SIGCHLD, SIG_DFL); ++#endif + state = 0; + if (setjmp(jmploc.loc)) { + /* +diff -urN netbsd-sh/var.c ash-0.3.7.orig/var.c +--- netbsd-sh/var.c Fri Jan 12 17:50:40 2001 ++++ ash-0.3.7.orig/var.c Mon Apr 23 22:19:54 2001 +@@ -114,7 +114,7 @@ + NULL }, + { &vmpath, VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH=", + NULL }, +- { &vpath, VSTRFIXED|VTEXTFIXED, "PATH=" _PATH_DEFPATH, ++ { &vpath, VSTRFIXED|VTEXTFIXED, "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + changepath }, + /* + * vps1 depends on uid +@@ -138,13 +138,16 @@ + + /* + * Initialize the varable symbol tables and import the environment ++ * Setting PWD added by herbert + */ + + #ifdef mkinit ++INCLUDE "cd.h" + INCLUDE "var.h" + INIT { + char **envp; + extern char **environ; ++ extern char *curdir; + + initvar(); + for (envp = environ ; *envp ; envp++) { +@@ -152,6 +155,9 @@ + setvareq(*envp, VEXPORT|VTEXTFIXED); + } + } ++ ++ getpwd(); ++ setvar("PWD", curdir, VEXPORT|VTEXTFIXED); + } + #endif + +@@ -283,6 +289,7 @@ + struct var *vp, **vpp; + + vpp = hashvar(s); ++ flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1)); + for (vp = *vpp ; vp ; vp = vp->next) { + if (varequal(s, vp->text)) { + if (vp->flags & VREADONLY) { +@@ -305,7 +312,8 @@ + * We could roll this to a function, to handle it as + * a regular variable function callback, but why bother? + */ +- if (vp == &vmpath || (vp == &vmail && ! mpathset())) ++ if (iflag && ++ (vp == &vmpath || (vp == &vmail && ! mpathset()))) + chkmail(1); + INTON; + return; diff --git a/source/ap/ash/patches/ash-ppid.patch b/source/ap/ash/patches/ash-ppid.patch new file mode 100644 index 000000000..954b509d4 --- /dev/null +++ b/source/ap/ash/patches/ash-ppid.patch @@ -0,0 +1,21 @@ +diff -ur ash-0.4.0/var.c ash-0.4.0-ppid/var.c +--- ash-0.4.0/var.c Tue Apr 24 01:23:17 2001 ++++ ash-0.4.0-ppid/var.c Tue Apr 24 01:22:07 2001 +@@ -172,6 +172,7 @@ + const struct varinit *ip; + struct var *vp; + struct var **vpp; ++ char ppid[30]; + + for (ip = varinit ; (vp = ip->var) != NULL ; ip++) { + if ((vp->flags & VEXPORT) == 0) { +@@ -193,6 +194,9 @@ + vps1.text = strdup(geteuid() ? "PS1=$ " : "PS1=# "); + vps1.flags = VSTRFIXED|VTEXTFIXED; + } ++ ++ snprintf(ppid, 29, "%ld", (long)getppid()); ++ setvar("PPID", ppid, VREADONLY|VNOFUNC); + } + + /* diff --git a/source/ap/ash/patches/ash-redir.patch b/source/ap/ash/patches/ash-redir.patch new file mode 100644 index 000000000..40cdbe9ac --- /dev/null +++ b/source/ap/ash/patches/ash-redir.patch @@ -0,0 +1,463 @@ +diff -ur netbsd-sh/eval.c netbsd-sh-/eval.c +--- netbsd-sh/eval.c Tue May 23 12:03:18 2000 ++++ netbsd-sh-/eval.c Mon Apr 23 23:33:34 2001 +@@ -442,6 +442,7 @@ + case NFROM: + case NTO: + case NAPPEND: ++ case NTOOV: + expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR); + redir->nfile.expfname = fn.list->text; + break; +diff -ur netbsd-sh/exec.c netbsd-sh-/exec.c +--- netbsd-sh/exec.c Fri Jan 12 17:50:35 2001 ++++ netbsd-sh-/exec.c Mon Apr 23 23:33:34 2001 +@@ -125,6 +125,10 @@ + char *cmdname; + int e; + ++ if (fd2 >= 0 && fd2 != 2) { ++ close(fd2); ++ } ++ + if (strchr(argv[0], '/') != NULL) { + tryexec(argv[0], argv, envp); + e = errno; +diff -ur netbsd-sh/jobs.c netbsd-sh-/jobs.c +--- netbsd-sh/jobs.c Mon Apr 23 23:34:53 2001 ++++ netbsd-sh-/jobs.c Mon Apr 23 23:34:30 2001 +@@ -129,9 +129,9 @@ + if (on) { + do { /* while we are in the background */ + #ifdef OLD_TTY_DRIVER +- if (ioctl(2, TIOCGPGRP, (char *)&initialpgrp) < 0) { ++ if (ioctl(fd2, TIOCGPGRP, (char *)&initialpgrp) < 0) { + #else +- initialpgrp = tcgetpgrp(2); ++ initialpgrp = tcgetpgrp(fd2); + if (initialpgrp < 0) { + #endif + out2str("sh: can't access tty; job control turned off\n"); +@@ -146,7 +146,7 @@ + } + } while (0); + #ifdef OLD_TTY_DRIVER +- if (ioctl(2, TIOCGETD, (char *)&ldisc) < 0 || ldisc != NTTYDISC) { ++ if (ioctl(fd2, TIOCGETD, (char *)&ldisc) < 0 || ldisc != NTTYDISC) { + out2str("sh: need new tty driver to run job control; job control turned off\n"); + mflag = 0; + return; +@@ -157,16 +157,16 @@ + setsignal(SIGTTIN); + setpgid(0, rootpid); + #ifdef OLD_TTY_DRIVER +- ioctl(2, TIOCSPGRP, (char *)&rootpid); ++ ioctl(fd2, TIOCSPGRP, (char *)&rootpid); + #else +- tcsetpgrp(2, rootpid); ++ tcsetpgrp(fd2, rootpid); + #endif + } else { /* turning job control off */ + setpgid(0, initialpgrp); + #ifdef OLD_TTY_DRIVER +- ioctl(2, TIOCSPGRP, (char *)&initialpgrp); ++ ioctl(fd2, TIOCSPGRP, (char *)&initialpgrp); + #else +- tcsetpgrp(2, initialpgrp); ++ tcsetpgrp(fd2, initialpgrp); + #endif + setsignal(SIGTSTP); + setsignal(SIGTTOU); +@@ -206,9 +206,9 @@ + error("job not created under job control"); + pgrp = jp->ps[0].pid; + #ifdef OLD_TTY_DRIVER +- ioctl(2, TIOCSPGRP, (char *)&pgrp); ++ ioctl(fd2, TIOCSPGRP, (char *)&pgrp); + #else +- tcsetpgrp(2, pgrp); ++ tcsetpgrp(fd2, pgrp); + #endif + restartjob(jp); + INTOFF; +@@ -612,10 +612,10 @@ + if (mode == FORK_FG) { + /*** this causes superfluous TIOCSPGRPS ***/ + #ifdef OLD_TTY_DRIVER +- if (ioctl(2, TIOCSPGRP, (char *)&pgrp) < 0) ++ if (ioctl(fd2, TIOCSPGRP, (char *)&pgrp) < 0) + error("TIOCSPGRP failed, errno=%d", errno); + #else +- if (tcsetpgrp(2, pgrp) < 0) ++ if (tcsetpgrp(fd2, pgrp) < 0) + error("tcsetpgrp failed, errno=%d", errno); + #endif + } +@@ -734,10 +734,10 @@ + #if JOBS + if (jp->jobctl) { + #ifdef OLD_TTY_DRIVER +- if (ioctl(2, TIOCSPGRP, (char *)&mypgrp) < 0) ++ if (ioctl(fd2, TIOCSPGRP, (char *)&mypgrp) < 0) + error("TIOCSPGRP failed, errno=%d\n", errno); + #else +- if (tcsetpgrp(2, mypgrp) < 0) ++ if (tcsetpgrp(fd2, mypgrp) < 0) + error("tcsetpgrp failed, errno=%d\n", errno); + #endif + } +@@ -1092,6 +1092,8 @@ + p = ">>"; i = 1; goto redir; + case NTOFD: + p = ">&"; i = 1; goto redir; ++ case NTOOV: ++ p = ">|"; i = 1; goto redir; + case NFROM: + p = "<"; i = 0; goto redir; + case NFROMFD: +Only in netbsd-sh-: jobs.c.orig +diff -ur netbsd-sh/nodetypes netbsd-sh-/nodetypes +--- netbsd-sh/nodetypes Fri Feb 5 13:04:52 1999 ++++ netbsd-sh-/nodetypes Mon Apr 23 23:33:34 2001 +@@ -119,6 +119,7 @@ + NFROM nfile # fd< fname + NFROMTO nfile # fd<> fname + NAPPEND nfile # fd>> fname ++NTOOV nfile # fd>| fname + type int + next nodeptr # next redirection in list + fd int # file descriptor being redirected +diff -ur netbsd-sh/parser.c netbsd-sh-/parser.c +--- netbsd-sh/parser.c Fri Jan 12 17:50:39 2001 ++++ netbsd-sh-/parser.c Mon Apr 23 23:33:34 2001 +@@ -1125,6 +1125,8 @@ + np->type = NAPPEND; + else if (c == '&') + np->type = NTOFD; ++ else if (c == '|') ++ np->type = NTOOV; + else { + np->type = NTO; + pungetc(); +diff -ur netbsd-sh/redir.c netbsd-sh-/redir.c +--- netbsd-sh/redir.c Tue May 23 12:03:19 2000 ++++ netbsd-sh-/redir.c Mon Apr 23 23:33:34 2001 +@@ -45,6 +45,7 @@ + #endif + #endif /* not lint */ + ++#include <sys/stat.h> + #include <sys/types.h> + #include <sys/param.h> /* PIPE_BUF */ + #include <signal.h> +@@ -66,6 +67,7 @@ + #include "output.h" + #include "memalloc.h" + #include "error.h" ++#include "options.h" + + + #define EMPTY -2 /* marks an unused slot in redirtab */ +@@ -92,8 +94,15 @@ + */ + int fd0_redirected = 0; + +-STATIC void openredirect __P((union node *, char[10 ])); ++/* ++ * We also keep track of where fd2 goes. ++ */ ++int fd2 = 2; ++ ++STATIC int openredirect __P((union node *)); ++STATIC void dupredirect __P((union node *, int, char[10 ])); + STATIC int openhere __P((union node *)); ++STATIC int noclobberopen __P((const char *)); + + + /* +@@ -113,6 +122,7 @@ + struct redirtab *sv = NULL; + int i; + int fd; ++ int newfd; + int try; + char memory[10]; /* file descriptors to write to memory */ + +@@ -133,36 +143,47 @@ + n->ndup.dupfd == fd) + continue; /* redirect from/to same file descriptor */ + +- if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) { +- INTOFF; +-again: +- if ((i = fcntl(fd, F_DUPFD, 10)) == -1) { ++ INTOFF; ++ newfd = openredirect(n); ++ if (((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) || ++ (fd == fd2)) { ++ if (newfd == fd) { ++ try++; ++ } else if ((i = fcntl(fd, F_DUPFD, 10)) == -1) { + switch (errno) { + case EBADF: + if (!try) { +- openredirect(n, memory); ++ dupredirect(n, newfd, memory); + try++; +- goto again; ++ break; + } + /* FALLTHROUGH*/ + default: ++ if (newfd >= 0) { ++ close(newfd); ++ } + INTON; + error("%d: %s", fd, strerror(errno)); + /* NOTREACHED */ + } + } + if (!try) { +- sv->renamed[fd] = i; + close(fd); ++ if (flags & REDIR_PUSH) { ++ sv->renamed[fd] = i; ++ } ++ if (fd == fd2) { ++ fd2 = i; ++ } + } +- INTON; +- } else { ++ } else if (fd != newfd) { + close(fd); + } + if (fd == 0) + fd0_redirected++; + if (!try) +- openredirect(n, memory); ++ dupredirect(n, newfd, memory); ++ INTON; + } + if (memory[1]) + out1 = &memout; +@@ -171,22 +192,13 @@ + } + + +-STATIC void +-openredirect(redir, memory) ++STATIC int ++openredirect(redir) + union node *redir; +- char memory[10]; + { +- int fd = redir->nfile.fd; + char *fname; + int f; + +- /* +- * We suppress interrupts so that we won't leave open file +- * descriptors around. This may not be such a good idea because +- * an open of a device or a fifo can block indefinitely. +- */ +- INTOFF; +- memory[fd] = 0; + switch (redir->nfile.type) { + case NFROM: + fname = redir->nfile.expfname; +@@ -199,6 +211,14 @@ + goto ecreate; + break; + case NTO: ++ /* Take care of noclobber mode. */ ++ if (Cflag) { ++ fname = redir->nfile.expfname; ++ if ((f = noclobberopen(fname)) < 0) ++ goto ecreate; ++ break; ++ } ++ case NTOOV: + fname = redir->nfile.expfname; + #ifdef O_CREAT + if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0) +@@ -222,32 +242,48 @@ + break; + case NTOFD: + case NFROMFD: ++ f = -1; ++ break; ++ case NHERE: ++ case NXHERE: ++ f = openhere(redir); ++ break; ++ default: ++ abort(); ++ } ++ ++ return f; ++ecreate: ++ error("cannot create %s: %s", fname, errmsg(errno, E_CREAT)); ++eopen: ++ error("cannot open %s: %s", fname, errmsg(errno, E_OPEN)); ++} ++ ++ ++STATIC void ++dupredirect(redir, f, memory) ++ union node *redir; ++ int f; ++ char memory[10]; ++ { ++ int fd = redir->nfile.fd; ++ ++ memory[fd] = 0; ++ if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) { + if (redir->ndup.dupfd >= 0) { /* if not ">&-" */ + if (memory[redir->ndup.dupfd]) + memory[fd] = 1; + else + copyfd(redir->ndup.dupfd, fd); + } +- INTON; + return; +- case NHERE: +- case NXHERE: +- f = openhere(redir); +- break; +- default: +- abort(); + } + + if (f != fd) { + copyfd(f, fd); + close(f); + } +- INTON; + return; +-ecreate: +- error("cannot create %s: %s", fname, errmsg(errno, E_CREAT)); +-eopen: +- error("cannot open %s: %s", fname, errmsg(errno, E_OPEN)); + } + + +@@ -304,6 +340,7 @@ + struct redirtab *rp = redirlist; + int i; + ++ INTOFF; + for (i = 0 ; i < 10 ; i++) { + if (rp->renamed[i] != EMPTY) { + if (i == 0) +@@ -313,9 +350,11 @@ + copyfd(rp->renamed[i], i); + close(rp->renamed[i]); + } ++ if (rp->renamed[i] == fd2) { ++ fd2 = i; ++ } + } + } +- INTOFF; + redirlist = rp->next; + ckfree(rp); + INTON; +@@ -359,6 +398,9 @@ + for (i = 0 ; i < 10 ; i++) { + if (rp->renamed[i] >= 0) { + close(rp->renamed[i]); ++ if (rp->renamed[i] == fd2) { ++ fd2 = -1; ++ } + } + rp->renamed[i] = EMPTY; + } +@@ -388,4 +430,63 @@ + error("%d: %s", from, strerror(errno)); + } + return newfd; ++} ++ ++/* ++ * Open a file in noclobber mode. ++ * The code was copied from bash. ++ */ ++int ++noclobberopen(fname) ++ const char *fname; ++{ ++ int r, fd; ++ struct stat finfo, finfo2; ++ ++ /* ++ * If the file exists and is a regular file, return an error ++ * immediately. ++ */ ++ r = stat(fname, &finfo); ++ if (r == 0 && S_ISREG(finfo.st_mode)) { ++ errno = EEXIST; ++ return -1; ++ } ++ ++ /* ++ * If the file was not present (r != 0), make sure we open it ++ * exclusively so that if it is created before we open it, our open ++ * will fail. Make sure that we do not truncate an existing file. ++ * Note that we don't turn on O_EXCL unless the stat failed -- if the ++ * file was not a regular file, we leave O_EXCL off. ++ */ ++ if (r != 0) ++ return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666); ++ fd = open(fname, O_WRONLY|O_CREAT, 0666); ++ ++ /* If the open failed, return the file descriptor right away. */ ++ if (fd < 0) ++ return fd; ++ ++ /* ++ * OK, the open succeeded, but the file may have been changed from a ++ * non-regular file to a regular file between the stat and the open. ++ * We are assuming that the O_EXCL open handles the case where FILENAME ++ * did not exist and is symlinked to an existing file between the stat ++ * and open. ++ */ ++ ++ /* ++ * If we can open it and fstat the file descriptor, and neither check ++ * revealed that it was a regular file, and the file has not been ++ * replaced, return the file descriptor. ++ */ ++ if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) && ++ finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino) ++ return fd; ++ ++ /* The file has been replaced. badness. */ ++ close(fd); ++ errno = EEXIST; ++ return -1; + } +Only in netbsd-sh-: redir.c.orig +diff -ur netbsd-sh/redir.h netbsd-sh-/redir.h +--- netbsd-sh/redir.h Tue May 23 12:03:19 2000 ++++ netbsd-sh-/redir.h Mon Apr 23 23:33:34 2001 +@@ -42,6 +42,8 @@ + #define REDIR_PUSH 01 /* save previous values of file descriptors */ + #define REDIR_BACKQ 02 /* save the command output in memory */ + ++extern int fd2; ++ + union node; + void redirect __P((union node *, int)); + void popredir __P((void)); +diff -ur netbsd-sh/show.c netbsd-sh-/show.c +--- netbsd-sh/show.c Sat Oct 9 13:02:09 1999 ++++ netbsd-sh-/show.c Mon Apr 23 23:33:34 2001 +@@ -155,6 +155,7 @@ + case NTO: s = ">"; dftfd = 1; break; + case NAPPEND: s = ">>"; dftfd = 1; break; + case NTOFD: s = ">&"; dftfd = 1; break; ++ case NTOOV: s = ">|"; dftfd = 1; break; + case NFROM: s = "<"; dftfd = 0; break; + case NFROMFD: s = "<&"; dftfd = 0; break; + case NFROMTO: s = "<>"; dftfd = 0; break; diff --git a/source/ap/ash/patches/ash-setmode.patch b/source/ap/ash/patches/ash-setmode.patch new file mode 100644 index 000000000..b9a26d9ca --- /dev/null +++ b/source/ap/ash/patches/ash-setmode.patch @@ -0,0 +1,510 @@ +diff -urN netbsd-sh/miscbltin.c ash-0.3.7.orig/miscbltin.c +--- netbsd-sh/miscbltin.c Fri Jan 12 17:50:37 2001 ++++ ash-0.3.7.orig/miscbltin.c Mon Apr 23 22:16:46 2001 +@@ -70,6 +70,15 @@ + + #undef rflag + ++#ifdef __GLIBC__ ++mode_t getmode(const void *, mode_t); ++void *setmode(const char *); ++ ++#if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1 ++typedef enum __rlimit_resource rlim_t; ++#endif ++#endif ++ + extern char **argptr; /* argument list for builtin command */ + + +diff -urN netbsd-sh/setmode.c ash-0.3.7.orig/setmode.c +--- netbsd-sh/setmode.c Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/setmode.c Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,486 @@ ++/* $NetBSD: setmode.c,v 1.28 2000/01/25 15:43:43 enami Exp $ */ ++ ++/* ++ * Copyright (c) 1989, 1993, 1994 ++ * The Regents of the University of California. All rights reserved. ++ * ++ * This code is derived from software contributed to Berkeley by ++ * Dave Borman at Cray Research, Inc. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * This product includes software developed by the University of ++ * California, Berkeley and its contributors. ++ * 4. Neither the name of the University nor the names of its contributors ++ * may be used to endorse or promote products derived from this software ++ * without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ */ ++ ++#include <sys/cdefs.h> ++#if defined(LIBC_SCCS) && !defined(lint) ++#if 0 ++static char sccsid[] = "@(#)setmode.c 8.2 (Berkeley) 3/25/94"; ++#else ++__RCSID("$NetBSD: setmode.c,v 1.28 2000/01/25 15:43:43 enami Exp $"); ++#endif ++#endif /* LIBC_SCCS and not lint */ ++ ++#include <sys/types.h> ++#include <sys/stat.h> ++ ++#include <assert.h> ++#include <ctype.h> ++#include <errno.h> ++#include <signal.h> ++#include <stdlib.h> ++#include <unistd.h> ++ ++#ifdef SETMODE_DEBUG ++#include <stdio.h> ++#endif ++ ++#ifdef __weak_alias ++__weak_alias(getmode,_getmode) ++__weak_alias(setmode,_setmode) ++#endif ++ ++#ifdef __GLIBC__ ++#define S_ISTXT __S_ISVTX ++#endif ++ ++#define SET_LEN 6 /* initial # of bitcmd struct to malloc */ ++#define SET_LEN_INCR 4 /* # of bitcmd structs to add as needed */ ++ ++typedef struct bitcmd { ++ char cmd; ++ char cmd2; ++ mode_t bits; ++} BITCMD; ++ ++#define CMD2_CLR 0x01 ++#define CMD2_SET 0x02 ++#define CMD2_GBITS 0x04 ++#define CMD2_OBITS 0x08 ++#define CMD2_UBITS 0x10 ++ ++static BITCMD *addcmd __P((BITCMD *, int, int, int, u_int)); ++static void compress_mode __P((BITCMD *)); ++#ifdef SETMODE_DEBUG ++static void dumpmode __P((BITCMD *)); ++#endif ++ ++/* ++ * Given the old mode and an array of bitcmd structures, apply the operations ++ * described in the bitcmd structures to the old mode, and return the new mode. ++ * Note that there is no '=' command; a strict assignment is just a '-' (clear ++ * bits) followed by a '+' (set bits). ++ */ ++mode_t ++getmode(bbox, omode) ++ const void *bbox; ++ mode_t omode; ++{ ++ const BITCMD *set; ++ mode_t clrval, newmode, value; ++ ++ _DIAGASSERT(bbox != NULL); ++ ++ set = (const BITCMD *)bbox; ++ newmode = omode; ++ for (value = 0;; set++) ++ switch(set->cmd) { ++ /* ++ * When copying the user, group or other bits around, we "know" ++ * where the bits are in the mode so that we can do shifts to ++ * copy them around. If we don't use shifts, it gets real ++ * grundgy with lots of single bit checks and bit sets. ++ */ ++ case 'u': ++ value = (newmode & S_IRWXU) >> 6; ++ goto common; ++ ++ case 'g': ++ value = (newmode & S_IRWXG) >> 3; ++ goto common; ++ ++ case 'o': ++ value = newmode & S_IRWXO; ++common: if (set->cmd2 & CMD2_CLR) { ++ clrval = ++ (set->cmd2 & CMD2_SET) ? S_IRWXO : value; ++ if (set->cmd2 & CMD2_UBITS) ++ newmode &= ~((clrval<<6) & set->bits); ++ if (set->cmd2 & CMD2_GBITS) ++ newmode &= ~((clrval<<3) & set->bits); ++ if (set->cmd2 & CMD2_OBITS) ++ newmode &= ~(clrval & set->bits); ++ } ++ if (set->cmd2 & CMD2_SET) { ++ if (set->cmd2 & CMD2_UBITS) ++ newmode |= (value<<6) & set->bits; ++ if (set->cmd2 & CMD2_GBITS) ++ newmode |= (value<<3) & set->bits; ++ if (set->cmd2 & CMD2_OBITS) ++ newmode |= value & set->bits; ++ } ++ break; ++ ++ case '+': ++ newmode |= set->bits; ++ break; ++ ++ case '-': ++ newmode &= ~set->bits; ++ break; ++ ++ case 'X': ++ if (omode & (S_IFDIR|S_IXUSR|S_IXGRP|S_IXOTH)) ++ newmode |= set->bits; ++ break; ++ ++ case '\0': ++ default: ++#ifdef SETMODE_DEBUG ++ (void)printf("getmode:%04o -> %04o\n", omode, newmode); ++#endif ++ return (newmode); ++ } ++} ++ ++#define ADDCMD(a, b, c, d) do { \ ++ if (set >= endset) { \ ++ BITCMD *newset; \ ++ setlen += SET_LEN_INCR; \ ++ newset = realloc(saveset, sizeof(BITCMD) * setlen); \ ++ if (newset == NULL) { \ ++ free(saveset); \ ++ return (NULL); \ ++ } \ ++ set = newset + (set - saveset); \ ++ saveset = newset; \ ++ endset = newset + (setlen - 2); \ ++ } \ ++ set = addcmd(set, (a), (b), (c), (d)); \ ++} while (/*CONSTCOND*/0) ++ ++#define STANDARD_BITS (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO) ++ ++void * ++setmode(p) ++ const char *p; ++{ ++ int perm, who; ++ char op, *ep; ++ BITCMD *set, *saveset, *endset; ++ sigset_t sigset, sigoset; ++ mode_t mask; ++ int equalopdone = 0; /* pacify gcc */ ++ int permXbits, setlen; ++ ++ if (!*p) ++ return (NULL); ++ ++ /* ++ * Get a copy of the mask for the permissions that are mask relative. ++ * Flip the bits, we want what's not set. Since it's possible that ++ * the caller is opening files inside a signal handler, protect them ++ * as best we can. ++ */ ++ sigfillset(&sigset); ++ (void)sigprocmask(SIG_BLOCK, &sigset, &sigoset); ++ (void)umask(mask = umask(0)); ++ mask = ~mask; ++ (void)sigprocmask(SIG_SETMASK, &sigoset, NULL); ++ ++ setlen = SET_LEN + 2; ++ ++ if ((set = malloc((u_int)(sizeof(BITCMD) * setlen))) == NULL) ++ return (NULL); ++ saveset = set; ++ endset = set + (setlen - 2); ++ ++ /* ++ * If an absolute number, get it and return; disallow non-octal digits ++ * or illegal bits. ++ */ ++ if (isdigit((unsigned char)*p)) { ++ perm = (mode_t)strtol(p, &ep, 8); ++ if (*ep || perm & ~(STANDARD_BITS|S_ISTXT)) { ++ free(saveset); ++ return (NULL); ++ } ++ ADDCMD('=', (STANDARD_BITS|S_ISTXT), perm, mask); ++ set->cmd = 0; ++ return (saveset); ++ } ++ ++ /* ++ * Build list of structures to set/clear/copy bits as described by ++ * each clause of the symbolic mode. ++ */ ++ for (;;) { ++ /* First, find out which bits might be modified. */ ++ for (who = 0;; ++p) { ++ switch (*p) { ++ case 'a': ++ who |= STANDARD_BITS; ++ break; ++ case 'u': ++ who |= S_ISUID|S_IRWXU; ++ break; ++ case 'g': ++ who |= S_ISGID|S_IRWXG; ++ break; ++ case 'o': ++ who |= S_IRWXO; ++ break; ++ default: ++ goto getop; ++ } ++ } ++ ++getop: if ((op = *p++) != '+' && op != '-' && op != '=') { ++ free(saveset); ++ return (NULL); ++ } ++ if (op == '=') ++ equalopdone = 0; ++ ++ who &= ~S_ISTXT; ++ for (perm = 0, permXbits = 0;; ++p) { ++ switch (*p) { ++ case 'r': ++ perm |= S_IRUSR|S_IRGRP|S_IROTH; ++ break; ++ case 's': ++ /* ++ * If specific bits where requested and ++ * only "other" bits ignore set-id. ++ */ ++ if (who == 0 || (who & ~S_IRWXO)) ++ perm |= S_ISUID|S_ISGID; ++ break; ++ case 't': ++ /* ++ * If specific bits where requested and ++ * only "other" bits ignore set-id. ++ */ ++ if (who == 0 || (who & ~S_IRWXO)) { ++ who |= S_ISTXT; ++ perm |= S_ISTXT; ++ } ++ break; ++ case 'w': ++ perm |= S_IWUSR|S_IWGRP|S_IWOTH; ++ break; ++ case 'X': ++ permXbits = S_IXUSR|S_IXGRP|S_IXOTH; ++ break; ++ case 'x': ++ perm |= S_IXUSR|S_IXGRP|S_IXOTH; ++ break; ++ case 'u': ++ case 'g': ++ case 'o': ++ /* ++ * When ever we hit 'u', 'g', or 'o', we have ++ * to flush out any partial mode that we have, ++ * and then do the copying of the mode bits. ++ */ ++ if (perm) { ++ ADDCMD(op, who, perm, mask); ++ perm = 0; ++ } ++ if (op == '=') ++ equalopdone = 1; ++ if (op == '+' && permXbits) { ++ ADDCMD('X', who, permXbits, mask); ++ permXbits = 0; ++ } ++ ADDCMD(*p, who, op, mask); ++ break; ++ ++ default: ++ /* ++ * Add any permissions that we haven't already ++ * done. ++ */ ++ if (perm || (op == '=' && !equalopdone)) { ++ if (op == '=') ++ equalopdone = 1; ++ ADDCMD(op, who, perm, mask); ++ perm = 0; ++ } ++ if (permXbits) { ++ ADDCMD('X', who, permXbits, mask); ++ permXbits = 0; ++ } ++ goto apply; ++ } ++ } ++ ++apply: if (!*p) ++ break; ++ if (*p != ',') ++ goto getop; ++ ++p; ++ } ++ set->cmd = 0; ++#ifdef SETMODE_DEBUG ++ (void)printf("Before compress_mode()\n"); ++ dumpmode(saveset); ++#endif ++ compress_mode(saveset); ++#ifdef SETMODE_DEBUG ++ (void)printf("After compress_mode()\n"); ++ dumpmode(saveset); ++#endif ++ return (saveset); ++} ++ ++static BITCMD * ++addcmd(set, op, who, oparg, mask) ++ BITCMD *set; ++ int oparg, who; ++ int op; ++ u_int mask; ++{ ++ ++ _DIAGASSERT(set != NULL); ++ ++ switch (op) { ++ case '=': ++ set->cmd = '-'; ++ set->bits = who ? who : STANDARD_BITS; ++ set++; ++ ++ op = '+'; ++ /* FALLTHROUGH */ ++ case '+': ++ case '-': ++ case 'X': ++ set->cmd = op; ++ set->bits = (who ? who : mask) & oparg; ++ break; ++ ++ case 'u': ++ case 'g': ++ case 'o': ++ set->cmd = op; ++ if (who) { ++ set->cmd2 = ((who & S_IRUSR) ? CMD2_UBITS : 0) | ++ ((who & S_IRGRP) ? CMD2_GBITS : 0) | ++ ((who & S_IROTH) ? CMD2_OBITS : 0); ++ set->bits = (mode_t)~0; ++ } else { ++ set->cmd2 = CMD2_UBITS | CMD2_GBITS | CMD2_OBITS; ++ set->bits = mask; ++ } ++ ++ if (oparg == '+') ++ set->cmd2 |= CMD2_SET; ++ else if (oparg == '-') ++ set->cmd2 |= CMD2_CLR; ++ else if (oparg == '=') ++ set->cmd2 |= CMD2_SET|CMD2_CLR; ++ break; ++ } ++ return (set + 1); ++} ++ ++#ifdef SETMODE_DEBUG ++static void ++dumpmode(set) ++ BITCMD *set; ++{ ++ ++ _DIAGASSERT(set != NULL); ++ ++ for (; set->cmd; ++set) ++ (void)printf("cmd: '%c' bits %04o%s%s%s%s%s%s\n", ++ set->cmd, set->bits, set->cmd2 ? " cmd2:" : "", ++ set->cmd2 & CMD2_CLR ? " CLR" : "", ++ set->cmd2 & CMD2_SET ? " SET" : "", ++ set->cmd2 & CMD2_UBITS ? " UBITS" : "", ++ set->cmd2 & CMD2_GBITS ? " GBITS" : "", ++ set->cmd2 & CMD2_OBITS ? " OBITS" : ""); ++} ++#endif ++ ++/* ++ * Given an array of bitcmd structures, compress by compacting consecutive ++ * '+', '-' and 'X' commands into at most 3 commands, one of each. The 'u', ++ * 'g' and 'o' commands continue to be separate. They could probably be ++ * compacted, but it's not worth the effort. ++ */ ++static void ++compress_mode(set) ++ BITCMD *set; ++{ ++ BITCMD *nset; ++ int setbits, clrbits, Xbits, op; ++ ++ _DIAGASSERT(set != NULL); ++ ++ for (nset = set;;) { ++ /* Copy over any 'u', 'g' and 'o' commands. */ ++ while ((op = nset->cmd) != '+' && op != '-' && op != 'X') { ++ *set++ = *nset++; ++ if (!op) ++ return; ++ } ++ ++ for (setbits = clrbits = Xbits = 0;; nset++) { ++ if ((op = nset->cmd) == '-') { ++ clrbits |= nset->bits; ++ setbits &= ~nset->bits; ++ Xbits &= ~nset->bits; ++ } else if (op == '+') { ++ setbits |= nset->bits; ++ clrbits &= ~nset->bits; ++ Xbits &= ~nset->bits; ++ } else if (op == 'X') ++ Xbits |= nset->bits & ~setbits; ++ else ++ break; ++ } ++ if (clrbits) { ++ set->cmd = '-'; ++ set->cmd2 = 0; ++ set->bits = clrbits; ++ set++; ++ } ++ if (setbits) { ++ set->cmd = '+'; ++ set->cmd2 = 0; ++ set->bits = setbits; ++ set++; ++ } ++ if (Xbits) { ++ set->cmd = 'X'; ++ set->cmd2 = 0; ++ set->bits = Xbits; ++ set++; ++ } ++ } ++} + diff --git a/source/ap/ash/patches/ash-sighup.patch b/source/ap/ash/patches/ash-sighup.patch new file mode 100644 index 000000000..b4d1bc041 --- /dev/null +++ b/source/ap/ash/patches/ash-sighup.patch @@ -0,0 +1,18 @@ +--- ash-0.4.0/jobs.c.orig Tue Jul 3 19:10:28 2001 ++++ ash-0.4.0/jobs.c Tue Jul 3 19:12:11 2001 +@@ -712,6 +712,7 @@ + } else if (mode == FORK_BG) { + ignoresig(SIGINT); + ignoresig(SIGQUIT); ++ ignoresig(SIGHUP); + if ((jp == NULL || jp->nprocs == 0) && + ! fd0_redirected_p ()) { + close(0); +@@ -723,6 +724,7 @@ + if (mode == FORK_BG) { + ignoresig(SIGINT); + ignoresig(SIGQUIT); ++ ignoresig(SIGHUP); + if ((jp == NULL || jp->nprocs == 0) && + ! fd0_redirected_p ()) { + close(0); diff --git a/source/ap/ash/patches/ash-syntax.patch b/source/ap/ash/patches/ash-syntax.patch new file mode 100644 index 000000000..43ce78660 --- /dev/null +++ b/source/ap/ash/patches/ash-syntax.patch @@ -0,0 +1,270 @@ +diff -urN netbsd-sh/mksyntax.c ash-0.3.7.orig/mksyntax.c +--- netbsd-sh/mksyntax.c Fri Jan 12 17:50:38 2001 ++++ ash-0.3.7.orig/mksyntax.c Mon Apr 23 22:16:46 2001 +@@ -238,14 +238,14 @@ + add("$", "CVAR"); + add("}", "CENDVAR"); + /* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */ +- add("!*?[=~:/-", "CCTL"); ++ add("!*?[=~:/-]", "CCTL"); + print("dqsyntax"); + init(); + fputs("\n/* syntax table used when in single quotes */\n", cfile); + add("\n", "CNL"); + add("'", "CENDQUOTE"); + /* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */ +- add("!*?[=~:/-", "CCTL"); ++ add("!*?[=~:/-]\\", "CCTL"); + print("sqsyntax"); + init(); + fputs("\n/* syntax table used when in arithmetic */\n", cfile); +diff -urN netbsd-sh/parser.c ash-0.3.7.orig/parser.c +--- netbsd-sh/parser.c Fri Jan 12 17:50:39 2001 ++++ ash-0.3.7.orig/parser.c Mon Apr 23 22:16:46 2001 +@@ -221,6 +221,7 @@ + union node *n1, *n2, *n3; + int t; + ++ checkkwd = 1; + n1 = pipeline(); + for (;;) { + if ((t = readtoken()) == TAND) { +@@ -231,6 +232,7 @@ + tokpushback++; + return n1; + } ++ checkkwd = 2; + n2 = pipeline(); + n3 = (union node *)stalloc(sizeof (struct nbinary)); + n3->type = t; +@@ -250,9 +252,11 @@ + + negate = 0; + TRACE(("pipeline: entered\n")); +- while (readtoken() == TNOT) ++ if (readtoken() == TNOT) { + negate = !negate; +- tokpushback++; ++ checkkwd = 1; ++ } else ++ tokpushback++; + n1 = command(); + if (readtoken() == TPIPE) { + pipenode = (union node *)stalloc(sizeof (struct npipe)); +@@ -264,6 +268,7 @@ + do { + prev = lp; + lp = (struct nodelist *)stalloc(sizeof (struct nodelist)); ++ checkkwd = 2; + lp->n = command(); + prev->next = lp; + } while (readtoken() == TPIPE); +@@ -288,9 +293,8 @@ + union node *ap, **app; + union node *cp, **cpp; + union node *redir, **rpp; +- int t, negate = 0; ++ int t; + +- checkkwd = 2; + redir = NULL; + n1 = NULL; + rpp = &redir; +@@ -303,12 +307,6 @@ + } + tokpushback++; + +- while (readtoken() == TNOT) { +- TRACE(("command: TNOT recognized\n")); +- negate = !negate; +- } +- tokpushback++; +- + switch (readtoken()) { + case TIF: + n1 = (union node *)stalloc(sizeof (struct nif)); +@@ -417,6 +415,8 @@ + cpp = &n1->ncase.cases; + checkkwd = 2, readtoken(); + do { ++ if (lasttoken == TLP) ++ readtoken(); + *cpp = cp = (union node *)stalloc(sizeof (struct nclist)); + cp->type = NCLIST; + app = &cp->nclist.pattern; +@@ -464,21 +464,22 @@ + break; + /* Handle an empty command like other simple commands. */ + case TSEMI: ++ case TAND: ++ case TOR: ++ case TNL: ++ case TEOF: ++ case TRP: ++ case TBACKGND: + /* + * An empty command before a ; doesn't make much sense, and + * should certainly be disallowed in the case of `if ;'. + */ + if (!redir) + synexpect(-1); +- case TAND: +- case TOR: +- case TNL: +- case TEOF: + case TWORD: +- case TRP: + tokpushback++; + n1 = simplecmd(rpp, redir); +- goto checkneg; ++ return n1; + default: + synexpect(-1); + /* NOTREACHED */ +@@ -502,15 +503,7 @@ + n1->nredir.redirect = redir; + } + +-checkneg: +- if (negate) { +- n2 = (union node *)stalloc(sizeof (struct nnot)); +- n2->type = NNOT; +- n2->nnot.com = n1; +- return n2; +- } +- else +- return n1; ++ return n1; + } + + +@@ -520,8 +513,7 @@ + { + union node *args, **app; + union node **orig_rpp = rpp; +- union node *n = NULL, *n2; +- int negate = 0; ++ union node *n = NULL; + + /* If we don't have any redirections already, then we must reset */ + /* rpp to be the address of the local redir variable. */ +@@ -537,12 +529,6 @@ + */ + orig_rpp = rpp; + +- while (readtoken() == TNOT) { +- TRACE(("command: TNOT recognized\n")); +- negate = !negate; +- } +- tokpushback++; +- + for (;;) { + if (readtoken() == TWORD) { + n = (union node *)stalloc(sizeof (struct narg)); +@@ -565,8 +551,9 @@ + synerror("Bad function name"); + #endif + n->type = NDEFUN; ++ checkkwd = 2; + n->narg.next = command(); +- goto checkneg; ++ return n; + } else { + tokpushback++; + break; +@@ -579,16 +566,7 @@ + n->ncmd.backgnd = 0; + n->ncmd.args = args; + n->ncmd.redirect = redir; +- +-checkneg: +- if (negate) { +- n2 = (union node *)stalloc(sizeof (struct nnot)); +- n2->type = NNOT; +- n2->nnot.com = n; +- return n2; +- } +- else +- return n; ++ return n; + } + + STATIC union node * +@@ -743,7 +721,7 @@ + } + } + out: +- checkkwd = (t == TNOT) ? savecheckkwd : 0; ++ checkkwd = 0; + } + #ifdef DEBUG + if (!alreadyseen) +@@ -882,6 +860,7 @@ + int varnest; /* levels of variables expansion */ + int arinest; /* levels of arithmetic expansion */ + int parenlevel; /* levels of parens in arithmetic */ ++ int dqvarnest; /* levels of variables expansion within double quotes */ + int oldstyle; + char const *prevsyntax; /* syntax before arithmetic */ + #if __GNUC__ +@@ -892,6 +871,7 @@ + (void) &varnest; + (void) &arinest; + (void) &parenlevel; ++ (void) &dqvarnest; + (void) &oldstyle; + (void) &prevsyntax; + (void) &syntax; +@@ -906,6 +886,7 @@ + varnest = 0; + arinest = 0; + parenlevel = 0; ++ dqvarnest = 0; + + STARTSTACKSTR(out); + loop: { /* for each line, until end of word */ +@@ -938,7 +919,8 @@ + USTPUTC(c, out); + break; + case CCTL: +- if (eofmark == NULL || dblquote) ++ if ((eofmark == NULL || dblquote) && ++ dqvarnest == 0) + USTPUTC(CTLESC, out); + USTPUTC(c, out); + break; +@@ -983,7 +965,8 @@ + if (arinest) { + syntax = ARISYNTAX; + dblquote = 0; +- } else if (eofmark == NULL) { ++ } else if (eofmark == NULL && ++ dqvarnest == 0) { + syntax = BASESYNTAX; + dblquote = 0; + } +@@ -996,6 +979,9 @@ + case CENDVAR: /* '}' */ + if (varnest > 0) { + varnest--; ++ if (dqvarnest > 0) { ++ dqvarnest--; ++ } + USTPUTC(CTLENDVAR, out); + } else { + USTPUTC(c, out); +@@ -1260,8 +1248,12 @@ + if (dblquote || arinest) + flags |= VSQUOTE; + *(stackblock() + typeloc) = subtype | flags; +- if (subtype != VSNORMAL) ++ if (subtype != VSNORMAL) { + varnest++; ++ if (dblquote) { ++ dqvarnest++; ++ } ++ } + } + goto parsesub_return; + } + diff --git a/source/ap/ash/patches/ash-test.patch b/source/ap/ash/patches/ash-test.patch new file mode 100644 index 000000000..14c9f6802 --- /dev/null +++ b/source/ap/ash/patches/ash-test.patch @@ -0,0 +1,588 @@ +diff -urN netbsd-sh/bltin/test.c ash-0.3.7.orig/bltin/test.c +--- netbsd-sh/bltin/test.c Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/bltin/test.c Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,583 @@ ++/* $NetBSD: test.c,v 1.22 2000/04/09 23:24:59 christos Exp $ */ ++ ++/* ++ * test(1); version 7-like -- author Erik Baalbergen ++ * modified by Eric Gisin to be used as built-in. ++ * modified by Arnold Robbins to add SVR3 compatibility ++ * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket). ++ * modified by J.T. Conklin for NetBSD. ++ * ++ * This program is in the Public Domain. ++ */ ++ ++#include <sys/cdefs.h> ++#ifndef lint ++__RCSID("$NetBSD: test.c,v 1.22 2000/04/09 23:24:59 christos Exp $"); ++#endif ++ ++#include <sys/types.h> ++#include <sys/stat.h> ++#include <unistd.h> ++#include <ctype.h> ++#include <errno.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#include <err.h> ++#ifdef __STDC__ ++#include <stdarg.h> ++#else ++#include <varargs.h> ++#endif ++ ++/* test(1) accepts the following grammar: ++ oexpr ::= aexpr | aexpr "-o" oexpr ; ++ aexpr ::= nexpr | nexpr "-a" aexpr ; ++ nexpr ::= primary | "!" primary ++ primary ::= unary-operator operand ++ | operand binary-operator operand ++ | operand ++ | "(" oexpr ")" ++ ; ++ unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"| ++ "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S"; ++ ++ binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| ++ "-nt"|"-ot"|"-ef"; ++ operand ::= <any legal UNIX file name> ++*/ ++ ++enum token { ++ EOI, ++ FILRD, ++ FILWR, ++ FILEX, ++ FILEXIST, ++ FILREG, ++ FILDIR, ++ FILCDEV, ++ FILBDEV, ++ FILFIFO, ++ FILSOCK, ++ FILSYM, ++ FILGZ, ++ FILTT, ++ FILSUID, ++ FILSGID, ++ FILSTCK, ++ FILNT, ++ FILOT, ++ FILEQ, ++ FILUID, ++ FILGID, ++ STREZ, ++ STRNZ, ++ STREQ, ++ STRNE, ++ STRLT, ++ STRGT, ++ INTEQ, ++ INTNE, ++ INTGE, ++ INTGT, ++ INTLE, ++ INTLT, ++ UNOT, ++ BAND, ++ BOR, ++ LPAREN, ++ RPAREN, ++ OPERAND ++}; ++ ++enum token_types { ++ UNOP, ++ BINOP, ++ BUNOP, ++ BBINOP, ++ PAREN ++}; ++ ++static struct t_op { ++ const char *op_text; ++ short op_num, op_type; ++} const ops [] = { ++ {"-r", FILRD, UNOP}, ++ {"-w", FILWR, UNOP}, ++ {"-x", FILEX, UNOP}, ++ {"-e", FILEXIST,UNOP}, ++ {"-f", FILREG, UNOP}, ++ {"-d", FILDIR, UNOP}, ++ {"-c", FILCDEV,UNOP}, ++ {"-b", FILBDEV,UNOP}, ++ {"-p", FILFIFO,UNOP}, ++ {"-u", FILSUID,UNOP}, ++ {"-g", FILSGID,UNOP}, ++ {"-k", FILSTCK,UNOP}, ++ {"-s", FILGZ, UNOP}, ++ {"-t", FILTT, UNOP}, ++ {"-z", STREZ, UNOP}, ++ {"-n", STRNZ, UNOP}, ++ {"-h", FILSYM, UNOP}, /* for backwards compat */ ++ {"-O", FILUID, UNOP}, ++ {"-G", FILGID, UNOP}, ++ {"-L", FILSYM, UNOP}, ++ {"-S", FILSOCK,UNOP}, ++ {"=", STREQ, BINOP}, ++ {"!=", STRNE, BINOP}, ++ {"<", STRLT, BINOP}, ++ {">", STRGT, BINOP}, ++ {"-eq", INTEQ, BINOP}, ++ {"-ne", INTNE, BINOP}, ++ {"-ge", INTGE, BINOP}, ++ {"-gt", INTGT, BINOP}, ++ {"-le", INTLE, BINOP}, ++ {"-lt", INTLT, BINOP}, ++ {"-nt", FILNT, BINOP}, ++ {"-ot", FILOT, BINOP}, ++ {"-ef", FILEQ, BINOP}, ++ {"!", UNOT, BUNOP}, ++ {"-a", BAND, BBINOP}, ++ {"-o", BOR, BBINOP}, ++ {"(", LPAREN, PAREN}, ++ {")", RPAREN, PAREN}, ++ {0, 0, 0} ++}; ++ ++static char **t_wp; ++static struct t_op const *t_wp_op; ++static gid_t *group_array = NULL; ++static int ngroups; ++ ++static void syntax __P((const char *, const char *)); ++static int oexpr __P((enum token)); ++static int aexpr __P((enum token)); ++static int nexpr __P((enum token)); ++static int primary __P((enum token)); ++static int binop __P((void)); ++static int filstat __P((char *, enum token)); ++static enum token t_lex __P((char *)); ++static int isoperand __P((void)); ++static int getn __P((const char *)); ++static int newerf __P((const char *, const char *)); ++static int olderf __P((const char *, const char *)); ++static int equalf __P((const char *, const char *)); ++static int test_eaccess(); ++static int bash_group_member(); ++static void initialize_group_array(); ++ ++#if defined(SHELL) ++extern void error __P((const char *, ...)) __attribute__((__noreturn__)); ++#else ++static void error __P((const char *, ...)) __attribute__((__noreturn__)); ++ ++static void ++#ifdef __STDC__ ++error(const char *msg, ...) ++#else ++error(va_alist) ++ va_dcl ++#endif ++{ ++ va_list ap; ++#ifndef __STDC__ ++ const char *msg; ++ ++ va_start(ap); ++ msg = va_arg(ap, const char *); ++#else ++ va_start(ap, msg); ++#endif ++ verrx(2, msg, ap); ++ /*NOTREACHED*/ ++ va_end(ap); ++} ++#endif ++ ++#ifdef SHELL ++int testcmd __P((int, char **)); ++ ++int ++testcmd(argc, argv) ++ int argc; ++ char **argv; ++#else ++int main __P((int, char **)); ++ ++int ++main(argc, argv) ++ int argc; ++ char **argv; ++#endif ++{ ++ int res; ++ ++ ++ if (strcmp(argv[0], "[") == 0) { ++ if (strcmp(argv[--argc], "]")) ++ error("missing ]"); ++ argv[argc] = NULL; ++ } ++ ++ if (argc < 2) ++ return 1; ++ ++ t_wp = &argv[1]; ++ res = !oexpr(t_lex(*t_wp)); ++ ++ if (*t_wp != NULL && *++t_wp != NULL) ++ syntax(*t_wp, "unexpected operator"); ++ ++ return res; ++} ++ ++static void ++syntax(op, msg) ++ const char *op; ++ const char *msg; ++{ ++ if (op && *op) ++ error("%s: %s", op, msg); ++ else ++ error("%s", msg); ++} ++ ++static int ++oexpr(n) ++ enum token n; ++{ ++ int res; ++ ++ res = aexpr(n); ++ if (t_lex(*++t_wp) == BOR) ++ return oexpr(t_lex(*++t_wp)) || res; ++ t_wp--; ++ return res; ++} ++ ++static int ++aexpr(n) ++ enum token n; ++{ ++ int res; ++ ++ res = nexpr(n); ++ if (t_lex(*++t_wp) == BAND) ++ return aexpr(t_lex(*++t_wp)) && res; ++ t_wp--; ++ return res; ++} ++ ++static int ++nexpr(n) ++ enum token n; /* token */ ++{ ++ if (n == UNOT) ++ return !nexpr(t_lex(*++t_wp)); ++ return primary(n); ++} ++ ++static int ++primary(n) ++ enum token n; ++{ ++ enum token nn; ++ int res; ++ ++ if (n == EOI) ++ return 0; /* missing expression */ ++ if (n == LPAREN) { ++ if ((nn = t_lex(*++t_wp)) == RPAREN) ++ return 0; /* missing expression */ ++ res = oexpr(nn); ++ if (t_lex(*++t_wp) != RPAREN) ++ syntax(NULL, "closing paren expected"); ++ return res; ++ } ++ if (t_wp_op && t_wp_op->op_type == UNOP) { ++ /* unary expression */ ++ if (*++t_wp == NULL) ++ syntax(t_wp_op->op_text, "argument expected"); ++ switch (n) { ++ case STREZ: ++ return strlen(*t_wp) == 0; ++ case STRNZ: ++ return strlen(*t_wp) != 0; ++ case FILTT: ++ return isatty(getn(*t_wp)); ++ default: ++ return filstat(*t_wp, n); ++ } ++ } ++ ++ if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) { ++ return binop(); ++ } ++ ++ return strlen(*t_wp) > 0; ++} ++ ++static int ++binop() ++{ ++ const char *opnd1, *opnd2; ++ struct t_op const *op; ++ ++ opnd1 = *t_wp; ++ (void) t_lex(*++t_wp); ++ op = t_wp_op; ++ ++ if ((opnd2 = *++t_wp) == (char *)0) ++ syntax(op->op_text, "argument expected"); ++ ++ switch (op->op_num) { ++ case STREQ: ++ return strcmp(opnd1, opnd2) == 0; ++ case STRNE: ++ return strcmp(opnd1, opnd2) != 0; ++ case STRLT: ++ return strcmp(opnd1, opnd2) < 0; ++ case STRGT: ++ return strcmp(opnd1, opnd2) > 0; ++ case INTEQ: ++ return getn(opnd1) == getn(opnd2); ++ case INTNE: ++ return getn(opnd1) != getn(opnd2); ++ case INTGE: ++ return getn(opnd1) >= getn(opnd2); ++ case INTGT: ++ return getn(opnd1) > getn(opnd2); ++ case INTLE: ++ return getn(opnd1) <= getn(opnd2); ++ case INTLT: ++ return getn(opnd1) < getn(opnd2); ++ case FILNT: ++ return newerf (opnd1, opnd2); ++ case FILOT: ++ return olderf (opnd1, opnd2); ++ case FILEQ: ++ return equalf (opnd1, opnd2); ++ default: ++ abort(); ++ /* NOTREACHED */ ++ } ++} ++ ++static int ++filstat(nm, mode) ++ char *nm; ++ enum token mode; ++{ ++ struct stat s; ++ ++ if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s)) ++ return 0; ++ ++ switch (mode) { ++ case FILRD: ++ return test_eaccess(nm, R_OK) == 0; ++ case FILWR: ++ return test_eaccess(nm, W_OK) == 0; ++ case FILEX: ++ return test_eaccess(nm, X_OK) == 0; ++ case FILEXIST: ++ return 1; ++ case FILREG: ++ return S_ISREG(s.st_mode); ++ case FILDIR: ++ return S_ISDIR(s.st_mode); ++ case FILCDEV: ++ return S_ISCHR(s.st_mode); ++ case FILBDEV: ++ return S_ISBLK(s.st_mode); ++ case FILFIFO: ++ return S_ISFIFO(s.st_mode); ++ case FILSOCK: ++ return S_ISSOCK(s.st_mode); ++ case FILSYM: ++ return S_ISLNK(s.st_mode); ++ case FILSUID: ++ return (s.st_mode & S_ISUID) != 0; ++ case FILSGID: ++ return (s.st_mode & S_ISGID) != 0; ++ case FILSTCK: ++ return (s.st_mode & S_ISVTX) != 0; ++ case FILGZ: ++ return s.st_size > (off_t)0; ++ case FILUID: ++ return s.st_uid == geteuid(); ++ case FILGID: ++ return s.st_gid == getegid(); ++ default: ++ return 1; ++ } ++} ++ ++static enum token ++t_lex(s) ++ char *s; ++{ ++ struct t_op const *op = ops; ++ ++ if (s == 0) { ++ t_wp_op = (struct t_op *)0; ++ return EOI; ++ } ++ while (op->op_text) { ++ if (strcmp(s, op->op_text) == 0) { ++ if ((op->op_type == UNOP && isoperand()) || ++ (op->op_num == LPAREN && *(t_wp+1) == 0)) ++ break; ++ t_wp_op = op; ++ return op->op_num; ++ } ++ op++; ++ } ++ t_wp_op = (struct t_op *)0; ++ return OPERAND; ++} ++ ++static int ++isoperand() ++{ ++ struct t_op const *op = ops; ++ char *s; ++ char *t; ++ ++ if ((s = *(t_wp+1)) == 0) ++ return 1; ++ if ((t = *(t_wp+2)) == 0) ++ return 0; ++ while (op->op_text) { ++ if (strcmp(s, op->op_text) == 0) ++ return op->op_type == BINOP && ++ (t[0] != ')' || t[1] != '\0'); ++ op++; ++ } ++ return 0; ++} ++ ++/* atoi with error detection */ ++static int ++getn(s) ++ const char *s; ++{ ++ char *p; ++ long r; ++ ++ errno = 0; ++ r = strtol(s, &p, 10); ++ ++ if (errno != 0) ++ error("%s: out of range", s); ++ ++ while (isspace((unsigned char)*p)) ++ p++; ++ ++ if (*p) ++ error("%s: bad number", s); ++ ++ return (int) r; ++} ++ ++static int ++newerf (f1, f2) ++const char *f1, *f2; ++{ ++ struct stat b1, b2; ++ ++ return (stat (f1, &b1) == 0 && ++ stat (f2, &b2) == 0 && ++ b1.st_mtime > b2.st_mtime); ++} ++ ++static int ++olderf (f1, f2) ++const char *f1, *f2; ++{ ++ struct stat b1, b2; ++ ++ return (stat (f1, &b1) == 0 && ++ stat (f2, &b2) == 0 && ++ b1.st_mtime < b2.st_mtime); ++} ++ ++static int ++equalf (f1, f2) ++const char *f1, *f2; ++{ ++ struct stat b1, b2; ++ ++ return (stat (f1, &b1) == 0 && ++ stat (f2, &b2) == 0 && ++ b1.st_dev == b2.st_dev && ++ b1.st_ino == b2.st_ino); ++} ++ ++/* Do the same thing access(2) does, but use the effective uid and gid, ++ and don't make the mistake of telling root that any file is ++ executable. */ ++static int ++test_eaccess (path, mode) ++char *path; ++int mode; ++{ ++ struct stat st; ++ int euid = geteuid(); ++ ++ if (stat (path, &st) < 0) ++ return (-1); ++ ++ if (euid == 0) { ++ /* Root can read or write any file. */ ++ if (mode != X_OK) ++ return (0); ++ ++ /* Root can execute any file that has any one of the execute ++ bits set. */ ++ if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) ++ return (0); ++ } ++ ++ if (st.st_uid == euid) /* owner */ ++ mode <<= 6; ++ else if (bash_group_member (st.st_gid)) ++ mode <<= 3; ++ ++ if (st.st_mode & mode) ++ return (0); ++ ++ return (-1); ++} ++ ++static void ++initialize_group_array () ++{ ++ ngroups = getgroups(0, NULL); ++ group_array = malloc(ngroups * sizeof(gid_t)); ++ if (!group_array) ++ error(strerror(ENOMEM)); ++ getgroups(ngroups, group_array); ++} ++ ++/* Return non-zero if GID is one that we have in our groups list. */ ++static int ++bash_group_member (gid) ++gid_t gid; ++{ ++ register int i; ++ ++ /* Short-circuit if possible, maybe saving a call to getgroups(). */ ++ if (gid == getgid() || gid == getegid()) ++ return (1); ++ ++ if (ngroups == 0) ++ initialize_group_array (); ++ ++ /* Search through the list looking for GID. */ ++ for (i = 0; i < ngroups; i++) ++ if (gid == group_array[i]) ++ return (1); ++ ++ return (0); ++} + diff --git a/source/ap/ash/patches/ash-times.patch b/source/ap/ash/patches/ash-times.patch new file mode 100644 index 000000000..4c24f9a66 --- /dev/null +++ b/source/ap/ash/patches/ash-times.patch @@ -0,0 +1,42 @@ +diff -urN netbsd-sh/bltin/times.c ash-0.3.7.orig/bltin/times.c +--- netbsd-sh/bltin/times.c Thu Jan 1 01:00:00 1970 ++++ ash-0.3.7.orig/bltin/times.c Mon Apr 23 22:16:46 2001 +@@ -0,0 +1,30 @@ ++#ifdef _GNU_SOURCE ++/* ++ * Copyright (c) 1999 Herbert Xu <herbert@debian.org> ++ * This file contains code for the times builtin. ++ * $Id: times.c,v 1.4 2000/04/01 09:23:02 herbert Exp $ ++ */ ++ ++#include <stdio.h> ++#include <sys/times.h> ++#include <unistd.h> ++ ++#define main timescmd ++ ++int main() { ++ struct tms buf; ++ long int clk_tck = sysconf(_SC_CLK_TCK); ++ ++ times(&buf); ++ printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n", ++ (int) (buf.tms_utime / clk_tck / 60), ++ ((double) buf.tms_utime) / clk_tck, ++ (int) (buf.tms_stime / clk_tck / 60), ++ ((double) buf.tms_stime) / clk_tck, ++ (int) (buf.tms_cutime / clk_tck / 60), ++ ((double) buf.tms_cutime) / clk_tck, ++ (int) (buf.tms_cstime / clk_tck / 60), ++ ((double) buf.tms_cstime) / clk_tck); ++ return 0; ++} ++#endif /* _GNU_SOURCE */ +diff -urN netbsd-sh/builtins.def ash-0.3.7.orig/builtins.def +--- netbsd-sh/builtins.def Mon Apr 10 13:02:58 2000 ++++ ash-0.3.7.orig/builtins.def Mon Apr 23 22:16:46 2001 +@@ -91,3 +93,4 @@ + aliascmd alias + ulimitcmd ulimit + testcmd test [ ++timescmd times |