diff options
| -rw-r--r-- | shell/ash.c | 13785 | ||||
| -rw-r--r-- | shell/cmdedit.c | 223 |
2 files changed, 7203 insertions, 6805 deletions
diff --git a/shell/ash.c b/shell/ash.c index 1a91f40..334dc22 100644 --- a/shell/ash.c +++ b/shell/ash.c @@ -24,27 +24,52 @@ * * This version of ash is adapted from the source in Debian's ash 0.3.8-5 * package. + * Maintainer Herbert Xu <herbert@debian.org> (C) 1997-2002 * - * Modified by Erik Andersen <andersen@codepoet.org> and - * Vladimir Oleynik <dzo@simtreas.ru> to be used in busybox + * Modified by Vladimir Oleynik <dzo@simtreas.ru> to be used in busybox * * * Original copyright notice is retained at the end of this file. */ +/* + * The follow should be set to reflect the type of system you have: + * JOBS -> 1 if you have Berkeley job control, 0 otherwise. + * define SYSV if you are running under System V. + * define DEBUG=1 to compile in debugging ('set -o debug' to turn on) + * define DEBUG=2 to compile in and turn on debugging. + * + * When debugging is on, debugging info will be written to ./trace and + * a quit signal will generate a core dump. + */ + -/* Enable this to compile in extra debugging noise. When debugging is - * on, debugging info will be written to $HOME/trace and a quit signal - * will generate a core dump. */ -#undef DEBUG -/* These are here to work with glibc -- Don't change these... */ -#undef FNMATCH_BROKEN -#undef GLOB_BROKEN #define IFS_BROKEN -#include <assert.h> +#define PROFILE 0 + +#ifdef DEBUG +#define _GNU_SOURCE +#endif + +#include <sys/types.h> +#include <sys/cdefs.h> +#include <sys/ioctl.h> +#include <sys/param.h> +#include <sys/resource.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/wait.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <stdarg.h> #include <stddef.h> +#include <assert.h> #include <ctype.h> #include <dirent.h> #include <errno.h> @@ -53,185 +78,122 @@ #include <paths.h> #include <setjmp.h> #include <signal.h> -#include <stdarg.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> +#include <stdint.h> #include <sysexits.h> -#include <unistd.h> -#include <sys/stat.h> -#include <sys/cdefs.h> -#include <sys/ioctl.h> -#include <sys/param.h> -#include <sys/resource.h> -#include <sys/time.h> -#include <sys/times.h> -#include <sys/types.h> -#include <sys/wait.h> -#include "busybox.h" -#include "pwd_.h" - -#if !defined(FNMATCH_BROKEN) #include <fnmatch.h> -#endif -#if !defined(GLOB_BROKEN) #include <glob.h> -#endif + + + +#include "busybox.h" +#include "pwd_.h" #ifdef CONFIG_ASH_JOB_CONTROL +#define JOBS 1 +#else +#undif JOBS +#endif + +#if JOBS #include <termios.h> #endif #include "cmdedit.h" +#ifdef __GLIBC__ +/* glibc sucks */ +static int *dash_errno; +#undef errno +#define errno (*dash_errno) +#endif + #if defined(__uClinux__) #error "Do not even bother, ash will not run on uClinux" #endif -/* - * This file was generated by the mksyntax program. - */ +#ifdef DEBUG +#define _DIAGASSERT(assert_expr) assert(assert_expr) +#else +#define _DIAGASSERT(assert_expr) +#endif -/* Syntax classes */ -#define CWORD 0 /* character is nothing special */ -#define CNL 1 /* newline character */ -#define CBACK 2 /* a backslash character */ -#define CSQUOTE 3 /* single quote */ -#define CDQUOTE 4 /* double quote */ -#define CENDQUOTE 5 /* a terminating quote */ -#define CBQUOTE 6 /* backwards single quote */ -#define CVAR 7 /* a dollar sign */ -#define CENDVAR 8 /* a '}' character */ -#define CLP 9 /* a left paren in arithmetic */ -#define CRP 10 /* a right paren in arithmetic */ -#define CENDFILE 11 /* end of file */ -#define CCTL 12 /* like CWORD, except it must be escaped */ -#define CSPCL 13 /* these terminate a word */ -#define CIGN 14 /* character should be ignored */ -#define SYNBASE 130 -#define PEOF -130 +#ifdef CONFIG_ASH_ALIAS +/* $NetBSD: alias.h,v 1.5 2002/11/24 22:35:38 christos Exp $ */ -#define PEOA -129 +#define ALIASINUSE 1 +#define ALIASDEAD 2 -#define TEOF 0 -#define TNL 1 -#define TREDIR 2 -#define TWORD 3 -#define TASSIGN 4 -#define TSEMI 5 -#define TBACKGND 6 -#define TAND 7 -#define TOR 8 -#define TPIPE 9 -#define TLP 10 -#define TRP 11 -#define TENDCASE 12 -#define TENDBQUOTE 13 -#define TNOT 14 -#define TCASE 15 -#define TDO 16 -#define TDONE 17 -#define TELIF 18 -#define TELSE 19 -#define TESAC 20 -#define TFI 21 -#define TFOR 22 -#define TIF 23 -#define TIN 24 -#define TTHEN 25 -#define TUNTIL 26 -#define TWHILE 27 -#define TBEGIN 28 -#define TEND 29 +struct alias { + struct alias *next; + char *name; + char *val; + int flag; +}; +static struct alias *lookupalias(const char *, int); +static int aliascmd(int, char **); +static int unaliascmd(int, char **); +static void rmaliases(void); +static int unalias(const char *); +static void printalias(const struct alias *); +#endif +/* $NetBSD: cd.h,v 1.3 2002/11/24 22:35:39 christos Exp $ */ -/* control characters in argument strings */ -#define CTLESC '\201' -#define CTLVAR '\202' -#define CTLENDVAR '\203' -#define CTLBACKQ '\204' -#define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */ -/* CTLBACKQ | CTLQUOTE == '\205' */ -#define CTLARI '\206' -#define CTLENDARI '\207' -#define CTLQUOTEMARK '\210' +static void setpwd(const char *, int); + +/* $NetBSD: error.h,v 1.15 2002/11/24 22:35:39 christos Exp $ */ -#define is_digit(c) ((c)>='0' && (c)<='9') -#define is_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalpha((unsigned char) (c)))) -#define is_in_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalnum((unsigned char) (c)))) /* - * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise - * (assuming ascii char codes, as the original implementation did) + * Types of operations (passed to the errmsg routine). */ -#define is_special(c) \ - ( (((unsigned int)c) - 33 < 32) \ - && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1)) - -#define digit_val(c) ((c) - '0') - -#define S_DFL 1 /* default signal handling (SIG_DFL) */ -#define S_CATCH 2 /* signal is caught */ -#define S_IGN 3 /* signal is ignored (SIG_IGN) */ -#define S_HARD_IGN 4 /* signal is ignored permenantly */ -#define S_RESET 5 /* temporary - to reset a hard ignored sig */ +static const char not_found_msg[] = "%s: not found"; -/* variable substitution byte (follows CTLVAR) */ -#define VSTYPE 0x0f /* type of variable substitution */ -#define VSNUL 0x10 /* colon--treat the empty string as unset */ -#define VSQUOTE 0x80 /* inside double quotes--suppress splitting */ - -/* values of VSTYPE field */ -#define VSNORMAL 0x1 /* normal variable: $var or ${var} */ -#define VSMINUS 0x2 /* ${var-text} */ -#define VSPLUS 0x3 /* ${var+text} */ -#define VSQUESTION 0x4 /* ${var?message} */ -#define VSASSIGN 0x5 /* ${var=text} */ -#define VSTRIMLEFT 0x6 /* ${var#pattern} */ -#define VSTRIMLEFTMAX 0x7 /* ${var##pattern} */ -#define VSTRIMRIGHT 0x8 /* ${var%pattern} */ -#define VSTRIMRIGHTMAX 0x9 /* ${var%%pattern} */ -#define VSLENGTH 0xa /* ${#var} */ -/* flags passed to redirect */ -#define REDIR_PUSH 01 /* save previous values of file descriptors */ -#define REDIR_BACKQ 02 /* save the command output to pipe */ +#define E_OPEN "No such file" /* opening a file */ +#define E_CREAT "Directory nonexistent" /* creating a file */ +#define E_EXEC not_found_msg+4 /* executing a program */ /* - * BSD setjmp saves the signal mask, which violates ANSI C and takes time, - * so we use _setjmp instead. + * We enclose jmp_buf in a structure so that we can declare pointers to + * jump locations. The global variable handler contains the location to + * jump to when an exception occurs, and the global variable exception + * contains a code identifying the exeception. To implement nested + * exception handlers, the user should save the value of handler on entry + * to an inner scope, set handler to point to a jmploc structure for the + * inner scope, and restore handler on exit from the scope. */ -#if defined(BSD) -#define setjmp(jmploc) _setjmp(jmploc) -#define longjmp(jmploc, val) _longjmp(jmploc, val) -#endif +struct jmploc { + jmp_buf loc; +}; -/* - * Most machines require the value returned from malloc to be aligned - * in some way. The following macro will get this right on many machines. - */ +static struct jmploc *handler; +static int exception; +static volatile int suppressint; +static volatile sig_atomic_t intpending; -#ifndef ALIGN -union align { - int i; - char *cp; -}; +static int exerrno; /* Last exec error, error for EXEXEC */ -#define ALIGN(nbytes) (((nbytes) + sizeof(union align) - 1) & ~(sizeof(union align) - 1)) -#endif +/* exceptions */ +#define EXINT 0 /* SIGINT received */ +#define EXERROR 1 /* a generic error */ +#define EXSHELLPROC 2 /* execute a shell procedure */ +#define EXEXEC 3 /* command execution failed */ +#define EXEXIT 4 /* exit the shell */ +#define EXSIG 5 /* trapped signal in wait(1) */ -#ifdef CONFIG_LOCALE_SUPPORT -#include <locale.h> -static void change_lc_all(const char *value); -static void change_lc_ctype(const char *value); -#endif + +/* do we generate EXSIG events */ +static int exsig; +/* last pending signal */ +static volatile sig_atomic_t pendingsigs; /* * These macros allow the user to suspend the handling of interrupt signals @@ -240,101 +202,144 @@ static void change_lc_ctype(const char *value); * more fun than worrying about efficiency and portability. :-)) */ -static void onint(void); -static volatile int suppressint; -static volatile int intpending; +#define barrier() ({ __asm__ __volatile__ ("": : :"memory"); }) +#define INTOFF \ + ({ \ + suppressint++; \ + barrier(); \ + 0; \ + }) +#define SAVEINT(v) ((v) = suppressint) +#define RESTOREINT(v) \ + ({ \ + barrier(); \ + if ((suppressint = (v)) == 0 && intpending) onint(); \ + 0; \ + }) +#define EXSIGON() \ + ({ \ + exsig++; \ + barrier(); \ + if (pendingsigs) \ + exraise(EXSIG); \ + 0; \ + }) +/* EXSIG is turned off by evalbltin(). */ + + +static void exraise(int) __attribute__((__noreturn__)); +static void onint(void) __attribute__((__noreturn__)); + +static void error(const char *, ...) __attribute__((__noreturn__)); +static void exerror(int, const char *, ...) __attribute__((__noreturn__)); + +static void sh_warnx(const char *, ...); -#define INTOFF suppressint++ -#ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE -#define INTON { if (--suppressint == 0 && intpending) onint(); } -#define FORCEINTON {suppressint = 0; if (intpending) onint();} -#else -static void __inton(void); -static void forceinton(void); - -#define INTON __inton() +#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE +static void +inton(void) { + if (--suppressint == 0 && intpending) { + onint(); + } +} +#define INTON inton() +static void forceinton(void) +{ + suppressint = 0; + if (intpending) + onint(); +} #define FORCEINTON forceinton() -#endif - -#define CLEAR_PENDING_INT intpending = 0 -#define int_pending() intpending - +#else +#define INTON \ + ({ \ + barrier(); \ + if (--suppressint == 0 && intpending) onint(); \ + 0; \ + }) +#define FORCEINTON \ + ({ \ + barrier(); \ + suppressint = 0; \ + if (intpending) onint(); \ + 0; \ + }) +#endif /* CONFIG_ASH_OPTIMIZE_FOR_SIZE */ -typedef void *pointer; +/* + * BSD setjmp saves the signal mask, which violates ANSI C and takes time, + * so we use _setjmp instead. + */ -#ifndef NULL -#define NULL (void *)0 +#if defined(BSD) && !defined(__SVR4) && !defined(__GLIBC__) +#define setjmp(jmploc) _setjmp(jmploc) +#define longjmp(jmploc, val) _longjmp(jmploc, val) #endif -static pointer stalloc(int); -static void stunalloc(pointer); -static void ungrabstackstr(char *, char *); -static char *growstackstr(void); -static char *makestrspace(size_t newlen); +/* $NetBSD: expand.h,v 1.13 2002/11/24 22:35:40 christos Exp $ */ -/* - * Parse trees for commands are allocated in lifo order, so we use a stack - * to make this more efficient, and also to avoid all sorts of exception - * handling code to handle interrupts in the middle of a parse. - * - * The size 504 was chosen because the Ultrix malloc handles that size - * well. - */ - -#define MINSIZE 504 /* minimum size of a block */ +struct strlist { + struct strlist *next; + char *text; +}; -struct stack_block { - struct stack_block *prev; - char space[MINSIZE]; +struct arglist { + struct strlist *list; + struct strlist **lastp; }; -static struct stack_block stackbase; -static struct stack_block *stackp = &stackbase; -static struct stackmark *markp; -static char *stacknxt = stackbase.space; -static int stacknleft = MINSIZE; +/* + * expandarg() flags + */ +#define EXP_FULL 0x1 /* perform word splitting & file globbing */ +#define EXP_TILDE 0x2 /* do normal tilde expansion */ +#define EXP_VARTILDE 0x4 /* expand tildes in an assignment */ +#define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */ +#define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */ +#define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */ +#define EXP_VARTILDE2 0x40 /* expand tildes after colons only */ +#define EXP_WORD 0x80 /* expand word in parameter expansion */ +#define EXP_QWORD 0x100 /* expand word in quoted parameter expansion */ -#define equal(s1, s2) (strcmp(s1, s2) == 0) +union node; +static void expandarg(union node *, struct arglist *, int); +#define rmescapes(p) _rmescapes((p), 0) +static char *_rmescapes(char *, int); +static int casematch(union node *, char *); -#define stackblock() stacknxt -#define stackblocksize() stacknleft -#define STARTSTACKSTR(p) p = stackblock(), sstrnleft = stackblocksize() +#ifdef CONFIG_ASH_MATH_SUPPORT +static void expari(int); +#endif -#define STPUTC(c, p) (--sstrnleft >= 0? (*p++ = (c)) : (p = growstackstr(), *p++ = (c))) -#define CHECKSTRSPACE(n, p) { if (sstrnleft < n) p = makestrspace(n); } -#define STACKSTRNUL(p) (sstrnleft == 0? (p = growstackstr(), *p = '\0') : (*p = '\0')) +/* $NetBSD: eval.h,v 1.13 2002/11/24 22:35:39 christos Exp $ */ +static char *commandname; /* currently executing command */ +static struct strlist *cmdenviron; /* environment for builtin command */ +static int exitstatus; /* exit status of last command */ +static int back_exitstatus; /* exit status of backquoted command */ -#define USTPUTC(c, p) (--sstrnleft, *p++ = (c)) -#define STUNPUTC(p) (++sstrnleft, --p) -#define STTOPC(p) p[-1] -#define STADJUST(amount, p) (p += (amount), sstrnleft -= (amount)) -#define grabstackstr(p) stalloc(stackblocksize() - sstrnleft) +struct backcmd { /* result of evalbackcmd */ + int fd; /* file descriptor to read from */ + char *buf; /* buffer */ + int nleft; /* number of chars in buffer */ + struct job *jp; /* job structure for command */ +}; -#ifdef DEBUG -#define TRACE(param) trace param -typedef union node unode; -static void trace(const char *, ...); -static void trargs(char **); -static void showtree(unode *); -static void trputc(int); -static void trputs(const char *); -static void opentrace(void); -#else -#define TRACE(param) -#endif +/* + * This file was generated by the mknodes program. + */ -#define NSEMI 0 -#define NCMD 1 -#define NPIPE 2 -#define NREDIR 3 -#define NBACKGND 4 -#define NSUBSHELL 5 -#define NAND 6 -#define NOR 7 +#define NCMD 0 +#define NPIPE 1 +#define NREDIR 2 +#define NBACKGND 3 +#define NSUBSHELL 4 +#define NAND 5 +#define NOR 6 +#define NSEMI 7 #define NIF 8 #define NWHILE 9 #define NUNTIL 10 @@ -344,194 +349,133 @@ static void opentrace(void); #define NDEFUN 14 #define NARG 15 #define NTO 16 -#define NFROM 17 -#define NFROMTO 18 -#define NAPPEND 19 -#define NTOOV 20 +#define NCLOBBER 17 +#define NFROM 18 +#define NFROMTO 19 +#define NAPPEND 20 #define NTOFD 21 #define NFROMFD 22 #define NHERE 23 #define NXHERE 24 #define NNOT 25 -/* - * expandarg() flags - */ -#define EXP_FULL 0x1 /* perform word splitting & file globbing */ -#define EXP_TILDE 0x2 /* do normal tilde expansion */ -#define EXP_VARTILDE 0x4 /* expand tildes in an assignment */ -#define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */ -#define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */ -#define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */ - - -#define NOPTS 16 - -static char optet_vals[NOPTS]; - -static const char *const optlist[NOPTS] = { - "e" "errexit", - "f" "noglob", - "I" "ignoreeof", - "i" "interactive", - "m" "monitor", - "n" "noexec", - "s" "stdin", - "x" "xtrace", - "v" "verbose", - "V" "vi", - "E" "emacs", - "C" "noclobber", - "a" "allexport", - "b" "notify", - "u" "nounset", - "q" "quietprofile" -}; - -#define optent_name(optent) (optent+1) -#define optent_letter(optent) optent[0] -#define optent_val(optent) optet_vals[optent] - -#define eflag optent_val(0) -#define fflag optent_val(1) -#define Iflag optent_val(2) -#define iflag optent_val(3) -#define mflag optent_val(4) -#define nflag optent_val(5) -#define sflag optent_val(6) -#define xflag optent_val(7) -#define vflag optent_val(8) -#define Vflag optent_val(9) -#define Eflag optent_val(10) -#define Cflag optent_val(11) -#define aflag optent_val(12) -#define bflag optent_val(13) -#define uflag optent_val(14) -#define qflag optent_val(15) - - -/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */ -#define FORK_FG 0 -#define FORK_BG 1 -#define FORK_NOJOB 2 - - -struct nbinary { - int type; - union node *ch1; - union node *ch2; -}; struct ncmd { - int type; - int backgnd; - union node *assign; - union node *args; - union node *redirect; + int type; + union node *assign; + union node *args; + union node *redirect; }; struct npipe { - int type; - int backgnd; - struct nodelist *cmdlist; + int type; + int backgnd; + struct nodelist *cmdlist; }; struct nredir { - int type; - union node *n; - union node *redirect; + int type; + union node *n; + union node *redirect; +}; + + +struct nbinary { + int type; + union node *ch1; + union node *ch2; }; struct nif { - int type; - union node *test; - union node *ifpart; - union node *elsepart; + int type; + union node *test; + union node *ifpart; + union node *elsepart; }; struct nfor { - int type; - union node *args; - union node *body; - char *var; + int type; + union node *args; + union node *body; + char *var; }; struct ncase { - int type; - union node *expr; - union node *cases; + int type; + union node *expr; + union node *cases; }; struct nclist { - int type; - union node *next; - union node *pattern; - union node *body; + int type; + union node *next; + union node *pattern; + union node *body; }; struct narg { - int type; - union node *next; - char *text; - struct nodelist *backquote; + int type; + union node *next; + char *text; + struct nodelist *backquote; }; struct nfile { - int type; - union node *next; - int fd; - union node *fname; - char *expfname; + int type; + union node *next; + int fd; + union node *fname; + char *expfname; }; struct ndup { - int type; - union node *next; - int fd; - int dupfd; - union node *vname; + int type; + union node *next; + int fd; + int dupfd; + union node *vname; }; struct nhere { - int type; - union node *next; - int fd; - union node *doc; + int type; + union node *next; + int fd; + union node *doc; }; struct nnot { - int type; - union node *com; + int type; + union node *com; }; union node { - int type; - struct nbinary nbinary; - struct ncmd ncmd; - struct npipe npipe; - struct nredir nredir; - struct nif nif; - struct nfor nfor; - struct ncase ncase; - struct nclist nclist; - struct narg narg; - struct nfile nfile; - struct ndup ndup; - struct nhere nhere; - struct nnot nnot; + int type; + struct ncmd ncmd; + struct npipe npipe; + struct nredir nredir; + struct nbinary nbinary; + struct nif nif; + struct nfor nfor; + struct ncase ncase; + struct nclist nclist; + struct narg narg; + struct nfile nfile; + struct ndup ndup; + struct nhere nhere; + struct nnot nnot; }; @@ -540,162 +484,316 @@ struct nodelist { union node *n; }; -struct backcmd { /* result of evalbackcmd */ - int fd; /* file descriptor to read from */ - char *buf; /* buffer */ - int nleft; /* number of chars in buffer */ - struct job *jp; /* job structure for command */ -}; -struct cmdentry { - int cmdtype; - union param { - int index; - union node *func; - const struct builtincmd *cmd; - } u; +struct funcnode { + int count; + union node n; }; -struct strlist { - struct strlist *next; - char *text; -}; +static void freefunc(struct funcnode *); +/* $NetBSD: parser.h,v 1.15 2002/11/24 22:35:42 christos Exp $ */ -struct arglist { - struct strlist *list; - struct strlist **lastp; -}; +/* control characters in argument strings */ +#define CTL_FIRST '\201' /* first 'special' character */ +#define CTLESC '\201' /* escape next character */ +#define CTLVAR '\202' /* variable defn */ +#define CTLENDVAR '\203' +#define CTLBACKQ '\204' +#define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */ +/* CTLBACKQ | CTLQUOTE == '\205' */ +#define CTLARI '\206' /* arithmetic expression */ +#define CTLENDARI '\207' +#define CTLQUOTEMARK '\210' +#define CTL_LAST '\210' /* last 'special' character */ -struct strpush { - struct strpush *prev; /* preceding string on stack */ - char *prevstring; - int prevnleft; -#ifdef CONFIG_ASH_ALIAS - struct alias *ap; /* if push was associated with an alias */ -#endif - char *string; /* remember the string since it may change */ -}; +/* variable substitution byte (follows CTLVAR) */ +#define VSTYPE 0x0f /* type of variable substitution */ +#define VSNUL 0x10 /* colon--treat the empty string as unset */ +#define VSQUOTE 0x80 /* inside double quotes--suppress splitting */ -struct parsefile { - struct parsefile *prev; /* preceding file on stack */ - int linno; /* current line */ - int fd; /* file descriptor (or -1 if string) */ - int nleft; /* number of chars left in this line */ - int lleft; /* number of chars left in this buffer */ - char *nextc; /* next char in buffer */ - char *buf; /* input buffer */ - struct strpush *strpush; /* for pushing strings at this level */ - struct strpush basestrpush; /* so pushing one is fast */ -}; +/* values of VSTYPE field */ +#define VSNORMAL 0x1 /* normal variable: $var or ${var} */ +#define VSMINUS 0x2 /* ${var-text} */ +#define VSPLUS 0x3 /* ${var+text} */ +#define VSQUESTION 0x4 /* ${var?message} */ +#define VSASSIGN 0x5 /* ${var=text} */ +#define VSTRIMRIGHT 0x6 /* ${var%pattern} */ +#define VSTRIMRIGHTMAX 0x7 /* ${var%%pattern} */ +#define VSTRIMLEFT 0x8 /* ${var#pattern} */ +#define VSTRIMLEFTMAX 0x9 /* ${var##pattern} */ +#define VSLENGTH 0xa /* ${#var} */ -struct stackmark { - struct stack_block *stackp; - char *stacknxt; - int stacknleft; - struct stackmark *marknext; -}; +/* values of checkkwd variable */ +#define CHKALIAS 0x1 +#define CHKKWD 0x2 +#define CHKNL 0x4 -struct shparam { - int nparam; /* # of positional parameters (without $0) */ - unsigned char malloc; /* if parameter list dynamically allocated */ - char **p; /* parameter list */ - int optind; /* next parameter to be processed by getopts */ - int optoff; /* used by getopts */ -}; +#define IBUFSIZ (BUFSIZ + 1) /* - * When commands are first encountered, they are entered in a hash table. - * This ensures that a full path search will not have to be done for them - * on each invocation. - * - * We should investigate converting to a linear search, even though that - * would make the command name "hash" a misnomer. + * NEOF is returned by parsecmd when it encounters an end of file. It + * must be distinct from NULL, so we use the address of a variable that + * happens to be handy. */ -#define CMDTABLESIZE 31 /* should be prime */ -#define ARB 1 /* actual size determined at run time */ +static int plinno = 1; /* input line number */ +/* number of characters left in input buffer */ +static int parsenleft; /* copy of parsefile->nleft */ +static int parselleft; /* copy of parsefile->lleft */ +/* next character in input buffer */ +static char *parsenextc; /* copy of parsefile->nextc */ +static struct parsefile basepf; /* top level input file */ +static char basebuf[IBUFSIZ]; /* buffer for top level input file */ +static struct parsefile *parsefile = &basepf; /* current input file */ -struct tblentry { - struct tblentry *next; /* next entry in hash chain */ - union param param; /* definition of builtin function */ - short cmdtype; /* index identifying command */ - char rehash; /* if set, cd done since entry created */ - char cmdname[ARB]; /* name of command */ -}; +static int tokpushback; /* last token pushed back */ +#define NEOF ((union node *)&tokpushback) +static int parsebackquote; /* nonzero if we are inside backquotes */ +static int doprompt; /* if set, prompt the user */ +static int needprompt; /* true if interactive and at start of line */ +static int lasttoken; /* last token read */ +static char *wordtext; /* text of last word returned by readtoken */ +static int checkkwd; +static struct nodelist *backquotelist; +static union node *redirnode; +static struct heredoc *heredoc; +static int quoteflag; /* set if (part of) last token was quoted */ +static int startlinno; /* line # where last token started */ -static struct tblentry *cmdtable[CMDTABLESIZE]; -static int builtinloc = -1; /* index in path of %builtin, or -1 */ -static int exerrno = 0; /* Last exec error */ +static union node *parsecmd(int); +static void fixredir(union node *, const char *, int); +static const char *const *findkwd(const char *); +static char *endofname(const char *); +/* $NetBSD: shell.h,v 1.16 2003/01/22 20:36:04 dsl Exp $ */ -static void tryexec(char *, char **, char **); -static void printentry(struct tblentry *, int); -static void clearcmdentry(int); -static struct tblentry *cmdlookup(const char *, int); -static void delete_cmd_entry(void); -static int path_change(const char *, int *); +typedef void *pointer; +static char nullstr[1]; /* zero length string */ +static const char spcstr[] = " "; +static const char snlfmt[] = "%s\n"; +static const char dolatstr[] = { CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0' }; +static const char illnum[] = "Illegal number: %s"; +static const char homestr[] = "HOME"; -static void flushall(void); -static void out2fmt(const char *, ...) - __attribute__ ((__format__(__printf__, 1, 2))); -static int xwrite(int, const char *, int); +#ifdef DEBUG +#define TRACE(param) trace param +#define TRACEV(param) tracev param +#else +#define TRACE(param) +#define TRACEV(param) +#endif -static inline void outstr(const char *p, FILE * file) -{ - fputs(p, file); -} -static void out1str(const char *p) -{ - outstr(p, stdout); -} -static void out2str(const char *p) +#if defined(__GNUC__) && __GNUC__ < 3 +#define va_copy __va_copy +#endif + +#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96) +#define __builtin_expect(x, expected_value) (x) +#endif + +#define likely(x) __builtin_expect((x),1) +#define unlikely(x) __builtin_expect((x),0) + +#define TEOF 0 +#define TNL 1 +#define TREDIR 2 +#define TWORD 3 +#define TSEMI 4 +#define TBACKGND 5 +#define TAND 6 +#define TOR 7 +#define TPIPE 8 +#define TLP 9 +#define TRP 10 +#define TENDCASE 11 +#define TENDBQUOTE 12 +#define TNOT 13 +#define TCASE 14 +#define TDO 15 +#define TDONE 16 +#define TELIF 17 +#define TELSE 18 +#define TESAC 19 +#define TFI 20 +#define TFOR 21 +#define TIF 22 +#define TIN 23 +#define TTHEN 24 +#define TUNTIL 25 +#define TWHILE 26 +#define TBEGIN 27 +#define TEND 28 + +/* first char is indicating which tokens mark the end of a list */ +static const char *const tokname_array[] = { + "\1end of file", + "\0newline", + "\0redirection", + "\0word", + "\0;", + "\0&", + "\0&&", + "\0||", + "\0|", + "\0(", + "\1)", + "\1;;", + "\1`", +#define KWDOFFSET 13 + /* the following are keywords */ + "\0!", + "\0case", + "\1do", + "\1done", + "\1elif", + "\1else", + "\1esac", + "\1fi", + "\0for", + "\0if", + "\0in", + "\1then", + "\0until", + "\0while", + "\0{", + "\1}", +}; + +static const char *tokname(int tok) { - outstr(p, stderr); + static char buf[16]; + + if (tok >= TSEMI) + buf[0] = '"'; + sprintf(buf + (tok >= TSEMI), "%s%c", + tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0)); + return buf; } -#ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE -#define out2c(c) putc((c), stderr) +/* $NetBSD: machdep.h,v 1.10 2002/10/07 14:26:08 christos Exp $ */ + +/* + * Most machines require the value returned from malloc to be aligned + * in some way. The following macro will get this right on many machines. + */ + +#define SHELL_SIZE (sizeof(union {int i; char *cp; double d; }) - 1) +/* + * It appears that grabstackstr() will barf with such alignments + * because stalloc() will return a string allocated in a new stackblock. + */ +#define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE) + +/* + * This file was generated by the mksyntax program. + */ + + +/* Syntax classes */ +#define CWORD 0 /* character is nothing special */ +#define CNL 1 /* newline character */ +#define CBACK 2 /* a backslash character */ +#define CSQUOTE 3 /* single quote */ +#define CDQUOTE 4 /* double quote */ +#define CENDQUOTE 5 /* a terminating quote */ +#define CBQUOTE 6 /* backwards single quote */ +#define CVAR 7 /* a dollar sign */ +#define CENDVAR 8 /* a '}' character */ +#define CLP 9 /* a left paren in arithmetic */ +#define CRP 10 /* a right paren in arithmetic */ +#define CENDFILE 11 /* end of file */ +#define CCTL 12 /* like CWORD, except it must be escaped */ +#define CSPCL 13 /* these terminate a word */ +#define CIGN 14 /* character should be ignored */ + +#ifdef CONFIG_ASH_ALIAS +#define SYNBASE 130 +#define PEOF -130 +#define PEOA -129 +#define PEOA_OR_PEOF PEOA #else -static void out2c(int c) -{ - putc(c, stderr); -} +#define SYNBASE 129 +#define PEOF -129 +#define PEOA_OR_PEOF PEOF #endif +#define is_digit(c) ((unsigned)((c) - '0') <= 9) +#define is_name(c) ((c) == '_' || isalpha((unsigned char)(c))) +#define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c))) + +/* + * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise + * (assuming ascii char codes, as the original implementation did) + */ +#define is_special(c) \ + ( (((unsigned int)c) - 33 < 32) \ + && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1)) + +#define digit_val(c) ((c) - '0') + +/* + * This file was generated by the mksyntax program. + */ #ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE #define USE_SIT_FUNCTION #endif /* number syntax index */ -#define BASESYNTAX 0 /* not in quotes */ -#define DQSYNTAX 1 /* in double quotes */ -#define SQSYNTAX 2 /* in single quotes */ -#define ARISYNTAX 3 /* in arithmetic */ +#define BASESYNTAX 0 /* not in quotes */ +#define DQSYNTAX 1 /* in double quotes */ +#define SQSYNTAX 2 /* in single quotes */ +#define ARISYNTAX 3 /* in arithmetic */ +#ifdef CONFIG_ASH_MATH_SUPPORT static const char S_I_T[][4] = { - {CSPCL, CIGN, CIGN, CIGN}, /* 0, PEOA */ - {CSPCL, CWORD, CWORD, CWORD}, /* 1, ' ' */ - {CNL, CNL, CNL, CNL}, /* 2, \n */ - {CWORD, CCTL, CCTL, CWORD}, /* 3, !*-/:=?[]~ */ - {CDQUOTE, CENDQUOTE, CWORD, CDQUOTE}, /* 4, '"' */ - {CVAR, CVAR, CWORD, CVAR}, /* 5, $ */ - {CSQUOTE, CWORD, CENDQUOTE, CSQUOTE}, /* 6, "'" */ - {CSPCL, CWORD, CWORD, CLP}, /* 7, ( */ - {CSPCL, CWORD, CWORD, CRP}, /* 8, ) */ - {CBACK, CBACK, CCTL, CBACK}, /* 9, \ */ - {CBQUOTE, CBQUOTE, CWORD, CBQUOTE}, /* 10, ` */ - {CENDVAR, CENDVAR, CWORD, CENDVAR}, /* 11, } */ +#ifdef CONFIG_ASH_ALIAS + {CSPCL, CIGN, CIGN, CIGN}, /* 0, PEOA */ +#endif + {CSPCL, CWORD, CWORD, CWORD}, /* 1, ' ' */ + {CNL, CNL, CNL, CNL}, /* 2, \n */ + {CWORD, CCTL, CCTL, CWORD}, /* 3, !*-/:=?[]~ */ + {CDQUOTE, CENDQUOTE, CWORD, CWORD}, /* 4, '"' */ + {CVAR, CVAR, CWORD, CVAR}, /* 5, $ */ + {CSQUOTE, CWORD, CENDQUOTE, CWORD}, /* 6, "'" */ + {CSPCL, CWORD, CWORD, CLP}, /* 7, ( */ + {CSPCL, CWORD, CWORD, CRP}, /* 8, ) */ + {CBACK, CBACK, CCTL, CBACK}, /* 9, \ */ + {CBQUOTE, CBQUOTE, CWORD, CBQUOTE}, /* 10, ` */ + {CENDVAR, CENDVAR, CWORD, CENDVAR}, /* 11, } */ #ifndef USE_SIT_FUNCTION - {CENDFILE, CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */ - {CWORD, CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */ - {CCTL, CCTL, CCTL, CCTL} /* 14, CTLESC ... */ + {CENDFILE, CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */ + {CWORD, CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */ + {CCTL, CCTL, CCTL, CCTL} /* 14, CTLESC ... */ #endif }; +#else +static const char S_I_T[][3] = { +#ifdef CONFIG_ASH_ALIAS + {CSPCL, CIGN, CIGN}, /* 0, PEOA */ +#endif + {CSPCL, CWORD, CWORD}, /* 1, ' ' */ + {CNL, CNL, CNL}, /* 2, \n */ + {CWORD, CCTL, CCTL}, /* 3, !*-/:=?[]~ */ + {CDQUOTE, CENDQUOTE, CWORD}, /* 4, '"' */ + {CVAR, CVAR, CWORD}, /* 5, $ */ + {CSQUOTE, CWORD, CENDQUOTE}, /* 6, "'" */ + {CSPCL, CWORD, CWORD}, /* 7, ( */ + {CSPCL, CWORD, CWORD}, /* 8, ) */ + {CBACK, CBACK, CCTL}, /* 9, \ */ + {CBQUOTE, CBQUOTE, CWORD}, /* 10, ` */ + {CENDVAR, CENDVAR, CWORD}, /* 11, } */ +#ifndef USE_SIT_FUNCTION + {CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */ + {CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */ + {CCTL, CCTL, CCTL} /* 14, CTLESC ... */ +#endif +}; +#endif /* CONFIG_ASH_MATH_SUPPORT */ #ifdef USE_SIT_FUNCTION @@ -704,41 +802,54 @@ static const char S_I_T[][4] = { static int SIT(int c, int syntax) { static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~"; +#ifdef CONFIG_ASH_ALIAS static const char syntax_index_table[] = { - 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */ - 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */ - 3, 1, 3, 3, 9, 3, 10, 1, /* "=>?[\\]`|" */ - 11, 3 - }; /* "}~" */ + 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */ + 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */ + 3, 1, 3, 3, 9, 3, 10, 1, /* "=>?[\\]`|" */ + 11, 3 /* "}~" */ + }; +#else + static const char syntax_index_table[] = { + 0, 1, 0, 2, 3, 4, 0, 5, /* "\t\n !\"$&'" */ + 6, 7, 2, 2, 2, 2, 0, 0, /* "()*-/:;<" */ + 2, 0, 2, 2, 8, 2, 9, 0, /* "=>?[\\]`|" */ + 10, 2 /* "}~" */ + }; +#endif const char *s; int indx; - if (c == PEOF) /* 2^8+2 */ + if (c == PEOF) /* 2^8+2 */ return CENDFILE; - if (c == PEOA) /* 2^8+1 */ +#ifdef CONFIG_ASH_ALIAS + if (c == PEOA) /* 2^8+1 */ indx = 0; - else if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK)) - return CCTL; + else +#endif + if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK)) + return CCTL; else { s = strchr(spec_symbls, c); - if (s == 0) + if (s == 0 || *s == 0) return CWORD; indx = syntax_index_table[(s - spec_symbls)]; } return S_I_T[indx][syntax]; } -#else /* USE_SIT_FUNCTION */ +#else /* USE_SIT_FUNCTION */ #define SIT(c, syntax) S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax] +#ifdef CONFIG_ASH_ALIAS #define CSPCL_CIGN_CIGN_CIGN 0 #define CSPCL_CWORD_CWORD_CWORD 1 #define CNL_CNL_CNL_CNL 2 #define CWORD_CCTL_CCTL_CWORD 3 -#define CDQUOTE_CENDQUOTE_CWORD_CDQUOTE 4 +#define CDQUOTE_CENDQUOTE_CWORD_CWORD 4 #define CVAR_CVAR_CWORD_CVAR 5 -#define CSQUOTE_CWORD_CENDQUOTE_CSQUOTE 6 +#define CSQUOTE_CWORD_CENDQUOTE_CWORD 6 #define CSPCL_CWORD_CWORD_CLP 7 #define CSPCL_CWORD_CWORD_CRP 8 #define CBACK_CBACK_CCTL_CBACK 9 @@ -747,22 +858,38 @@ static int SIT(int c, int syntax) #define CENDFILE_CENDFILE_CENDFILE_CENDFILE 12 #define CWORD_CWORD_CWORD_CWORD 13 #define CCTL_CCTL_CCTL_CCTL 14 +#else +#define CSPCL_CWORD_CWORD_CWORD 0 +#define CNL_CNL_CNL_CNL 1 +#define CWORD_CCTL_CCTL_CWORD 2 +#define CDQUOTE_CENDQUOTE_CWORD_CWORD 3 +#define CVAR_CVAR_CWORD_CVAR 4 +#define CSQUOTE_CWORD_CENDQUOTE_CWORD 5 +#define CSPCL_CWORD_CWORD_CLP 6 +#define CSPCL_CWORD_CWORD_CRP 7 +#define CBACK_CBACK_CCTL_CBACK 8 +#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 9 +#define CENDVAR_CENDVAR_CWORD_CENDVAR 10 +#define CENDFILE_CENDFILE_CENDFILE_CENDFILE 11 +#define CWORD_CWORD_CWORD_CWORD 12 +#define CCTL_CCTL_CCTL_CCTL 13 +#endif static const char syntax_index_table[258] = { /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */ - /* 0 -130 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE, - /* 1 -129 PEOA */ CSPCL_CIGN_CIGN_CIGN, - /* 2 -128 0xff */ CWORD_CWORD_CWORD_CWORD, - /* 3 -127 */ CCTL_CCTL_CCTL_CCTL, - /* CTLQUOTEMARK */ - /* 4 -126 */ CCTL_CCTL_CCTL_CCTL, - /* 5 -125 */ CCTL_CCTL_CCTL_CCTL, - /* 6 -124 */ CCTL_CCTL_CCTL_CCTL, - /* 7 -123 */ CCTL_CCTL_CCTL_CCTL, - /* 8 -122 */ CCTL_CCTL_CCTL_CCTL, - /* 9 -121 */ CCTL_CCTL_CCTL_CCTL, - /* 10 -120 */ CCTL_CCTL_CCTL_CCTL, - /* CTLESC */ + /* 0 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE, +#ifdef CONFIG_ASH_ALIAS + /* 1 PEOA */ CSPCL_CIGN_CIGN_CIGN, +#endif + /* 2 -128 0x80 */ CWORD_CWORD_CWORD_CWORD, + /* 3 -127 CTLESC */ CCTL_CCTL_CCTL_CCTL, + /* 4 -126 CTLVAR */ CCTL_CCTL_CCTL_CCTL, + /* 5 -125 CTLENDVAR */ CCTL_CCTL_CCTL_CCTL, + /* 6 -124 CTLBACKQ */ CCTL_CCTL_CCTL_CCTL, + /* 7 -123 CTLQUOTE */ CCTL_CCTL_CCTL_CCTL, + /* 8 -122 CTLARI */ CCTL_CCTL_CCTL_CCTL, + /* 9 -121 CTLENDARI */ CCTL_CCTL_CCTL_CCTL, + /* 10 -120 CTLQUOTEMARK */ CCTL_CCTL_CCTL_CCTL, /* 11 -119 */ CWORD_CWORD_CWORD_CWORD, /* 12 -118 */ CWORD_CWORD_CWORD_CWORD, /* 13 -117 */ CWORD_CWORD_CWORD_CWORD, @@ -916,12 +1043,12 @@ static const char syntax_index_table[258] = { /* 161 31 */ CWORD_CWORD_CWORD_CWORD, /* 162 32 " " */ CSPCL_CWORD_CWORD_CWORD, /* 163 33 "!" */ CWORD_CCTL_CCTL_CWORD, - /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CDQUOTE, + /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CWORD, /* 165 35 "#" */ CWORD_CWORD_CWORD_CWORD, /* 166 36 "$" */ CVAR_CVAR_CWORD_CVAR, /* 167 37 "%" */ CWORD_CWORD_CWORD_CWORD, /* 168 38 "&" */ CSPCL_CWORD_CWORD_CWORD, - /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CSQUOTE, + /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CWORD, /* 170 40 "(" */ CSPCL_CWORD_CWORD_CLP, /* 171 41 ")" */ CSPCL_CWORD_CWORD_CRP, /* 172 42 "*" */ CWORD_CCTL_CCTL_CWORD, @@ -1012,90 +1139,66 @@ static const char syntax_index_table[258] = { /* 257 127 */ CWORD_CWORD_CWORD_CWORD, }; -#endif /* USE_SIT_FUNCTION */ +#endif /* USE_SIT_FUNCTION */ +/* $NetBSD: alias.c,v 1.11 2002/11/24 22:35:38 christos Exp $ */ -/* first char is indicating which tokens mark the end of a list */ -static const char *const tokname_array[] = { - "\1end of file", - "\0newline", - "\0redirection", - "\0word", - "\0assignment", - "\0;", - "\0&", - "\0&&", - "\0||", - "\0|", - "\0(", - "\1)", - "\1;;", - "\1`", -#define KWDOFFSET 14 - /* the following are keywords */ - "\0!", - "\0case", - "\1do", - "\1done", - "\1elif", - "\1else", - "\1esac", - "\1fi", - "\0for", - "\0if", - "\0in", - "\1then", - "\0until", - "\0while", - "\0{", - "\1}", -}; -static const char *tokname(int tok) -{ - static char buf[16]; - - if (tok >= TSEMI) - buf[0] = '"'; - sprintf(buf + (tok >= TSEMI), "%s%c", - tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0)); - return buf; -} - -static int plinno = 1; /* input line number */ - -static int parselleft; /* copy of parsefile->lleft */ - -static struct parsefile basepf; /* top level input file */ -static char basebuf[BUFSIZ]; /* buffer for top level input file */ -static struct parsefile *parsefile = &basepf; /* current input file */ +#define ATABSIZE 39 -/* - * NEOF is returned by parsecmd when it encounters an end of file. It - * must be distinct from NULL, so we use the address of a variable that - * happens to be handy. - */ +static int funcblocksize; /* size of structures in function */ +static int funcstringsize; /* size of strings in node */ +static pointer funcblock; /* block to allocate function from */ +static char *funcstring; /* block to allocate strings from */ + +static const short nodesize[26] = { + SHELL_ALIGN(sizeof (struct ncmd)), + SHELL_ALIGN(sizeof (struct npipe)), + SHELL_ALIGN(sizeof (struct nredir)), + SHELL_ALIGN(sizeof (struct nredir)), + SHELL_ALIGN(sizeof (struct nredir)), + SHELL_ALIGN(sizeof (struct nbinary)), + SHELL_ALIGN(sizeof (struct nbinary)), + SHELL_ALIGN(sizeof (struct nbinary)), + SHELL_ALIGN(sizeof (struct nif)), + SHELL_ALIGN(sizeof (struct nbinary)), + SHELL_ALIGN(sizeof (struct nbinary)), + SHELL_ALIGN(sizeof (struct nfor)), + SHELL_ALIGN(sizeof (struct ncase)), + SHELL_ALIGN(sizeof (struct nclist)), + SHELL_ALIGN(sizeof (struct narg)), + SHELL_ALIGN(sizeof (struct narg)), + SHELL_ALIGN(sizeof (struct nfile)), + SHELL_ALIGN(sizeof (struct nfile)), + SHELL_ALIGN(sizeof (struct nfile)), + SHELL_ALIGN(sizeof (struct nfile)), + SHELL_ALIGN(sizeof (struct nfile)), + SHELL_ALIGN(sizeof (struct ndup)), + SHELL_ALIGN(sizeof (struct ndup)), + SHELL_ALIGN(sizeof (struct nhere)), + SHELL_ALIGN(sizeof (struct nhere)), + SHELL_ALIGN(sizeof (struct nnot)), +}; -static int tokpushback; /* last token pushed back */ -#define NEOF ((union node *)&tokpushback) -static int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */ +static void calcsize(union node *); +static void sizenodelist(struct nodelist *); +static union node *copynode(union node *); +static struct nodelist *copynodelist(struct nodelist *); +static char *nodesavestr(char *); -static void error(const char *, ...) __attribute__ ((__noreturn__)); -static void exerror(int, const char *, ...) __attribute__ ((__noreturn__)); -static void shellexec(char **, char **, const char *, int) - __attribute__ ((noreturn)); -static void exitshell(int) __attribute__ ((noreturn)); -static int goodname(const char *); -static void ignoresig(int); -static void onsig(int); -static void dotrap(void); -static int decode_signal(const char *, int); +static void evalstring(char *, int); +union node; /* BLETCH for ansi C */ +static void evaltree(union node *, int); +static void evalbackcmd(union node *, struct backcmd *); -static void setparam(char **); -static void freeparam(volatile struct shparam *); +/* in_function returns nonzero if we are currently evaluating a function */ +#define in_function() funcnest +static int evalskip; /* set if we are skipping commands */ +static int skipcount; /* number of levels to skip */ +static int funcnest; /* depth of function calls */ /* reasons for skipping commands (see comment on breakcmd routine) */ #define SKIPBREAK 1 @@ -1103,160 +1206,330 @@ static void freeparam(volatile struct shparam *); #define SKIPFUNC 3 #define SKIPFILE 4 +/* + * This file was generated by the mkbuiltins program. + */ + +#ifdef JOBS +static int bgcmd(int, char **); +#endif +static int breakcmd(int, char **); +static int cdcmd(int, char **); +#ifdef CONFIG_ASH_CMDCMD +static int commandcmd(int, char **); +#endif +static int dotcmd(int, char **); +static int evalcmd(int, char **); +static int execcmd(int, char **); +static int exitcmd(int, char **); +#ifdef CONFIG_ASH_MATH_SUPPORT +static int expcmd(int, char **); +#endif +static int exportcmd(int, char **); +static int falsecmd(int, char **); +#ifdef JOBS +static int fgcmd(int, char **); +#endif +#ifdef CONFIG_ASH_GETOPTS +static int getoptscmd(int, char **); +#endif +static int hashcmd(int, char **); +#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET +static int helpcmd(int argc, char **argv); +#endif +#ifdef JOBS +static int jobscmd(int, char **); +#endif +static int localcmd(int, char **); +static int pwdcmd(int, char **); +static int readcmd(int, char **); +static int returncmd(int, char **); +static int setcmd(int, char **); +static int shiftcmd(int, char **); +static int timescmd(int, char **); +static int trapcmd(int, char **); +static int truecmd(int, char **); +static int typecmd(int, char **); +static int umaskcmd(int, char **); +static int unsetcmd(int, char **); +static int waitcmd(int, char **); +static int ulimitcmd(int, char **); +#ifdef JOBS +static int killcmd(int, char **); +#endif + +/* $NetBSD: mail.h,v 1.9 2002/11/24 22:35:40 christos Exp $ */ + +#ifdef CONFIG_ASH_MAIL +static void chkmail(void); +static void changemail(const char *); +#endif + +/* $NetBSD: exec.h,v 1.20 2003/01/22 20:36:04 dsl Exp $ */ + /* values of cmdtype */ -#define CMDUNKNOWN -1 /* no entry in table for command */ -#define CMDNORMAL 0 /* command is an executable program */ -#define CMDBUILTIN 1 /* command is a shell builtin */ -#define CMDFUNCTION 2 /* command is a shell function */ +#define CMDUNKNOWN -1 /* no entry in table for command */ +#define CMDNORMAL 0 /* command is an executable program */ +#define CMDFUNCTION 1 /* command is a shell function */ +#define CMDBUILTIN 2 /* command is a shell builtin */ -#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 */ +struct builtincmd { + const char *name; + int (*builtin)(int, char **); + /* unsigned flags; */ +}; -/* - * Shell variables. - */ +#ifdef CONFIG_ASH_CMDCMD +# ifdef JOBS +# ifdef CONFIG_ASH_ALIAS +# define COMMANDCMD (builtincmd + 7) +# define EXECCMD (builtincmd + 10) +# else +# define COMMANDCMD (builtincmd + 6) +# define EXECCMD (builtincmd + 9) +# endif +# else /* ! JOBS */ +# ifdef CONFIG_ASH_ALIAS +# define COMMANDCMD (builtincmd + 6) +# define EXECCMD (builtincmd + 9) +# else +# define COMMANDCMD (builtincmd + 5) +# define EXECCMD (builtincmd + 8) +# endif +# endif /* JOBS */ +#else /* ! CONFIG_ASH_CMDCMD */ +# ifdef JOBS +# ifdef CONFIG_ASH_ALIAS +# define EXECCMD (builtincmd + 9) +# else +# define EXECCMD (builtincmd + 8) +# endif +# else /* ! JOBS */ +# ifdef CONFIG_ASH_ALIAS +# define EXECCMD (builtincmd + 8) +# else +# define EXECCMD (builtincmd + 7) +# endif +# endif /* JOBS */ +#endif /* CONFIG_ASH_CMDCMD */ -/* flags */ -#define VEXPORT 0x01 /* variable is exported */ -#define VREADONLY 0x02 /* variable cannot be modified */ -#define VSTRFIXED 0x04 /* variable struct is staticly allocated */ -#define VTEXTFIXED 0x08 /* text is staticly allocated */ -#define VSTACK 0x10 /* text is allocated on the stack */ -#define VUNSET 0x20 /* the variable is not set */ -#define VNOFUNC 0x40 /* don't call the callback function */ +#define BUILTIN_NOSPEC "0" +#define BUILTIN_SPECIAL "1" +#define BUILTIN_REGULAR "2" +#define BUILTIN_SPEC_REG "3" +#define BUILTIN_ASSIGN "4" +#define BUILTIN_SPEC_ASSG "5" +#define BUILTIN_REG_ASSG "6" +#define BUILTIN_SPEC_REG_ASSG "7" +#define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1) +#define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2) -struct var { - struct var *next; /* next entry in hash list */ - int flags; /* flags are defined above */ - char *text; /* name=value */ - void (*func) (const char *); - /* function to be called when */ - /* the variable gets set/unset */ +static const struct builtincmd builtincmd[] = { + { BUILTIN_SPEC_REG ".", dotcmd }, + { BUILTIN_SPEC_REG ":", truecmd }, +#ifdef CONFIG_ASH_ALIAS + { BUILTIN_REG_ASSG "alias", aliascmd }, +#endif +#ifdef JOBS + { BUILTIN_REGULAR "bg", bgcmd }, +#endif + { BUILTIN_SPEC_REG "break", breakcmd }, + { BUILTIN_REGULAR "cd", cdcmd }, + { BUILTIN_NOSPEC "chdir", cdcmd }, +#ifdef CONFIG_ASH_CMDCMD + { BUILTIN_REGULAR "command", commandcmd }, +#endif + { BUILTIN_SPEC_REG "continue", breakcmd }, + { BUILTIN_SPEC_REG "eval", evalcmd }, + { BUILTIN_SPEC_REG "exec", execcmd }, + { BUILTIN_SPEC_REG "exit", exitcmd }, +#ifdef CONFIG_ASH_MATH_SUPPORT + { BUILTIN_NOSPEC "exp", expcmd }, +#endif + { BUILTIN_SPEC_REG_ASSG "export", exportcmd }, + { BUILTIN_REGULAR "false", falsecmd }, +#ifdef JOBS + { BUILTIN_REGULAR "fg", fgcmd }, +#endif +#ifdef CONFIG_ASH_GETOPTS + { BUILTIN_REGULAR "getopts", getoptscmd }, +#endif + { BUILTIN_NOSPEC "hash", hashcmd }, +#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET + { BUILTIN_NOSPEC "help", helpcmd }, +#endif +#ifdef JOBS + { BUILTIN_REGULAR "jobs", jobscmd }, + { BUILTIN_REGULAR "kill", killcmd }, +#endif +#ifdef CONFIG_ASH_MATH_SUPPORT + { BUILTIN_NOSPEC "let", expcmd }, +#endif + { BUILTIN_ASSIGN "local", localcmd }, + { BUILTIN_NOSPEC "pwd", pwdcmd }, + { BUILTIN_REGULAR "read", readcmd }, + { BUILTIN_SPEC_REG_ASSG "readonly", exportcmd }, + { BUILTIN_SPEC_REG "return", returncmd }, + { BUILTIN_SPEC_REG "set", setcmd }, + { BUILTIN_SPEC_REG "shift", shiftcmd }, + { BUILTIN_SPEC_REG "times", timescmd }, + { BUILTIN_SPEC_REG "trap", trapcmd }, + { BUILTIN_REGULAR "true", truecmd }, + { BUILTIN_NOSPEC "type", typecmd }, + { BUILTIN_NOSPEC "ulimit", ulimitcmd }, + { BUILTIN_REGULAR "umask", umaskcmd }, +#ifdef CONFIG_ASH_ALIAS + { BUILTIN_REGULAR "unalias", unaliascmd }, +#endif + { BUILTIN_SPEC_REG "unset", unsetcmd }, + { BUILTIN_REGULAR "wait", waitcmd }, }; -struct localvar { - struct localvar *next; /* next local variable in list */ - struct var *vp; /* the variable that was made local */ - int flags; /* saved flags */ - char *text; /* saved text */ +#define NUMBUILTINS (sizeof (builtincmd) / sizeof (struct builtincmd) ) + + + +struct cmdentry { + int cmdtype; + union param { + int index; + const struct builtincmd *cmd; + struct funcnode *func; + } u; }; -#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) -#define rmescapes(p) _rmescapes((p), 0) -static char *_rmescapes(char *, int); -#else -static void rmescapes(char *); +/* action to find_command() */ +#define DO_ERR 0x01 /* prints errors */ +#define DO_ABS 0x02 /* checks absolute paths */ +#define DO_NOFUNC 0x04 /* don't return shell functions, for command */ +#define DO_ALTPATH 0x08 /* using alternate path */ +#define DO_ALTBLTIN 0x20 /* %builtin in alt. path */ + +static const char *pathopt; /* set by padvance */ + +static void shellexec(char **, const char *, int) + __attribute__((__noreturn__)); +static char *padvance(const char **, const char *); +static void find_command(char *, struct cmdentry *, int, const char *); +static struct builtincmd *find_builtin(const char *); +static void hashcd(void); +static void changepath(const char *); +static void defun(char *, union node *); +static void unsetfunc(const char *); + +#ifdef CONFIG_ASH_MATH_SUPPORT +/* From arith.y */ +static int dash_arith(const char *); #endif -static int casematch(union node *, const char *); -static void clearredir(void); -static void popstring(void); -static void readcmdfile(const char *); +/* $NetBSD: init.h,v 1.9 2002/11/24 22:35:40 christos Exp $ */ -static int number(const char *); -static int is_number(const char *, int *num); -static char *single_quote(const char *); -static int nextopt(const char *); +static void reset(void); -static void redirect(union node *, int); -static void popredir(void); -static int dup_as_newfd(int, int); +/* $NetBSD: var.h,v 1.21 2003/01/22 20:36:04 dsl Exp $ */ -static void changepath(const char *newval); -static void getoptsreset(const char *value); +/* + * Shell variables. + */ +/* flags */ +#define VEXPORT 0x01 /* variable is exported */ +#define VREADONLY 0x02 /* variable cannot be modified */ +#define VSTRFIXED 0x04 /* variable struct is statically allocated */ +#define VTEXTFIXED 0x08 /* text is statically allocated */ +#define VSTACK 0x10 /* text is allocated on the stack */ +#define VUNSET 0x20 /* the variable is not set */ +#define VNOFUNC 0x40 /* don't call the callback function */ +#define VNOSET 0x80 /* do not set variable - just readonly test */ +#define VNOSAVE 0x100 /* when text is on the heap before setvareq */ -static int parsenleft; /* copy of parsefile->nleft */ -static char *parsenextc; /* copy of parsefile->nextc */ -static int rootpid; /* pid of main shell */ -static int rootshell; /* true if we aren't a child of the main shell */ -static const char spcstr[] = " "; -static const char snlfmt[] = "%s\n"; +struct var { + struct var *next; /* next entry in hash list */ + int flags; /* flags are defined above */ + const char *text; /* name=value */ + void (*func)(const char *); + /* function to be called when */ + /* the variable gets set/unset */ +}; + +struct localvar { + struct localvar *next; /* next local variable in list */ + struct var *vp; /* the variable that was made local */ + int flags; /* saved flags */ + const char *text; /* saved text */ +}; -static int sstrnleft; -static int herefd = -1; static struct localvar *localvars; -static struct var vifs; -static struct var vmail; -static struct var vmpath; -static struct var vpath; -static struct var vps1; -static struct var vps2; -static struct var voptind; +/* + * Shell variables. + */ -#ifdef CONFIG_LOCALE_SUPPORT -static struct var vlc_all; -static struct var vlc_ctype; +#ifdef CONFIG_ASH_GETOPTS +static void getoptsreset(const char *); #endif -#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY -static struct var vhistfile; +#ifdef CONFIG_LOCALE_SUPPORT +#include <locale.h> +static void change_lc_all(const char *value); +static void change_lc_ctype(const char *value); #endif -struct varinit { - struct var *var; - int flags; - const char *text; - void (*func) (const char *); -}; +#define VTABSIZE 39 static const char defpathvar[] = "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"; -#define defpath (defpathvar + 5) - #ifdef IFS_BROKEN static const char defifsvar[] = "IFS= \t\n"; - -#define defifs (defifsvar + 4) -#else -static const char defifs[] = " \t\n"; #endif +static const char defifs[] = " \t\n"; -static const struct varinit varinit[] = { +static struct var varinit[] = { #ifdef IFS_BROKEN - {&vifs, VSTRFIXED | VTEXTFIXED, defifsvar, + { 0, VSTRFIXED|VTEXTFIXED, defifsvar, 0 }, #else - {&vifs, VSTRFIXED | VTEXTFIXED | VUNSET, "IFS=", -#endif - NULL}, - {&vmail, VSTRFIXED | VTEXTFIXED | VUNSET, "MAIL=", - NULL}, - {&vmpath, VSTRFIXED | VTEXTFIXED | VUNSET, "MAILPATH=", - NULL}, - {&vpath, VSTRFIXED | VTEXTFIXED, defpathvar, - changepath}, -#if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT) - {&vps1, VSTRFIXED | VTEXTFIXED, "PS1=\\w \\$ ", - NULL}, -#endif /* else vps1 depends on uid */ - {&vps2, VSTRFIXED | VTEXTFIXED, "PS2=> ", - NULL}, - {&voptind, VSTRFIXED | VTEXTFIXED, "OPTIND=1", - getoptsreset}, + { 0, VSTRFIXED|VTEXTFIXED|VUNSET, "IFS\0", 0 }, +#endif + +#ifdef CONFIG_ASH_MAIL + { 0, VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL\0", changemail }, + { 0, VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH\0", changemail }, +#endif + + { 0, VSTRFIXED|VTEXTFIXED, defpathvar, changepath }, + { 0, VSTRFIXED|VTEXTFIXED, "PS1=$ ", 0 }, + { 0, VSTRFIXED|VTEXTFIXED, "PS2=> ", 0 }, + { 0, VSTRFIXED|VTEXTFIXED, "PS4=+ ", 0 }, +#ifdef CONFIG_ASH_GETOPTS + { 0, VSTRFIXED|VTEXTFIXED, "OPTIND=1", getoptsreset }, +#endif #ifdef CONFIG_LOCALE_SUPPORT - {&vlc_all, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL=", - change_lc_all}, - {&vlc_ctype, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE=", - change_lc_ctype}, + {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL=", change_lc_all}, + {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE=", change_lc_ctype}, #endif #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY - {&vhistfile, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE=", - NULL}, + {0, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE=", NULL}, #endif - {NULL, 0, NULL, - NULL} }; -#define VTABSIZE 39 +#define vifs varinit[0] +#ifdef CONFIG_ASH_MAIL +#define vmail (&vifs)[1] +#define vmpath (&vmail)[1] +#else +#define vmpath vifs +#endif +#define vpath (&vmpath)[1] +#define vps1 (&vpath)[1] +#define vps2 (&vps1)[1] +#define vps4 (&vps2)[1] +#define voptind (&vps4)[1] -static struct var *vartab[VTABSIZE]; +#define defpath (defpathvar + 5) /* * The following macros access the values of the above variables. @@ -1271,54 +1544,533 @@ static struct var *vartab[VTABSIZE]; #define pathval() (vpath.text + 5) #define ps1val() (vps1.text + 4) #define ps2val() (vps2.text + 4) +#define ps4val() (vps4.text + 4) #define optindval() (voptind.text + 7) #define mpathset() ((vmpath.flags & VUNSET) == 0) -static void initvar(void); static void setvar(const char *, const char *, int); static void setvareq(char *, int); -static void listsetvar(struct strlist *); -static const char *lookupvar(const char *); -static const char *bltinlookup(const char *); -static char **environment(void); -static int showvarscmd(int, char **); -static void mklocal(char *); +static void listsetvar(struct strlist *, int); +static char *lookupvar(const char *); +static char *bltinlookup(const char *); +static char **listvars(int, int, char ***); +#define environment() listvars(VEXPORT, VUNSET, 0) +static int showvars(const char *, int, int); static void poplocalvars(void); static int unsetvar(const char *); -static int varequal(const char *, const char *); +#ifdef CONFIG_ASH_GETOPTS +static int setvarsafe(const char *, const char *, int); +#endif +static int varcmp(const char *, const char *); +static struct var **hashvar(const char *); -static char *arg0; /* value of $0 */ -static struct shparam shellparam; /* current positional parameters */ -static char **argptr; /* argument list for builtin commands */ -static char *optionarg; /* set by nextopt (like getopt) */ -static char *optptr; /* used by nextopt */ -static char *minusc; /* argument to -c option */ +static inline int varequal(const char *a, const char *b) { + return !varcmp(a, b); +} +static int loopnest; /* current loop nesting level */ + +struct strpush { + struct strpush *prev; /* preceding string on stack */ + char *prevstring; + int prevnleft; #ifdef CONFIG_ASH_ALIAS + struct alias *ap; /* if push was associated with an alias */ +#endif + char *string; /* remember the string since it may change */ +}; -#define ALIASINUSE 1 -#define ALIASDEAD 2 +struct parsefile { + struct parsefile *prev; /* preceding file on stack */ + int linno; /* current line */ + int fd; /* file descriptor (or -1 if string) */ + int nleft; /* number of chars left in this line */ + int lleft; /* number of chars left in this buffer */ + char *nextc; /* next char in buffer */ + char *buf; /* input buffer */ + struct strpush *strpush; /* for pushing strings at this level */ + struct strpush basestrpush; /* so pushing one is fast */ +}; -#define ATABSIZE 39 +/* + * The parsefile structure pointed to by the global variable parsefile + * contains information about the current file being read. + */ -struct alias { - struct alias *next; - char *name; - char *val; - int flag; + +struct redirtab { + struct redirtab *next; + int renamed[10]; + int nullredirs; }; +static struct redirtab *redirlist; +static int nullredirs; + +extern char **environ; + +/* $NetBSD: output.h,v 1.16 2002/11/24 22:35:42 christos Exp $ */ + + +static void outstr(const char *, FILE *); +static void outcslow(int, FILE *); +static void flushall(void); +static void flushout(FILE *); +static int out1fmt(const char *, ...) + __attribute__((__format__(__printf__,1,2))); +static int fmtstr(char *, size_t, const char *, ...) + __attribute__((__format__(__printf__,3,4))); +static void xwrite(int, const void *, size_t); + + +#define outerr(f) ferror(f) +#define out2c(c) outcslow((c), stderr) + +static void out1str(const char *p) +{ + outstr(p, stdout); +} + +static void out2str(const char *p) +{ + outstr(p, stderr); +} + +static void out1c(char c) +{ + char s[2]; + + s[0] = c; + s[1] = 0; + outstr(s, stdout); +} + +/* + * Initialization code. + */ + +/* + * This routine initializes the builtin variables. + */ + +static inline void +initvar(void) +{ + struct var *vp; + struct var *end; + struct var **vpp; + + /* + * PS1 depends on uid + */ +#if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT) + vps1.text = "PS1=\\w \\$ "; +#else + if (!geteuid()) + vps1.text = "PS1=# "; +#endif + vp = varinit; + end = vp + sizeof(varinit) / sizeof(varinit[0]); + do { + vpp = hashvar(vp->text); + vp->next = *vpp; + *vpp = vp; + } while (++vp < end); +} + +static inline void +init(void) +{ + + /* from input.c: */ + { + basepf.nextc = basepf.buf = basebuf; + } + + /* from trap.c: */ + { + signal(SIGCHLD, SIG_DFL); + } + + /* from var.c: */ + { + char **envp; + char ppid[32]; + + initvar(); + for (envp = environ ; *envp ; envp++) { + if (strchr(*envp, '=')) { + setvareq(*envp, VEXPORT|VTEXTFIXED); + } + } + + snprintf(ppid, sizeof(ppid), "%d", (int) getppid()); + setvar("PPID", ppid, 0); + setpwd(0, 0); + } +} + +/* PEOF (the end of file marker) */ + +/* + * The input line number. Input.c just defines this variable, and saves + * and restores it when files are pushed and popped. The user of this + * package must set its value. + */ + +static int pgetc(void); +static int pgetc2(void); +static int preadbuffer(void); +static void pungetc(void); +static void pushstring(char *, void *); +static void popstring(void); +static void setinputfile(const char *, int); +static void setinputfd(int, int); +static void setinputstring(char *); +static void popfile(void); +static void popallfiles(void); +static void closescript(void); + + +/* $NetBSD: jobs.h,v 1.17 2003/01/22 20:36:04 dsl Exp $ */ + + +/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */ +#define FORK_FG 0 +#define FORK_BG 1 +#define FORK_NOJOB 2 + +/* mode flags for showjob(s) */ +#define SHOW_PGID 0x01 /* only show pgid - for jobs -p */ +#define SHOW_PID 0x04 /* include process pid */ +#define SHOW_CHANGED 0x08 /* only jobs whose state has changed */ + + +/* + * A job structure contains information about a job. A job is either a + * single process or a set of processes contained in a pipeline. In the + * latter case, pidlist will be non-NULL, and will point to a -1 terminated + * array of pids. + */ + +struct procstat { + pid_t pid; /* process id */ + int status; /* last process status from wait() */ + char *cmd; /* text of command being run */ +}; + +struct job { + struct procstat ps0; /* status of process */ + struct procstat *ps; /* status or processes when more than one */ +#if JOBS + int stopstatus; /* status of a stopped job */ +#endif + uint32_t + nprocs: 16, /* number of processes */ + state: 8, +#define JOBRUNNING 0 /* at least one proc running */ +#define JOBSTOPPED 1 /* all procs are stopped */ +#define JOBDONE 2 /* all procs are completed */ +#if JOBS + sigint: 1, /* job was killed by SIGINT */ + jobctl: 1, /* job running under job control */ +#endif + waited: 1, /* true if this entry has been waited for */ + used: 1, /* true if this entry is in used */ + changed: 1; /* true if status has changed */ + struct job *prev_job; /* previous job */ +}; + +static pid_t backgndpid; /* pid of last background process */ +static int job_warning; /* user was warned about stopped jobs */ +#if JOBS +static int jobctl; /* true if doing job control */ +#endif + +static struct job *makejob(union node *, int); +static int forkshell(struct job *, union node *, int); +static int waitforjob(struct job *); +static int stoppedjobs(void); + +#if ! JOBS +#define setjobctl(on) /* do nothing */ +#else +static void setjobctl(int); +static void showjobs(FILE *, int); +#endif + +/* $NetBSD: main.h,v 1.9 2002/11/24 22:35:41 christos Exp $ */ + + +/* pid of main shell */ +static int rootpid; +/* true if we aren't a child of the main shell */ +static int rootshell; + +static void readcmdfile(char *); +static void cmdloop(int); + +/* $NetBSD: memalloc.h,v 1.13 2003/01/22 20:36:04 dsl Exp $ */ + + +struct stackmark { + struct stack_block *stackp; + char *stacknxt; + size_t stacknleft; + struct stackmark *marknext; +}; + +/* minimum size of a block */ +#define MINSIZE SHELL_ALIGN(504) + +struct stack_block { + struct stack_block *prev; + char space[MINSIZE]; +}; + +static struct stack_block stackbase; +static struct stack_block *stackp = &stackbase; +static struct stackmark *markp; +static char *stacknxt = stackbase.space; +static size_t stacknleft = MINSIZE; +static char *sstrend = stackbase.space + MINSIZE; +static int herefd = -1; + + +static pointer ckmalloc(size_t); +static pointer ckrealloc(pointer, size_t); +static char *savestr(const char *); +static pointer stalloc(size_t); +static void stunalloc(pointer); +static void setstackmark(struct stackmark *); +static void popstackmark(struct stackmark *); +static void growstackblock(void); +static void *growstackstr(void); +static char *makestrspace(size_t, char *); +static char *stnputs(const char *, size_t, char *); +static char *stputs(const char *, char *); + + +static inline char *_STPUTC(char c, char *p) { + if (p == sstrend) + p = growstackstr(); + *p++ = c; + return p; +} + +#define stackblock() ((void *)stacknxt) +#define stackblocksize() stacknleft +#define STARTSTACKSTR(p) ((p) = stackblock()) +#define STPUTC(c, p) ((p) = _STPUTC((c), (p))) +#define CHECKSTRSPACE(n, p) \ + ({ \ + char *q = (p); \ + size_t l = (n); \ + size_t m = sstrend - q; \ + if (l > m) \ + (p) = makestrspace(l, q); \ + 0; \ + }) +#define USTPUTC(c, p) (*p++ = (c)) +#define STACKSTRNUL(p) ((p) == sstrend? (p = growstackstr(), *p = '\0') : (*p = '\0')) +#define STUNPUTC(p) (--p) +#define STTOPC(p) p[-1] +#define STADJUST(amount, p) (p += (amount)) + +#define grabstackstr(p) stalloc((char *)(p) - (char *)stackblock()) +#define ungrabstackstr(s, p) stunalloc((s)) +#define stackstrend() ((void *)sstrend) + +#define ckfree(p) free((pointer)(p)) + +/* $NetBSD: mystring.h,v 1.10 2002/11/24 22:35:42 christos Exp $ */ + + +#define DOLATSTRLEN 4 + +static char *prefix(const char *, const char *); +static int number(const char *); +static int is_number(const char *); +static char *single_quote(const char *); +static char *sstrdup(const char *); + +#define equal(s1, s2) (strcmp(s1, s2) == 0) +#define scopy(s1, s2) ((void)strcpy(s2, s1)) + +/* $NetBSD: options.h,v 1.16 2003/01/22 20:36:04 dsl Exp $ */ + +struct shparam { + int nparam; /* # of positional parameters (without $0) */ + unsigned char malloc; /* if parameter list dynamically allocated */ + char **p; /* parameter list */ +#ifdef CONFIG_ASH_GETOPTS + int optind; /* next parameter to be processed by getopts */ + int optoff; /* used by getopts */ +#endif +}; + + +#define eflag optlist[0] +#define fflag optlist[1] +#define Iflag optlist[2] +#define iflag optlist[3] +#define mflag optlist[4] +#define nflag optlist[5] +#define sflag optlist[6] +#define xflag optlist[7] +#define vflag optlist[8] +#define Cflag optlist[9] +#define aflag optlist[10] +#define bflag optlist[11] +#define uflag optlist[12] +#define qflag optlist[13] + +#ifdef DEBUG +#define nolog optlist[14] +#define debug optlist[15] +#define NOPTS 16 +#else +#define NOPTS 14 +#endif + +/* $NetBSD: options.c,v 1.33 2003/01/22 20:36:04 dsl Exp $ */ + + +static const char *const optletters_optnames[NOPTS] = { + "e" "errexit", + "f" "noglob", + "I" "ignoreeof", + "i" "interactive", + "m" "monitor", + "n" "noexec", + "s" "stdin", + "x" "xtrace", + "v" "verbose", + "C" "noclobber", + "a" "allexport", + "b" "notify", + "u" "nounset", + "q" "quietprofile", +#ifdef DEBUG + "\0" "nolog", + "\0" "debug", +#endif +}; + +#define optletters(n) optletters_optnames[(n)][0] +#define optnames(n) (&optletters_optnames[(n)][1]) + + +static char optlist[NOPTS]; + + +static char *arg0; /* value of $0 */ +static struct shparam shellparam; /* $@ current positional parameters */ +static char **argptr; /* argument list for builtin commands */ +static char *optionarg; /* set by nextopt (like getopt) */ +static char *optptr; /* used by nextopt */ + +static char *minusc; /* argument to -c option */ + + +static void procargs(int, char **); +static void optschanged(void); +static void setparam(char **); +static void freeparam(volatile struct shparam *); +static int shiftcmd(int, char **); +static int setcmd(int, char **); +static int nextopt(const char *); + +/* $NetBSD: redir.h,v 1.14 2002/11/24 22:35:43 christos Exp $ */ + +/* flags passed to redirect */ +#define REDIR_PUSH 01 /* save previous values of file descriptors */ + +union node; +static void redirect(union node *, int); +static void popredir(int); +static void clearredir(int); +static int copyfd(int, int); +static int redirectsafe(union node *, int); + +/* $NetBSD: show.h,v 1.6 2003/01/22 20:36:04 dsl Exp $ */ + + +#ifdef DEBUG +static void showtree(union node *); +static void trace(const char *, ...); +static void tracev(const char *, va_list); +static void trargs(char **); +static void trputc(int); +static void trputs(const char *); +static void opentrace(void); +#endif + +/* $NetBSD: trap.h,v 1.16 2002/11/24 22:35:43 christos Exp $ */ + + +/* trap handler commands */ +static char *trap[NSIG]; +/* current value of signal */ +static char sigmode[NSIG - 1]; +/* indicates specified signal received */ +static char gotsig[NSIG - 1]; + +static void clear_traps(void); +static void setsignal(int); +static void ignoresig(int); +static void onsig(int); +static void dotrap(void); +static void setinteractive(int); +static void exitshell(void) __attribute__((__noreturn__)); +static int decode_signal(const char *, int); + +/* + * This routine is called when an error or an interrupt occurs in an + * interactive shell and control is returned to the main command loop. + */ + +static void +reset(void) +{ + /* from eval.c: */ + { + evalskip = 0; + loopnest = 0; + funcnest = 0; + } + + /* from input.c: */ + { + parselleft = parsenleft = 0; /* clear input buffer */ + popallfiles(); + } + + /* from parser.c: */ + { + tokpushback = 0; + checkkwd = 0; + } + + /* from redir.c: */ + { + clearredir(0); + } + +} + +#ifdef CONFIG_ASH_ALIAS static struct alias *atab[ATABSIZE]; -static void setalias(char *, char *); -static struct alias **hashalias(const char *); +static void setalias(const char *, const char *); static struct alias *freealias(struct alias *); static struct alias **__lookupalias(const char *); -static void setalias(char *name, char *val) +static void +setalias(const char *name, const char *val) { struct alias *ap, **app; @@ -1327,15 +2079,15 @@ static void setalias(char *name, char *val) INTOFF; if (ap) { if (!(ap->flag & ALIASINUSE)) { - free(ap->val); + ckfree(ap->val); } - ap->val = bb_xstrdup(val); + ap->val = savestr(val); ap->flag &= ~ALIASDEAD; } else { /* not found */ - ap = xmalloc(sizeof(struct alias)); - ap->name = bb_xstrdup(name); - ap->val = bb_xstrdup(val); + ap = ckmalloc(sizeof (struct alias)); + ap->name = savestr(name); + ap->val = savestr(val); ap->flag = 0; ap->next = 0; *app = ap; @@ -1343,7 +2095,8 @@ static void setalias(char *name, char *val) INTON; } -static int unalias(char *name) +static int +unalias(const char *name) { struct alias **app; @@ -1359,7 +2112,8 @@ static int unalias(char *name) return (1); } -static void rmaliases(void) +static void +rmaliases(void) { struct alias *ap, **app; int i; @@ -1377,20 +2131,21 @@ static void rmaliases(void) INTON; } -static void printalias(const struct alias *ap) +static struct alias * +lookupalias(const char *name, int check) { - char *p; + struct alias *ap = *__lookupalias(name); - p = single_quote(ap->val); - printf("alias %s=%s\n", ap->name, p); - stunalloc(p); + if (check && ap && (ap->flag & ALIASINUSE)) + return (NULL); + return (ap); } - /* * TODO - sort output */ -static int aliascmd(int argc, char **argv) +static int +aliascmd(int argc, char **argv) { char *n, *v; int ret = 0; @@ -1406,9 +2161,9 @@ static int aliascmd(int argc, char **argv) return (0); } while ((n = *++argv) != NULL) { - if ((v = strchr(n + 1, '=')) == NULL) { /* n+1: funny ksh stuff */ + if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */ if ((ap = *__lookupalias(n)) == NULL) { - out2fmt("%s: %s not found\n", "alias", n); + fprintf(stderr, "%s: %s not found\n", "alias", n); ret = 1; } else printalias(ap); @@ -1421,7 +2176,8 @@ static int aliascmd(int argc, char **argv) return (ret); } -static int unaliascmd(int argc, char **argv) +static int +unaliascmd(int argc, char **argv) { int i; @@ -1433,7 +2189,7 @@ static int unaliascmd(int argc, char **argv) } for (i = 0; *argptr; argptr++) { if (unalias(*argptr)) { - out2fmt("%s: %s not found\n", "unalias", *argptr); + fprintf(stderr, "%s: %s not found\n", "unalias", *argptr); i = 1; } } @@ -1441,18 +2197,8 @@ static int unaliascmd(int argc, char **argv) return (i); } -static struct alias **hashalias(const char *p) -{ - unsigned int hashval; - - hashval = *p << 4; - while (*p) - hashval += *p++; - return &atab[hashval % ATABSIZE]; -} - -static struct alias *freealias(struct alias *ap) -{ +static struct alias * +freealias(struct alias *ap) { struct alias *next; if (ap->flag & ALIASINUSE) { @@ -1461,16 +2207,33 @@ static struct alias *freealias(struct alias *ap) } next = ap->next; - free(ap->name); - free(ap->val); - free(ap); + ckfree(ap->name); + ckfree(ap->val); + ckfree(ap); return next; } +static void +printalias(const struct alias *ap) { + out1fmt("%s=%s\n", ap->name, single_quote(ap->val)); +} -static struct alias **__lookupalias(const char *name) -{ - struct alias **app = hashalias(name); +static struct alias ** +__lookupalias(const char *name) { + unsigned int hashval; + struct alias **app; + const char *p; + unsigned int ch; + + p = name; + + ch = (unsigned char)*p; + hashval = ch << 4; + while (ch) { + hashval += ch; + ch = (unsigned char)*++p; + } + app = &atab[hashval % ATABSIZE]; for (; *app; app = &(*app)->next) { if (equal(name, (*app)->name)) { @@ -1480,362 +2243,257 @@ static struct alias **__lookupalias(const char *name) return app; } -#endif - -#ifdef CONFIG_ASH_MATH_SUPPORT -/* The generated file arith.c has been replaced with a custom hand - * written implementation written by Aaron Lehmann <aaronl@vitelus.com>. - * This is now part of libbb, so that it can be used by all the shells - * in busybox. */ -static void expari(int); -#endif - -static char *trap[NSIG]; /* trap handler commands */ -static char sigmode[NSIG - 1]; /* current value of signal */ -static char gotsig[NSIG - 1]; /* indicates specified signal received */ -static int pendingsigs; /* indicates some signal received */ - -/* - * This file was generated by the mkbuiltins program. - */ - -#ifdef CONFIG_ASH_JOB_CONTROL -static int bgcmd(int, char **); -static int fgcmd(int, char **); -static int killcmd(int, char **); -#endif -static int bltincmd(int, char **); -static int cdcmd(int, char **); -static int breakcmd(int, char **); - -#ifdef CONFIG_ASH_CMDCMD -static int commandcmd(int, char **); -#endif -static int dotcmd(int, char **); -static int evalcmd(int, char **); -static int execcmd(int, char **); -static int exitcmd(int, char **); -static int exportcmd(int, char **); -static int histcmd(int, char **); -static int hashcmd(int, char **); -static int helpcmd(int, char **); -static int jobscmd(int, char **); -static int localcmd(int, char **); -static int pwdcmd(int, char **); -static int readcmd(int, char **); -static int returncmd(int, char **); -static int setcmd(int, char **); -static int setvarcmd(int, char **); -static int shiftcmd(int, char **); -static int trapcmd(int, char **); -static int umaskcmd(int, char **); - -#ifdef CONFIG_ASH_ALIAS -static int aliascmd(int, char **); -static int unaliascmd(int, char **); -#endif -static int unsetcmd(int, char **); -static int waitcmd(int, char **); -static int ulimitcmd(int, char **); -static int timescmd(int, char **); - -#ifdef CONFIG_ASH_MATH_SUPPORT -static int letcmd(int, char **); -#endif -static int typecmd(int, char **); - -#ifdef CONFIG_ASH_GETOPTS -static int getoptscmd(int, char **); -#endif - -#ifndef CONFIG_TRUE -static int true_main(int, char **); -#endif -#ifndef CONFIG_FALSE -static int false_main(int, char **); -#endif - -static void setpwd(const char *, int); - - -#define BUILTIN_NOSPEC "0" -#define BUILTIN_SPECIAL "1" -#define BUILTIN_REGULAR "2" -#define BUILTIN_ASSIGN "4" -#define BUILTIN_SPEC_ASSG "5" -#define BUILTIN_REG_ASSG "6" - -#define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1) -#define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2) -#define IS_BUILTIN_ASSIGN(builtincmd) ((builtincmd)->name[0] & 4) +#endif /* CONFIG_ASH_ALIAS */ -struct builtincmd { - const char *name; - int (*const builtinfunc) (int, char **); - //unsigned flags; -}; - - -/* It is CRUCIAL that this listing be kept in ascii order, otherwise - * the binary search in find_builtin() will stop working. If you value - * your kneecaps, you'll be sure to *make sure* that any changes made - * to this array result in the listing remaining in ascii order. You - * have been warned. - */ -static const struct builtincmd builtincmds[] = { - {BUILTIN_SPECIAL ".", dotcmd}, /* first, see declare DOTCMD */ - {BUILTIN_SPECIAL ":", true_main}, -#ifdef CONFIG_ASH_ALIAS - {BUILTIN_REG_ASSG "alias", aliascmd}, -#endif -#ifdef CONFIG_ASH_JOB_CONTROL - {BUILTIN_REGULAR "bg", bgcmd}, -#endif - {BUILTIN_SPECIAL "break", breakcmd}, - {BUILTIN_SPECIAL "builtin", bltincmd}, - {BUILTIN_REGULAR "cd", cdcmd}, - {BUILTIN_NOSPEC "chdir", cdcmd}, -#ifdef CONFIG_ASH_CMDCMD - {BUILTIN_REGULAR "command", commandcmd}, -#endif - {BUILTIN_SPECIAL "continue", breakcmd}, - {BUILTIN_SPECIAL "eval", evalcmd}, - {BUILTIN_SPECIAL "exec", execcmd}, - {BUILTIN_SPECIAL "exit", exitcmd}, - {BUILTIN_SPEC_ASSG "export", exportcmd}, - {BUILTIN_REGULAR "false", false_main}, - {BUILTIN_REGULAR "fc", histcmd}, -#ifdef CONFIG_ASH_JOB_CONTROL - {BUILTIN_REGULAR "fg", fgcmd}, -#endif -#ifdef CONFIG_ASH_GETOPTS - {BUILTIN_REGULAR "getopts", getoptscmd}, -#endif - {BUILTIN_NOSPEC "hash", hashcmd}, - {BUILTIN_NOSPEC "help", helpcmd}, - {BUILTIN_REGULAR "jobs", jobscmd}, -#ifdef CONFIG_ASH_JOB_CONTROL - {BUILTIN_REGULAR "kill", killcmd}, -#endif -#ifdef CONFIG_ASH_MATH_SUPPORT - {BUILTIN_REGULAR "let", letcmd}, -#endif - {BUILTIN_ASSIGN "local", localcmd}, - {BUILTIN_NOSPEC "pwd", pwdcmd}, - {BUILTIN_REGULAR "read", readcmd}, - {BUILTIN_SPEC_ASSG "readonly", exportcmd}, - {BUILTIN_SPECIAL "return", returncmd}, - {BUILTIN_SPECIAL "set", setcmd}, - {BUILTIN_NOSPEC "setvar", setvarcmd}, - {BUILTIN_SPECIAL "shift", shiftcmd}, - {BUILTIN_SPECIAL "times", timescmd}, - {BUILTIN_SPECIAL "trap", trapcmd}, - {BUILTIN_REGULAR "true", true_main}, - {BUILTIN_NOSPEC "type", typecmd}, - {BUILTIN_NOSPEC "ulimit", ulimitcmd}, - {BUILTIN_REGULAR "umask", umaskcmd}, -#ifdef CONFIG_ASH_ALIAS - {BUILTIN_REGULAR "unalias", unaliascmd}, -#endif - {BUILTIN_SPECIAL "unset", unsetcmd}, - {BUILTIN_REGULAR "wait", waitcmd}, -}; -#define NUMBUILTINS (sizeof (builtincmds) / sizeof (struct builtincmd) ) - -#define DOTCMD &builtincmds[0] -static struct builtincmd *BLTINCMD; -static struct builtincmd *EXECCMD; -static struct builtincmd *EVALCMD; - -/* states */ -#define JOBSTOPPED 1 /* all procs are stopped */ -#define JOBDONE 2 /* all procs are completed */ +/* $NetBSD: cd.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */ /* - * A job structure contains information about a job. A job is either a - * single process or a set of processes contained in a pipeline. In the - * latter case, pidlist will be non-NULL, and will point to a -1 terminated - * array of pids. + * The cd and pwd commands. */ -struct procstat { - pid_t pid; /* process id */ - int status; /* status flags (defined above) */ - char *cmd; /* text of command being run */ -}; - - -static int job_warning; /* user was warned about stopped jobs */ - -#ifdef CONFIG_ASH_JOB_CONTROL -static void setjobctl(int enable); -#else -#define setjobctl(on) /* do nothing */ -#endif - - -struct job { - struct procstat ps0; /* status of process */ - struct procstat *ps; /* status or processes when more than one */ - short nprocs; /* number of processes */ - short pgrp; /* process group of this job */ - char state; /* true if job is finished */ - char used; /* true if this entry is in used */ - char changed; /* true if status has changed */ -#ifdef CONFIG_ASH_JOB_CONTROL - char jobctl; /* job running under job control */ -#endif -}; - -static struct job *jobtab; /* array of jobs */ -static int njobs; /* size of array */ -static int backgndpid = -1; /* pid of last background process */ +#define CD_PHYSICAL 1 +#define CD_PRINT 2 -#ifdef CONFIG_ASH_JOB_CONTROL -static int initialpgrp; /* pgrp of shell on invocation */ -static int curjob; /* current job */ -static int jobctl; -#endif +static int docd(const char *, int); +static int cdopt(void); -static struct job *makejob(const union node *, int); -static int forkshell(struct job *, const union node *, int); -static int waitforjob(struct job *); +static char *curdir = nullstr; /* current working directory */ +static char *physdir = nullstr; /* physical working directory */ -static int docd(char *, int); -static void getpwd(void); +static int +cdopt(void) +{ + int flags = 0; + int i, j; -static char *padvance(const char **, const char *); + j = 'L'; + while ((i = nextopt("LP"))) { + if (i != j) { + flags ^= CD_PHYSICAL; + j = i; + } + } -static char nullstr[1]; /* zero length string */ -static char *curdir = nullstr; /* current working directory */ + return flags; +} -static int cdcmd(int argc, char **argv) +static int +cdcmd(int argc, char **argv) { const char *dest; const char *path; - char *p; + const char *p; + char c; struct stat statb; - int print = 0; + int flags; - nextopt(nullstr); - if ((dest = *argptr) == NULL && (dest = bltinlookup("HOME")) == NULL) - error("HOME not set"); - if (*dest == '\0') - dest = "."; - if (dest[0] == '-' && dest[1] == '\0') { + flags = cdopt(); + dest = *argptr; + if (!dest) + dest = bltinlookup(homestr); + else if (dest[0] == '-' && dest[1] == '\0') { dest = bltinlookup("OLDPWD"); - if (!dest || !*dest) { - dest = curdir; + flags |= CD_PRINT; + goto step7; + } + if (!dest) + dest = nullstr; + if (*dest == '/') + goto step7; + if (*dest == '.') { + c = dest[1]; +dotdot: + switch (c) { + case '\0': + case '/': + goto step6; + case '.': + c = dest[2]; + if (c != '.') + goto dotdot; } - print = 1; - if (dest) - print = 1; - else - dest = "."; } - if (*dest == '/' || (path = bltinlookup("CDPATH")) == NULL) - path = nullstr; - while ((p = padvance(&path, dest)) != NULL) { + if (!*dest) + dest = "."; + if (!(path = bltinlookup("CDPATH"))) { +step6: +step7: + p = dest; + goto docd; + } + do { + c = *path; + p = padvance(&path, dest); if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) { - if (!print) { - /* - * XXX - rethink - */ - if (p[0] == '.' && p[1] == '/' && p[2] != '\0') - p += 2; - print = strcmp(p, dest); - } - if (docd(p, print) >= 0) - return 0; - + if (c && c != ':') + flags |= CD_PRINT; +docd: + if (!docd(p, flags)) + goto out; + break; } - } + } while (path); error("can't cd to %s", dest); /* NOTREACHED */ +out: + if (flags & CD_PRINT) + out1fmt(snlfmt, curdir); + return 0; } /* * Update curdir (the name of the current directory) in response to a - * cd command. We also call hashcd to let the routines in exec.c know - * that the current directory has changed. + * cd command. */ -static void hashcd(void); - -static inline void updatepwd(const char *dir) +static inline const char * +updatepwd(const char *dir) { - hashcd(); /* update command hash table */ + char *new; + char *p; + char *cdcomppath; + const char *lim; - /* - * If our argument is NULL, we don't know the current directory - */ - if (dir == NULL || curdir == nullstr) { - setpwd(0, 1); + cdcomppath = sstrdup(dir); + STARTSTACKSTR(new); + if (*dir != '/') { + if (curdir == nullstr) + return 0; + new = stputs(curdir, new); + } + new = makestrspace(strlen(dir) + 2, new); + lim = stackblock() + 1; + if (*dir != '/') { + if (new[-1] != '/') + USTPUTC('/', new); + if (new > lim && *lim == '/') + lim++; } else { - setpwd(dir, 1); + USTPUTC('/', new); + cdcomppath++; + if (dir[1] == '/' && dir[2] != '/') { + USTPUTC('/', new); + cdcomppath++; + lim++; + } + } + p = strtok(cdcomppath, "/"); + while (p) { + switch(*p) { + case '.': + if (p[1] == '.' && p[2] == '\0') { + while (new > lim) { + STUNPUTC(new); + if (new[-1] == '/') + break; + } + break; + } else if (p[1] == '\0') + break; + /* fall through */ + default: + new = stputs(p, new); + USTPUTC('/', new); + } + p = strtok(0, "/"); } + if (new > lim) + STUNPUTC(new); + *new = 0; + return stackblock(); } /* - * Actually do the chdir. In an interactive shell, print the - * directory name if "print" is nonzero. + * Actually do the chdir. We also call hashcd to let the routines in exec.c + * know that the current directory has changed. */ -static int docd(char *dest, int print) +static int +docd(const char *dest, int flags) { - TRACE(("docd(\"%s\", %d) called\n", dest, print)); + const char *dir = 0; + int err; + + TRACE(("docd(\"%s\", %d) called\n", dest, flags)); + INTOFF; - if (chdir(dest) < 0) { - INTON; - return -1; + if (!(flags & CD_PHYSICAL)) { + dir = updatepwd(dest); + if (dir) + dest = dir; } - updatepwd(dest); + err = chdir(dest); + if (err) + goto out; + setpwd(dir, 1); + hashcd(); +out: INTON; - if (print && iflag) - puts(curdir); - return 0; + return err; } - -static int pwdcmd(int argc, char **argv) +/* + * Find out what the current directory is. If we already know the current + * directory, this routine returns immediately. + */ +static inline char * +getpwd(void) { - puts(curdir); - return 0; + char *dir = getcwd(0, 0); + return dir ? dir : nullstr; } -/* Ask system the current directory */ -static void getpwd(void) +static int +pwdcmd(int argc, char **argv) { - curdir = xgetcwd(0); - if (curdir == 0) - curdir = nullstr; + int flags; + const char *dir = curdir; + + flags = cdopt(); + if (flags) { + if (physdir == nullstr) + setpwd(dir, 0); + dir = physdir; + } + out1fmt(snlfmt, dir); + return 0; } -static void setpwd(const char *val, int setold) +static void +setpwd(const char *val, int setold) { - char *cated = NULL; + char *oldcur, *dir; + + oldcur = dir = curdir; if (setold) { - setvar("OLDPWD", curdir, VEXPORT); + setvar("OLDPWD", oldcur, VEXPORT); } INTOFF; - if (curdir != nullstr) { - if (val != NULL && *val != '/') - val = cated = concat_path_file(curdir, val); - free(curdir); + if (physdir != nullstr) { + if (physdir != oldcur) + free(physdir); + physdir = nullstr; + } + if (oldcur == val || !val) { + char *s = getpwd(); + physdir = s; + if (!val) + dir = s; + } else + dir = savestr(val); + if (oldcur != dir && oldcur != nullstr) { + free(oldcur); } - if (!val) - getpwd(); - else - curdir = bb_simplify_path(val); - if (cated) - free(cated); + curdir = dir; INTON; - setvar("PWD", curdir, VEXPORT); + setvar("PWD", dir, VEXPORT); } +/* $NetBSD: error.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */ + /* * Errors and exceptions. */ @@ -1844,32 +2502,10 @@ static void setpwd(const char *val, int setold) * Code to handle exceptions in C. */ -/* - * We enclose jmp_buf in a structure so that we can declare pointers to - * jump locations. The global variable handler contains the location to - * jump to when an exception occurs, and the global variable exception - * contains a code identifying the exeception. To implement nested - * exception handlers, the user should save the value of handler on entry - * to an inner scope, set handler to point to a jmploc structure for the - * inner scope, and restore handler on exit from the scope. - */ - -struct jmploc { - jmp_buf loc; -}; -/* exceptions */ -#define EXINT 0 /* SIGINT received */ -#define EXERROR 1 /* a generic error */ -#define EXSHELLPROC 2 /* execute a shell procedure */ -#define EXEXEC 3 /* command execution failed */ -#define EXREDIR 4 /* redirection error */ - -static struct jmploc *handler; -static int exception; static void exverror(int, const char *, va_list) - __attribute__ ((__noreturn__)); + __attribute__((__noreturn__)); /* * Called to raise an exception. Since C doesn't include exceptions, we @@ -1877,15 +2513,15 @@ static void exverror(int, const char *, va_list) * stored in the global variable "exception". */ -static void exraise(int) __attribute__ ((__noreturn__)); - -static void exraise(int e) +static void +exraise(int e) { #ifdef DEBUG if (handler == NULL) abort(); #endif - flushall(); + INTOFF; + exception = e; longjmp(handler->loc, 1); } @@ -1895,62 +2531,74 @@ static void exraise(int e) * Called from trap.c when a SIGINT is received. (If the user specifies * that SIGINT is to be trapped or ignored using the trap builtin, then * this routine is not called.) Suppressint is nonzero when interrupts - * are held using the INTOFF macro. The call to _exit is necessary because - * there is a short period after a fork before the signal handlers are - * set to the appropriate value for the child. (The test for iflag is - * just defensive programming.) + * are held using the INTOFF macro. (The test for iflag is just + * defensive programming.) */ -static void onint(void) -{ - sigset_t mysigset; +static void +onint(void) { + int i; - if (suppressint) { - intpending++; - return; - } intpending = 0; - sigemptyset(&mysigset); - sigprocmask(SIG_SETMASK, &mysigset, NULL); - if (!(rootshell && iflag)) { - signal(SIGINT, SIG_DFL); - raise(SIGINT); + sigsetmask(0); + i = EXSIG; + if (gotsig[SIGINT - 1] && !trap[SIGINT]) { + if (!(rootshell && iflag)) { + signal(SIGINT, SIG_DFL); + raise(SIGINT); + } + i = EXINT; } - exraise(EXINT); + exraise(i); /* NOTREACHED */ } +static void +exvwarning(const char *msg, va_list ap) +{ + FILE *errs; + const char *name; + const char *fmt; -static char *commandname; /* currently executing command */ + errs = stderr; + name = arg0; + fmt = "%s: "; + if (commandname) { + name = commandname; + fmt = "%s: %d: "; + } + fprintf(errs, fmt, name, startlinno); + vfprintf(errs, msg, ap); + outcslow('\n', errs); +} /* - * Exverror is called to raise the error exception. If the first argument + * Exverror is called to raise the error exception. If the second argument * is not NULL then error prints an error message using printf style * formatting. It then raises the error exception. */ -static void exverror(int cond, const char *msg, va_list ap) +static void +exverror(int cond, const char *msg, va_list ap) { - CLEAR_PENDING_INT; - INTOFF; - #ifdef DEBUG - if (msg) - TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid())); - else + if (msg) { + TRACE(("exverror(%d, \"", cond)); + TRACEV((msg, ap)); + TRACE(("\") pid=%d\n", getpid())); + } else TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid())); + if (msg) #endif - if (msg) { - if (commandname) - out2fmt("%s: ", commandname); - vfprintf(stderr, msg, ap); - out2c('\n'); - } + exvwarning(msg, ap); + + flushall(); exraise(cond); /* NOTREACHED */ } -static void error(const char *msg, ...) +static void +error(const char *msg, ...) { va_list ap; @@ -1961,7 +2609,8 @@ static void error(const char *msg, ...) } -static void exerror(int cond, const char *msg, ...) +static void +exerror(int cond, const char *msg, ...) { va_list ap; @@ -1971,82 +2620,20 @@ static void exerror(int cond, const char *msg, ...) va_end(ap); } - - /* - * Table of error messages. + * error/warning routines for external builtins */ -struct errname { - short errcode; /* error number */ - short action; /* operation which encountered the error */ -}; - -/* - * Types of operations (passed to the errmsg routine). - */ - -#define E_OPEN 01 /* opening a file */ -#define E_CREAT 02 /* creating a file */ -#define E_EXEC 04 /* executing a program */ - -#define ALL (E_OPEN|E_CREAT|E_EXEC) +static void +sh_warnx(const char *fmt, ...) +{ + va_list ap; -static const struct errname errormsg[] = { - {EINTR, ALL}, - {EACCES, ALL}, - {EIO, ALL}, - {ENOENT, E_OPEN}, - {ENOENT, E_CREAT}, - {ENOENT, E_EXEC}, - {ENOTDIR, E_OPEN}, - {ENOTDIR, E_CREAT}, - {ENOTDIR, E_EXEC}, - {EISDIR, ALL}, - {EEXIST, E_CREAT}, -#ifdef EMFILE - {EMFILE, ALL}, -#endif - {ENFILE, ALL}, - {ENOSPC, ALL}, -#ifdef EDQUOT - {EDQUOT, ALL}, -#endif -#ifdef ENOSR - {ENOSR, ALL}, -#endif - {ENXIO, ALL}, - {EROFS, ALL}, - {ETXTBSY, ALL}, -#ifdef EAGAIN - {EAGAIN, E_EXEC}, -#endif - {ENOMEM, ALL}, -#ifdef ENOLINK - {ENOLINK, ALL}, -#endif -#ifdef EMULTIHOP - {EMULTIHOP, ALL}, -#endif -#ifdef ECOMM - {ECOMM, ALL}, -#endif -#ifdef ESTALE - {ESTALE, ALL}, -#endif -#ifdef ETIMEDOUT - {ETIMEDOUT, ALL}, -#endif -#ifdef ELOOP - {ELOOP, ALL}, -#endif - {E2BIG, E_EXEC}, -#ifdef ELIBACC - {ELIBACC, E_EXEC}, -#endif -}; + va_start(ap, fmt); + exvwarning(fmt, ap); + va_end(ap); +} -#define ERRNAME_SIZE (sizeof(errormsg)/sizeof(struct errname)) /* * Return a string describing an error. The returned string may be a @@ -2054,57 +2641,47 @@ static const struct errname errormsg[] = { * Action describes the operation that got the error. */ -static const char *errmsg(int e, int action) +static const char * +errmsg(int e, const char *em) { - struct errname const *ep; - static char buf[12]; + if(e == ENOENT || e == ENOTDIR) { - for (ep = errormsg; ep < errormsg + ERRNAME_SIZE; ep++) { - if (ep->errcode == e && (ep->action & action) != 0) - return strerror(e); + return em; } - - snprintf(buf, sizeof buf, "error %d", e); - return buf; + return strerror(e); } -#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE -static void __inton() -{ - if (--suppressint == 0 && intpending) { - onint(); - } -} -static void forceinton(void) -{ - suppressint = 0; - if (intpending) - onint(); -} -#endif - -/* flags in argument to evaltree */ -#define EV_EXIT 01 /* exit after evaluating tree */ -#define EV_TESTED 02 /* exit status is checked; ignore -e flag */ -#define EV_BACKCMD 04 /* command executing within back quotes */ +/* $NetBSD: eval.c,v 1.71 2003/01/23 03:33:16 rafal Exp $ */ -static int evalskip; /* set if we are skipping commands */ -static int skipcount; /* number of levels to skip */ -static int loopnest; /* current loop nesting level */ -static int funcnest; /* depth of function calls */ +/* + * Evaluate a command. + */ +/* flags in argument to evaltree */ +#define EV_EXIT 01 /* exit after evaluating tree */ +#define EV_TESTED 02 /* exit status is checked; ignore -e flag */ +#define EV_BACKCMD 04 /* command executing within back quotes */ -static struct strlist *cmdenviron; /* environment for builtin command */ -static int exitstatus; /* exit status of last command */ -static int oexitstatus; /* saved exit status */ -static void evalsubshell(const union node *, int); +static void evalloop(union node *, int); +static void evalfor(union node *, int); +static void evalcase(union node *, int); +static void evalsubshell(union node *, int); static void expredir(union node *); +static void evalpipe(union node *, int); +static void evalcommand(union node *, int); +static int evalbltin(const struct builtincmd *, int, char **); +static int evalfun(struct funcnode *, int, char **, int); static void prehash(union node *); -static void eprintlist(struct strlist *); +static int eprintlist(struct strlist *, int); +static int bltincmd(int, char **); + + +static const struct builtincmd bltin = { + "\0\0", bltincmd +}; -static union node *parsecmd(int); /* * Called to reset things after an exception. @@ -2113,9 +2690,9 @@ static union node *parsecmd(int); /* * The eval commmand. */ -static void evalstring(char *, int); -static int evalcmd(int argc, char **argv) +static int +evalcmd(int argc, char **argv) { char *p; char *concat; @@ -2127,8 +2704,7 @@ static int evalcmd(int argc, char **argv) STARTSTACKSTR(concat); ap = argv + 2; for (;;) { - while (*p) - STPUTC(*p++, concat); + concat = stputs(p, concat); if ((p = *ap++) == NULL) break; STPUTC(' ', concat); @@ -2141,79 +2717,154 @@ static int evalcmd(int argc, char **argv) return exitstatus; } + /* * Execute a command or commands contained in a string. */ -static void evaltree(union node *, int); -static void setinputstring(char *); -static void popfile(void); -static void setstackmark(struct stackmark *mark); -static void popstackmark(struct stackmark *mark); - - -static void evalstring(char *s, int flag) +static void +evalstring(char *s, int flag) { union node *n; struct stackmark smark; setstackmark(&smark); setinputstring(s); + while ((n = parsecmd(0)) != NEOF) { evaltree(n, flag); popstackmark(&smark); + if (evalskip) + break; } popfile(); popstackmark(&smark); } -static struct builtincmd *find_builtin(const char *); -static void expandarg(union node *, struct arglist *, int); -static void calcsize(const union node *); -static union node *copynode(const union node *); + /* - * Make a copy of a parse tree. + * Evaluate a parse tree. The value is left in the global variable + * exitstatus. */ -static int funcblocksize; /* size of structures in function */ -static int funcstringsize; /* size of strings in node */ -static pointer funcblock; /* block to allocate function from */ -static char *funcstring; /* block to allocate strings from */ - - -static inline union node *copyfunc(union node *n) +static void +evaltree(union node *n, int flags) { - if (n == NULL) - return NULL; - funcblocksize = 0; - funcstringsize = 0; - calcsize(n); - funcblock = xmalloc(funcblocksize + funcstringsize); - funcstring = (char *) funcblock + funcblocksize; - return copynode(n); + int checkexit = 0; + void (*evalfn)(union node *, int); + unsigned isor; + int status; + if (n == NULL) { + TRACE(("evaltree(NULL) called\n")); + goto out; + } + TRACE(("pid %d, evaltree(%p: %d, %d) called\n", + getpid(), n, n->type, flags)); + switch (n->type) { + default: +#ifdef DEBUG + out1fmt("Node type = %d\n", n->type); + flushout(stdout); + break; +#endif + case NNOT: + evaltree(n->nnot.com, EV_TESTED); + status = !exitstatus; + goto setstatus; + case NREDIR: + expredir(n->nredir.redirect); + status = redirectsafe(n->nredir.redirect, REDIR_PUSH); + if (!status) { + evaltree(n->nredir.n, flags & EV_TESTED); + status = exitstatus; + } + popredir(0); + goto setstatus; + case NCMD: + evalfn = evalcommand; +checkexit: + if (eflag && !(flags & EV_TESTED)) + checkexit = ~0; + goto calleval; + case NFOR: + evalfn = evalfor; + goto calleval; + case NWHILE: + case NUNTIL: + evalfn = evalloop; + goto calleval; + case NSUBSHELL: + case NBACKGND: + evalfn = evalsubshell; + goto calleval; + case NPIPE: + evalfn = evalpipe; + goto checkexit; + case NCASE: + evalfn = evalcase; + goto calleval; + case NAND: + case NOR: + case NSEMI: +#if NAND + 1 != NOR +#error NAND + 1 != NOR +#endif +#if NOR + 1 != NSEMI +#error NOR + 1 != NSEMI +#endif + isor = n->type - NAND; + evaltree( + n->nbinary.ch1, + (flags | ((isor >> 1) - 1)) & EV_TESTED + ); + if (!exitstatus == isor) + break; + if (!evalskip) { + n = n->nbinary.ch2; +evaln: + evalfn = evaltree; +calleval: + evalfn(n, flags); + break; + } + break; + case NIF: + evaltree(n->nif.test, EV_TESTED); + if (evalskip) + break; + if (exitstatus == 0) { + n = n->nif.ifpart; + goto evaln; + } else if (n->nif.elsepart) { + n = n->nif.elsepart; + goto evaln; + } + goto success; + case NDEFUN: + defun(n->narg.text, n->narg.next); +success: + status = 0; +setstatus: + exitstatus = status; + break; + } +out: + if (pendingsigs) + dotrap(); + if (flags & EV_EXIT || checkexit & exitstatus) + exraise(EXEXIT); } -/* - * Add a new command entry, replacing any existing command entry for - * the same name. - */ -static inline void addcmdentry(char *name, struct cmdentry *entry) -{ - struct tblentry *cmdp; +#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3) +static +#endif +void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__)); - INTOFF; - cmdp = cmdlookup(name, 1); - if (cmdp->cmdtype == CMDFUNCTION) { - free(cmdp->param.func); - } - cmdp->cmdtype = entry->cmdtype; - cmdp->param = entry->u; - INTON; -} -static inline void evalloop(const union node *n, int flags) +static void +evalloop(union node *n, int flags) { int status; @@ -2221,9 +2872,11 @@ static inline void evalloop(const union node *n, int flags) status = 0; flags &= EV_TESTED; for (;;) { + int i; + evaltree(n->nbinary.ch1, EV_TESTED); if (evalskip) { - skipping:if (evalskip == SKIPCONT && --skipcount <= 0) { +skipping: if (evalskip == SKIPCONT && --skipcount <= 0) { evalskip = 0; continue; } @@ -2231,13 +2884,11 @@ static inline void evalloop(const union node *n, int flags) evalskip = 0; break; } - if (n->type == NWHILE) { - if (exitstatus != 0) - break; - } else { - if (exitstatus == 0) - break; - } + i = exitstatus; + if (n->type != NWHILE) + i = !i; + if (i != 0) + break; evaltree(n->nbinary.ch2, flags); status = exitstatus; if (evalskip) @@ -2247,7 +2898,10 @@ static inline void evalloop(const union node *n, int flags) exitstatus = status; } -static void evalfor(const union node *n, int flags) + + +static void +evalfor(union node *n, int flags) { struct arglist arglist; union node *argp; @@ -2256,9 +2910,9 @@ static void evalfor(const union node *n, int flags) setstackmark(&smark); arglist.lastp = &arglist.list; - for (argp = n->nfor.args; argp; argp = argp->narg.next) { - oexitstatus = exitstatus; + for (argp = n->nfor.args ; argp ; argp = argp->narg.next) { expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD); + /* XXX */ if (evalskip) goto out; } @@ -2267,7 +2921,7 @@ static void evalfor(const union node *n, int flags) exitstatus = 0; loopnest++; flags &= EV_TESTED; - for (sp = arglist.list; sp; sp = sp->next) { + for (sp = arglist.list ; sp ; sp = sp->next) { setvar(n->nfor.var, sp->text, 0); evaltree(n->nfor.body, flags); if (evalskip) { @@ -2281,11 +2935,14 @@ static void evalfor(const union node *n, int flags) } } loopnest--; - out: +out: popstackmark(&smark); } -static inline void evalcase(const union node *n, int flags) + + +static void +evalcase(union node *n, int flags) { union node *cp; union node *patp; @@ -2294,10 +2951,10 @@ static inline void evalcase(const union node *n, int flags) setstackmark(&smark); arglist.lastp = &arglist.list; - oexitstatus = exitstatus; expandarg(n->ncase.expr, &arglist, EXP_TILDE); - for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) { - for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) { + exitstatus = 0; + for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) { + for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) { if (casematch(patp, arglist.list->text)) { if (evalskip == 0) { evaltree(cp->nclist.body, flags); @@ -2306,10 +2963,81 @@ static inline void evalcase(const union node *n, int flags) } } } - out: +out: popstackmark(&smark); } + + +/* + * Kick off a subshell to evaluate a tree. + */ + +static void +evalsubshell(union node *n, int flags) +{ + struct job *jp; + int backgnd = (n->type == NBACKGND); + int status; + + expredir(n->nredir.redirect); + if (!backgnd && flags & EV_EXIT && !trap[0]) + goto nofork; + INTOFF; + jp = makejob(n, 1); + if (forkshell(jp, n, backgnd) == 0) { + INTON; + flags |= EV_EXIT; + if (backgnd) + flags &=~ EV_TESTED; +nofork: + redirect(n->nredir.redirect, 0); + evaltreenr(n->nredir.n, flags); + /* never returns */ + } + status = 0; + if (! backgnd) + status = waitforjob(jp); + exitstatus = status; + INTON; +} + + + +/* + * Compute the names of the files in a redirection list. + */ + +static void +expredir(union node *n) +{ + union node *redir; + + for (redir = n ; redir ; redir = redir->nfile.next) { + struct arglist fn; + fn.lastp = &fn.list; + switch (redir->type) { + case NFROMTO: + case NFROM: + case NTO: + case NCLOBBER: + case NAPPEND: + expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR); + redir->nfile.expfname = fn.list->text; + break; + case NFROMFD: + case NTOFD: + if (redir->ndup.vname) { + expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE); + fixredir(redir, fn.list->text, 1); + } + break; + } + } +} + + + /* * Evaluate a pipeline. All the processes in the pipeline are children * of the process creating the pipeline. (This differs from some versions @@ -2317,7 +3045,8 @@ static inline void evalcase(const union node *n, int flags) * of all the rest.) */ -static inline void evalpipe(union node *n, int flags) +static void +evalpipe(union node *n, int flags) { struct job *jp; struct nodelist *lp; @@ -2325,15 +3054,15 @@ static inline void evalpipe(union node *n, int flags) int prevfd; int pip[2]; - TRACE(("evalpipe(0x%lx) called\n", (long) n)); + TRACE(("evalpipe(0x%lx) called\n", (long)n)); pipelen = 0; - for (lp = n->npipe.cmdlist; lp; lp = lp->next) + for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) pipelen++; flags |= EV_EXIT; INTOFF; jp = makejob(n, pipelen); prevfd = -1; - for (lp = n->npipe.cmdlist; lp; lp = lp->next) { + for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) { prehash(lp->n); pip[1] = -1; if (lp->next) { @@ -2355,7 +3084,8 @@ static inline void evalpipe(union node *n, int flags) dup2(pip[1], 1); close(pip[1]); } - evaltree(lp->n, flags); + evaltreenr(lp->n, flags); + /* never returns */ } if (prevfd >= 0) close(prevfd); @@ -2369,21 +3099,101 @@ static inline void evalpipe(union node *n, int flags) INTON; } -static void find_command(const char *, struct cmdentry *, int, const char *); -static int isassignment(const char *word) + +/* + * Execute a command inside back quotes. If it's a builtin command, we + * want to save its output in a block obtained from malloc. Otherwise + * we fork off a subprocess and get the output of the command via a pipe. + * Should be called with interrupts off. + */ + +static void +evalbackcmd(union node *n, struct backcmd *result) { - if (!is_name(*word)) { - return 0; + int saveherefd; + + result->fd = -1; + result->buf = NULL; + result->nleft = 0; + result->jp = NULL; + if (n == NULL) { + goto out; } - do { - word++; - } while (is_in_name(*word)); - return *word == '='; + + saveherefd = herefd; + herefd = -1; + + { + int pip[2]; + struct job *jp; + + if (pipe(pip) < 0) + error("Pipe call failed"); + jp = makejob(n, 1); + if (forkshell(jp, n, FORK_NOJOB) == 0) { + FORCEINTON; + close(pip[0]); + if (pip[1] != 1) { + close(1); + copyfd(pip[1], 1); + close(pip[1]); + } + eflag = 0; + evaltreenr(n, EV_EXIT); + /* NOTREACHED */ + } + close(pip[1]); + result->fd = pip[0]; + result->jp = jp; + } + herefd = saveherefd; +out: + TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n", + result->fd, result->buf, result->nleft, result->jp)); +} + +#ifdef CONFIG_ASH_CMDCMD +static inline char ** +parse_command_args(char **argv, const char **path) +{ + char *cp, c; + + for (;;) { + cp = *++argv; + if (!cp) + return 0; + if (*cp++ != '-') + break; + if (!(c = *cp++)) + break; + if (c == '-' && !*cp) { + argv++; + break; + } + do { + switch (c) { + case 'p': + *path = defpath; + break; + default: + /* run 'typecmd' for other options */ + return 0; + } + } while ((c = *cp++)); + } + return argv; } +#endif -static void evalcommand(union node *cmd, int flags) + +/* + * Execute a simple command. + */ + +static void +evalcommand(union node *cmd, int flags) { struct stackmark smark; union node *argp; @@ -2391,562 +3201,312 @@ static void evalcommand(union node *cmd, int flags) struct arglist varlist; char **argv; int argc; - char **envp; struct strlist *sp; - int mode; struct cmdentry cmdentry; struct job *jp; - char *volatile savecmdname; - volatile struct shparam saveparam; - struct localvar *volatile savelocalvars; - volatile int e; char *lastarg; const char *path; int spclbltin; - struct jmploc *volatile savehandler; - struct jmploc jmploc; - -#if __GNUC__ - /* Avoid longjmp clobbering */ - (void) &argv; - (void) &argc; - (void) &lastarg; - (void) &flags; - (void) &spclbltin; -#endif + int cmd_is_exec; + int status; + char **nargv; /* First expand the arguments. */ - TRACE(("evalcommand(0x%lx, %d) called\n", (long) cmd, flags)); + TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags)); setstackmark(&smark); - arglist.lastp = &arglist.list; - varlist.lastp = &varlist.list; - arglist.list = 0; - oexitstatus = exitstatus; - exitstatus = 0; - path = pathval(); - for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) { - expandarg(argp, &varlist, EXP_VARTILDE); - } - for (argp = cmd->ncmd.args; argp && !arglist.list; argp = argp->narg.next) { - expandarg(argp, &arglist, EXP_FULL | EXP_TILDE); - } - if (argp) { - struct builtincmd *bcmd; - int pseudovarflag; + back_exitstatus = 0; - bcmd = find_builtin(arglist.list->text); - pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd); - for (; argp; argp = argp->narg.next) { - if (pseudovarflag && isassignment(argp->narg.text)) { - expandarg(argp, &arglist, EXP_VARTILDE); - continue; - } - expandarg(argp, &arglist, EXP_FULL | EXP_TILDE); - } - } - *arglist.lastp = NULL; + cmdentry.cmdtype = CMDBUILTIN; + cmdentry.u.cmd = &bltin; + varlist.lastp = &varlist.list; *varlist.lastp = NULL; - expredir(cmd->ncmd.redirect); + arglist.lastp = &arglist.list; + *arglist.lastp = NULL; + argc = 0; - for (sp = arglist.list; sp; sp = sp->next) - argc++; - argv = stalloc(sizeof(char *) * (argc + 1)); + for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) { + struct strlist **spp; - for (sp = arglist.list; sp; sp = sp->next) { + spp = arglist.lastp; + expandarg(argp, &arglist, EXP_FULL | EXP_TILDE); + for (sp = *spp; sp; sp = sp->next) + argc++; + } + + argv = nargv = stalloc(sizeof (char *) * (argc + 1)); + for (sp = arglist.list ; sp ; sp = sp->next) { TRACE(("evalcommand arg: %s\n", sp->text)); - *argv++ = sp->text; + *nargv++ = sp->text; } - *argv = NULL; + *nargv = NULL; + lastarg = NULL; if (iflag && funcnest == 0 && argc > 0) - lastarg = argv[-1]; - argv -= argc; + lastarg = nargv[-1]; + + expredir(cmd->ncmd.redirect); + status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH); + + path = vpath.text; + for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) { + struct strlist **spp; + char *p; + + spp = varlist.lastp; + expandarg(argp, &varlist, EXP_VARTILDE); + + /* + * Modify the command lookup path, if a PATH= assignment + * is present + */ + p = (*spp)->text; + if (varequal(p, path)) + path = p; + } /* Print the command if xflag is set. */ if (xflag) { - out2c('+'); - eprintlist(varlist.list); - eprintlist(arglist.list); + int sep; + + out2str(ps4val()); + sep = 0; + sep = eprintlist(varlist.list, sep); + eprintlist(arglist.list, sep); out2c('\n'); + flushall(); } + cmd_is_exec = 0; + spclbltin = -1; + /* Now locate the command. */ - if (argc == 0) { - cmdentry.cmdtype = CMDBUILTIN; - cmdentry.u.cmd = BLTINCMD; - spclbltin = 1; - } else { + if (argc) { const char *oldpath; - int findflag = DO_ERR; - int oldfindflag; + int cmd_flag = DO_ERR; - /* - * Modify the command lookup path, if a PATH= assignment - * is present - */ - for (sp = varlist.list; sp; sp = sp->next) - if (varequal(sp->text, defpathvar)) { - path = sp->text + 5; - findflag |= DO_BRUTE; - } + path += 5; oldpath = path; - oldfindflag = findflag; - spclbltin = -1; for (;;) { - find_command(argv[0], &cmdentry, findflag, path); - if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */ - exitstatus = 127; - goto out; + find_command(argv[0], &cmdentry, cmd_flag, path); + if (cmdentry.cmdtype == CMDUNKNOWN) { + status = 127; + flushout(stderr); + goto bail; } + /* implement bltin and command here */ - if (cmdentry.cmdtype != CMDBUILTIN) { + if (cmdentry.cmdtype != CMDBUILTIN) + break; + if (spclbltin < 0) + spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd); + if (cmdentry.u.cmd == EXECCMD) + cmd_is_exec++; +#ifdef CONFIG_ASH_CMDCMD + if (cmdentry.u.cmd == COMMANDCMD) { + + path = oldpath; + nargv = parse_command_args(argv, &path); + if (!nargv) + break; + argc -= nargv - argv; + argv = nargv; + cmd_flag |= DO_NOFUNC; + } else +#endif break; - } - if (spclbltin < 0) { - spclbltin = !!(IS_BUILTIN_SPECIAL(cmdentry.u.cmd)) * 2; - } - if (cmdentry.u.cmd == BLTINCMD) { - for (;;) { - struct builtincmd *bcmd; - - argv++; - if (--argc == 0) - goto found; - if (!(bcmd = find_builtin(*argv))) { - out2fmt("%s: not found\n", *argv); - exitstatus = 127; - goto out; - } - cmdentry.u.cmd = bcmd; - if (bcmd != BLTINCMD) - break; - } - } - if (cmdentry.u.cmd == find_builtin("command")) { - argv++; - if (--argc == 0) { - goto found; - } - if (*argv[0] == '-') { - if (!equal(argv[0], "-p")) { - argv--; - argc++; - break; - } - argv++; - if (--argc == 0) { - goto found; - } - path = defpath; - findflag |= DO_BRUTE; - } else { - path = oldpath; - findflag = oldfindflag; - } - findflag |= DO_NOFUN; - continue; - } - found: - break; } } - /* Fork off a child process if necessary. */ - if (cmd->ncmd.backgnd - || (cmdentry.cmdtype == CMDNORMAL && (!(flags & EV_EXIT) || trap[0])) - ) { - INTOFF; - jp = makejob(cmd, 1); - mode = cmd->ncmd.backgnd; - if (forkshell(jp, cmd, mode) != 0) - goto parent; /* at end of routine */ - FORCEINTON; - flags |= EV_EXIT; - } else { - flags &= ~EV_EXIT; + if (status) { + /* We have a redirection error. */ + if (spclbltin > 0) + exraise(EXERROR); +bail: + exitstatus = status; + goto out; } - /* This is the child process if a fork occurred. */ /* Execute the command. */ - if (cmdentry.cmdtype == CMDFUNCTION) { -#ifdef DEBUG - trputs("Shell function: "); - trargs(argv); -#endif - exitstatus = oexitstatus; - saveparam = shellparam; - shellparam.malloc = 0; - shellparam.nparam = argc - 1; - shellparam.p = argv + 1; - INTOFF; - savelocalvars = localvars; - localvars = NULL; - INTON; - if (setjmp(jmploc.loc)) { - if (exception == EXREDIR) { - exitstatus = 2; - goto funcdone; + switch (cmdentry.cmdtype) { + default: + /* Fork off a child process if necessary. */ + if (!(flags & EV_EXIT) || trap[0]) { + INTOFF; + jp = makejob(cmd, 1); + if (forkshell(jp, cmd, FORK_FG) != 0) { + exitstatus = waitforjob(jp); + INTON; + break; } - saveparam.optind = shellparam.optind; - saveparam.optoff = shellparam.optoff; - freeparam(&shellparam); - shellparam = saveparam; - poplocalvars(); - localvars = savelocalvars; - handler = savehandler; - longjmp(handler->loc, 1); - } - savehandler = handler; - handler = &jmploc; - redirect(cmd->ncmd.redirect, REDIR_PUSH); - listsetvar(varlist.list); - funcnest++; - evaltree(cmdentry.u.func, flags & EV_TESTED); - funcnest--; - funcdone: - INTOFF; - poplocalvars(); - localvars = savelocalvars; - saveparam.optind = shellparam.optind; - saveparam.optoff = shellparam.optoff; - freeparam(&shellparam); - shellparam = saveparam; - handler = savehandler; - popredir(); - INTON; - if (evalskip == SKIPFUNC) { - evalskip = 0; - skipcount = 0; + FORCEINTON; } - } else if (cmdentry.cmdtype == CMDBUILTIN) { - int redir; + listsetvar(varlist.list, VEXPORT|VSTACK); + shellexec(argv, path, cmdentry.u.index); + /* NOTREACHED */ -#ifdef DEBUG - trputs("builtin command: "); - trargs(argv); -#endif - redir = (cmdentry.u.cmd == EXECCMD) ? 0 : REDIR_PUSH; - savecmdname = commandname; - if (spclbltin) { - listsetvar(varlist.list); - } else { - cmdenviron = varlist.list; - } - e = -1; - if (setjmp(jmploc.loc)) { - e = exception; - exitstatus = (e == EXINT) ? SIGINT + 128 : 2; - goto cmddone; - } - savehandler = handler; - handler = &jmploc; - redirect(cmd->ncmd.redirect, redir); - commandname = argv[0]; - argptr = argv + 1; - optptr = NULL; /* initialize nextopt */ - exitstatus = (*cmdentry.u.cmd->builtinfunc) (argc, argv); - flushall(); - cmddone: - cmdenviron = NULL; - commandname = savecmdname; - handler = savehandler; - if (e != -1) { - if (e == EXINT || spclbltin & 2) { - if (e == EXREDIR) - exraise(e); + case CMDBUILTIN: + cmdenviron = varlist.list; + if (cmdenviron) { + struct strlist *list = cmdenviron; + int i = VNOSET; + if (spclbltin > 0 || argc == 0) { + i = 0; + if (cmd_is_exec && argc > 1) + i = VEXPORT; + } + listsetvar(list, i); + } + if (evalbltin(cmdentry.u.cmd, argc, argv)) { + int exit_status; + int i, j; + + i = exception; + if (i == EXEXIT) + goto raise; + + exit_status = 2; + j = 0; + if (i == EXINT) + j = SIGINT; + if (i == EXSIG) + j = pendingsigs; + if (j) + exit_status = j + 128; + exitstatus = exit_status; + + if (i == EXINT || spclbltin > 0) { +raise: + longjmp(handler->loc, 1); } FORCEINTON; } - if (cmdentry.u.cmd != EXECCMD) - popredir(); - } else { -#ifdef DEBUG - trputs("normal command: "); - trargs(argv); -#endif - redirect(cmd->ncmd.redirect, 0); - clearredir(); - for (sp = varlist.list; sp; sp = sp->next) - setvareq(sp->text, VEXPORT | VSTACK); - envp = environment(); - shellexec(argv, envp, path, cmdentry.u.index); - } - if (flags & EV_EXIT) - exitshell(exitstatus); - goto out; + break; - parent: /* parent process gets here (if we forked) */ - if (mode == 0) { /* argument to fork */ - exitstatus = waitforjob(jp); + case CMDFUNCTION: + listsetvar(varlist.list, 0); + if (evalfun(cmdentry.u.func, argc, argv, flags)) + goto raise; + break; } - INTON; - out: +out: + popredir(cmd_is_exec); if (lastarg) + /* dsl: I think this is intended to be used to support + * '_' in 'vi' command mode during line editing... + * However I implemented that within libedit itself. + */ setvar("_", lastarg, 0); popstackmark(&smark); } -/* - * Evaluate a parse tree. The value is left in the global variable - * exitstatus. - */ -static void evaltree(union node *n, int flags) -{ - int checkexit = 0; - - if (n == NULL) { - TRACE(("evaltree(NULL) called\n")); - goto out; - } - TRACE(("evaltree(0x%lx: %d) called\n", (long) n, n->type)); - switch (n->type) { - case NSEMI: - evaltree(n->nbinary.ch1, flags & EV_TESTED); - if (evalskip) - goto out; - evaltree(n->nbinary.ch2, flags); - break; - case NAND: - evaltree(n->nbinary.ch1, EV_TESTED); - if (evalskip || exitstatus != 0) - goto out; - evaltree(n->nbinary.ch2, flags); - break; - case NOR: - evaltree(n->nbinary.ch1, EV_TESTED); - if (evalskip || exitstatus == 0) - goto out; - evaltree(n->nbinary.ch2, flags); - break; - case NREDIR: - expredir(n->nredir.redirect); - redirect(n->nredir.redirect, REDIR_PUSH); - evaltree(n->nredir.n, flags); - popredir(); - break; - case NSUBSHELL: - evalsubshell(n, flags); - break; - case NBACKGND: - evalsubshell(n, flags); - break; - case NIF:{ - evaltree(n->nif.test, EV_TESTED); - if (evalskip) - goto out; - if (exitstatus == 0) - evaltree(n->nif.ifpart, flags); - else if (n->nif.elsepart) - evaltree(n->nif.elsepart, flags); - else - exitstatus = 0; - break; - } - case NWHILE: - case NUNTIL: - evalloop(n, flags); - break; - case NFOR: - evalfor(n, flags); - break; - case NCASE: - evalcase(n, flags); - break; - case NDEFUN:{ - struct builtincmd *bcmd; - struct cmdentry entry; +static int +evalbltin(const struct builtincmd *cmd, int argc, char **argv) { + char *volatile savecmdname; + struct jmploc *volatile savehandler; + struct jmploc jmploc; + int i; - if ((bcmd = find_builtin(n->narg.text)) && IS_BUILTIN_SPECIAL(bcmd) - ) { - out2fmt("%s is a special built-in\n", n->narg.text); - exitstatus = 1; - break; - } - entry.cmdtype = CMDFUNCTION; - entry.u.func = copyfunc(n->narg.next); - addcmdentry(n->narg.text, &entry); - exitstatus = 0; - break; - } - case NNOT: - evaltree(n->nnot.com, EV_TESTED); - exitstatus = !exitstatus; - break; + savecmdname = commandname; + if ((i = setjmp(jmploc.loc))) + goto cmddone; + savehandler = handler; + handler = &jmploc; + commandname = argv[0]; + argptr = argv + 1; + optptr = NULL; /* initialize nextopt */ + exitstatus = (*cmd->builtin)(argc, argv); + flushall(); +cmddone: + exitstatus |= outerr(stdout); + commandname = savecmdname; + exsig = 0; + handler = savehandler; - case NPIPE: - evalpipe(n, flags); - checkexit = 1; - break; - case NCMD: - evalcommand(n, flags); - checkexit = 1; - break; -#ifdef DEBUG - default: - printf("Node type = %d\n", n->type); - break; -#endif - } - out: - if (pendingsigs) - dotrap(); - if (flags & EV_EXIT || - (checkexit && eflag && exitstatus && !(flags & EV_TESTED)) - ) - exitshell(exitstatus); + return i; } -/* - * Kick off a subshell to evaluate a tree. - */ - -static void evalsubshell(const union node *n, int flags) +static int +evalfun(struct funcnode *func, int argc, char **argv, int flags) { - struct job *jp = 0; - int backgnd = (n->type == NBACKGND); + volatile struct shparam saveparam; + struct localvar *volatile savelocalvars; + struct jmploc *volatile savehandler; + struct jmploc jmploc; + int e; - expredir(n->nredir.redirect); - if (!backgnd && flags & EV_EXIT && !trap[0]) - goto nofork; - INTOFF; - jp = makejob(n, 1); - if (forkshell(jp, n, backgnd) == 0) { - INTON; - flags |= EV_EXIT; - if (backgnd) - flags &= ~EV_TESTED; - nofork: - redirect(n->nredir.redirect, 0); - evaltree(n->nredir.n, flags); /* never returns */ - } - if (!backgnd) { - exitstatus = waitforjob(jp); + saveparam = shellparam; + savelocalvars = localvars; + if ((e = setjmp(jmploc.loc))) { + goto funcdone; } + INTOFF; + savehandler = handler; + handler = &jmploc; + localvars = NULL; + shellparam.malloc = 0; + func->count++; INTON; -} - -/* - * Compute the names of the files in a redirection list. - */ - -static void fixredir(union node *n, const char *text, int err); - -static void expredir(union node *n) -{ - union node *redir; - - for (redir = n; redir; redir = redir->nfile.next) { - struct arglist fn; - - fn.lastp = &fn.list; - oexitstatus = exitstatus; - switch (redir->type) { - case NFROMTO: - case NFROM: - case NTO: - case NAPPEND: - case NTOOV: - expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR); - redir->nfile.expfname = fn.list->text; - break; - case NFROMFD: - case NTOFD: - if (redir->ndup.vname) { - expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE); - fixredir(redir, fn.list->text, 1); - } - break; - } - } -} - - -/* - * Execute a command inside back quotes. If it's a builtin command, we - * want to save its output in a block obtained from malloc. Otherwise - * we fork off a subprocess and get the output of the command via a pipe. - * Should be called with interrupts off. - */ - -static void evalbackcmd(union node *n, struct backcmd *result) -{ - int pip[2]; - struct job *jp; - struct stackmark smark; /* unnecessary */ - - setstackmark(&smark); - result->fd = -1; - result->buf = NULL; - result->nleft = 0; - result->jp = NULL; - if (n == NULL) { - exitstatus = 0; - goto out; - } - exitstatus = 0; - if (pipe(pip) < 0) - error("Pipe call failed"); - jp = makejob(n, 1); - if (forkshell(jp, n, FORK_NOJOB) == 0) { - FORCEINTON; - close(pip[0]); - if (pip[1] != 1) { - close(1); - dup_as_newfd(pip[1], 1); - close(pip[1]); - } - eflag = 0; - evaltree(n, EV_EXIT); + shellparam.nparam = argc - 1; + shellparam.p = argv + 1; +#ifdef CONFIG_ASH_GETOPTS + shellparam.optind = 1; + shellparam.optoff = -1; +#endif + funcnest++; + evaltree(&func->n, flags & EV_TESTED); + funcnest--; +funcdone: + INTOFF; + freefunc(func); + poplocalvars(); + localvars = savelocalvars; + freeparam(&shellparam); + shellparam = saveparam; + handler = savehandler; + INTON; + if (evalskip == SKIPFUNC) { + evalskip = 0; + skipcount = 0; } - close(pip[1]); - result->fd = pip[0]; - result->jp = jp; - out: - popstackmark(&smark); - TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n", - result->fd, result->buf, result->nleft, result->jp)); + return e; } /* - * Execute a simple command. - */ - -/* * Search for a command. This is called before we fork so that the * location of the command will be available in the parent as well as - * the child. The check for "goodname" is an overly conservative - * check that the name will not be subject to expansion. + * the child. */ -static void prehash(union node *n) +static void +prehash(union node *n) { struct cmdentry entry; if (n->type == NCMD && n->ncmd.args) - if (goodname(n->ncmd.args->narg.text)) - find_command(n->ncmd.args->narg.text, &entry, 0, pathval()); + find_command(n->ncmd.args->narg.text, &entry, 0, pathval()); } + /* * Builtin commands. Builtin commands whose functions are closely * tied to evaluation are implemented here. */ /* - * No command given, or a bltin command with no arguments. Set the - * specified variables. + * No command given. */ -int bltincmd(int argc, char **argv) +static int +bltincmd(int argc, char **argv) { /* * Preserve exitstatus of a previous possible redirection * as POSIX mandates */ - return exitstatus; + return back_exitstatus; } @@ -2961,16 +3521,17 @@ int bltincmd(int argc, char **argv) * in the standard shell so we don't make it one here. */ -static int breakcmd(int argc, char **argv) +static int +breakcmd(int argc, char **argv) { int n = argc > 1 ? number(argv[1]) : 1; if (n <= 0) - error("Illegal number: %s", argv[1]); + error(illnum, argv[1]); if (n > loopnest) n = loopnest; if (n > 0) { - evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK; + evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK; skipcount = n; } return 0; @@ -2981,15 +3542,17 @@ static int breakcmd(int argc, char **argv) * The return command. */ -static int returncmd(int argc, char **argv) +static int +returncmd(int argc, char **argv) { - int ret = argc > 1 ? number(argv[1]) : oexitstatus; + int ret = argc > 1 ? number(argv[1]) : exitstatus; if (funcnest) { evalskip = SKIPFUNC; skipcount = 1; return ret; - } else { + } + else { /* Do what ksh does; skip the rest of the file */ evalskip = SKIPFILE; skipcount = 1; @@ -2998,101 +3561,102 @@ static int returncmd(int argc, char **argv) } -#ifndef CONFIG_FALSE -static int false_main(int argc, char **argv) +static int +falsecmd(int argc, char **argv) { return 1; } -#endif -#ifndef CONFIG_TRUE -static int true_main(int argc, char **argv) -{ - return 0; -} -#endif - -/* - * Controls whether the shell is interactive or not. - */ - -static void setsignal(int signo); - -#ifdef CONFIG_ASH_MAIL -static void chkmail(int silent); -#endif - -static void setinteractive(int on) -{ - static int is_interactive; - static int do_banner = 0; - - if (on == is_interactive) - return; - setsignal(SIGINT); - setsignal(SIGQUIT); - setsignal(SIGTERM); -#ifdef CONFIG_ASH_MAIL - chkmail(1); -#endif - is_interactive = on; - if (do_banner == 0 && is_interactive) { - /* Looks like they want an interactive shell */ -#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET - printf("\n\n" BB_BANNER " Built-in shell (ash)\n"); - printf("Enter 'help' for a list of built-in commands.\n\n"); -#endif - do_banner = 1; - } -} -static void optschanged(void) +static int +truecmd(int argc, char **argv) { - setinteractive(iflag); - setjobctl(mflag); + return 0; } -static int execcmd(int argc, char **argv) +static int +execcmd(int argc, char **argv) { if (argc > 1) { - struct strlist *sp; - - iflag = 0; /* exit on error */ + iflag = 0; /* exit on error */ mflag = 0; optschanged(); - for (sp = cmdenviron; sp; sp = sp->next) - setvareq(sp->text, VEXPORT | VSTACK); - shellexec(argv + 1, environment(), pathval(), 0); + shellexec(argv + 1, pathval(), 0); } return 0; } -static void eprintlist(struct strlist *sp) + +static int +eprintlist(struct strlist *sp, int sep) { - for (; sp; sp = sp->next) { - out2fmt(" %s", sp->text); + while (sp) { + const char *p; + + p = " %s" + (1 - sep); + sep |= 1; + fprintf(stderr, p, sp->text); + sp = sp->next; } + + return sep; } +/* $NetBSD: exec.c,v 1.35 2003/01/22 20:36:04 dsl Exp $ */ + +/* + * When commands are first encountered, they are entered in a hash table. + * This ensures that a full path search will not have to be done for them + * on each invocation. + * + * We should investigate converting to a linear search, even though that + * would make the command name "hash" a misnomer. + */ + +#define CMDTABLESIZE 31 /* should be prime */ +#define ARB 1 /* actual size determined at run time */ + + + +struct tblentry { + struct tblentry *next; /* next entry in hash chain */ + union param param; /* definition of builtin function */ + short cmdtype; /* index identifying command */ + char rehash; /* if set, cd done since entry created */ + char cmdname[ARB]; /* name of command */ +}; + + +static struct tblentry *cmdtable[CMDTABLESIZE]; +static int builtinloc = -1; /* index in path of %builtin, or -1 */ + + +static void tryexec(char *, char **, char **); +static void printentry(struct tblentry *); +static void clearcmdentry(int); +static struct tblentry *cmdlookup(const char *, int); +static void delete_cmd_entry(void); + /* * Exec a program. Never returns. If you change this routine, you may * have to change the find_command routine as well. */ -static const char *pathopt; /* set by padvance */ - -static void shellexec(char **argv, char **envp, const char *path, int idx) +static void +shellexec(char **argv, const char *path, int idx) { char *cmdname; int e; + char **envp; + clearredir(1); + envp = environment(); if (strchr(argv[0], '/') != NULL #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL || find_applet_by_name(argv[0]) -#endif - ) - { +#endif + ) { tryexec(argv[0], argv, envp); e = errno; } else { @@ -3119,167 +3683,17 @@ static void shellexec(char **argv, char **envp, const char *path, int idx) exerrno = 2; break; } + TRACE(("shellexec failed for %s, errno %d, suppressint %d\n", + argv[0], e, suppressint )); exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC)); /* NOTREACHED */ } -/* - * Clear traps on a fork. - */ -static void clear_traps(void) -{ - char **tp; - - for (tp = trap; tp < &trap[NSIG]; tp++) { - if (*tp && **tp) { /* trap not NULL or SIG_IGN */ - INTOFF; - free(*tp); - *tp = NULL; - if (tp != &trap[0]) - setsignal(tp - trap); - INTON; - } - } -} - - -static int preadbuffer(void); -static void pushfile(void); - -/* - * Read a character from the script, returning PEOF on end of file. - * Nul characters in the input are silently discarded. - */ - -#ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE -#define pgetc_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer()) -static int pgetc(void) -{ - return pgetc_macro(); -} -#else -static int pgetc_macro(void) -{ - return --parsenleft >= 0 ? *parsenextc++ : preadbuffer(); -} - -static inline int pgetc(void) -{ - return pgetc_macro(); -} -#endif - -/* - * Undo the last call to pgetc. Only one character may be pushed back. - * PEOF may be pushed back. - */ - -static void pungetc(void) -{ - parsenleft++; - parsenextc--; -} - - -static void popfile(void) -{ - struct parsefile *pf = parsefile; - - INTOFF; - if (pf->fd >= 0) - close(pf->fd); - free(pf->buf); - while (pf->strpush) - popstring(); - parsefile = pf->prev; - free(pf); - parsenleft = parsefile->nleft; - parselleft = parsefile->lleft; - parsenextc = parsefile->nextc; - plinno = parsefile->linno; - INTON; -} - - -/* - * Return to top level. - */ - -static void popallfiles(void) -{ - while (parsefile != &basepf) - popfile(); -} - -/* - * Close the file(s) that the shell is reading commands from. Called - * after a fork is done. - */ - -static void closescript(void) -{ - popallfiles(); - if (parsefile->fd > 0) { - close(parsefile->fd); - parsefile->fd = 0; - } -} - - -/* - * Like setinputfile, but takes an open file descriptor. Call this with - * interrupts off. - */ - -static void setinputfd(int fd, int push) -{ - (void) fcntl(fd, F_SETFD, FD_CLOEXEC); - if (push) { - pushfile(); - parsefile->buf = 0; - } else { - closescript(); - while (parsefile->strpush) - popstring(); - } - parsefile->fd = fd; - if (parsefile->buf == NULL) - parsefile->buf = xmalloc(BUFSIZ); - parselleft = parsenleft = 0; - plinno = 1; -} - - -/* - * Set the input to take input from a file. If push is set, push the - * old input onto the stack first. - */ - -static void setinputfile(const char *fname, int push) -{ - int fd; - int myfileno2; - - INTOFF; - if ((fd = open(fname, O_RDONLY)) < 0) - error("Can't open %s", fname); - if (fd < 10) { - myfileno2 = dup_as_newfd(fd, 10); - close(fd); - if (myfileno2 < 0) - error("Out of file descriptors"); - fd = myfileno2; - } - setinputfd(fd, push); - INTON; -} - - -static void tryexec(char *cmd, char **argv, char **envp) +static void +tryexec(char *cmd, char **argv, char **envp) { int repeated = 0; - #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL int flg_bb = 0; char *name = cmd; @@ -3310,24 +3724,33 @@ static void tryexec(char *cmd, char **argv, char **envp) } } #endif - repeat: + +repeat: +#ifdef SYSV + do { + execve(cmd, argv, envp); + } while (errno == EINTR); +#else execve(cmd, argv, envp); +#endif if (repeated++) { - free(argv); + ckfree(argv); } else if (errno == ENOEXEC) { char **ap; char **new; - for (ap = argv; *ap; ap++); - ap = new = xmalloc((ap - argv + 2) * sizeof(char *)); + for (ap = argv; *ap; ap++) + ; + ap = new = ckmalloc((ap - argv + 2) * sizeof(char *)); *ap++ = cmd = "/bin/sh"; - while ((*ap++ = *argv++)); + while ((*ap++ = *argv++)) + ; argv = new; goto repeat; } } -static char *commandtext(const union node *); + /* * Do a path search. The variable path (passed by reference) should be @@ -3339,23 +3762,19 @@ static char *commandtext(const union node *); * NULL. */ -static const char *pathopt; - -static void growstackblock(void); - - -static char *padvance(const char **path, const char *name) +static char * +padvance(const char **path, const char *name) { const char *p; char *q; const char *start; - int len; + size_t len; if (*path == NULL) return NULL; start = *path; - for (p = start; *p && *p != ':' && *p != '%'; p++); - len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */ + for (p = start ; *p && *p != ':' && *p != '%' ; p++); + len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */ while (stackblocksize() < len) growstackblock(); q = stackblock(); @@ -3368,8 +3787,7 @@ static char *padvance(const char **path, const char *name) pathopt = NULL; if (*p == '%') { pathopt = ++p; - while (*p && *p != ':') - p++; + while (*p && *p != ':') p++; } if (*p == ':') *path = p + 1; @@ -3378,181 +3796,74 @@ static char *padvance(const char **path, const char *name) return stalloc(len); } -/* - * Wrapper around strcmp for qsort/bsearch/... - */ -static int pstrcmp(const void *a, const void *b) -{ - return strcmp((const char *) a, (*(const char *const *) b) + 1); -} - -/* - * Find a keyword is in a sorted array. - */ - -static const char *const *findkwd(const char *s) -{ - return bsearch(s, tokname_array + KWDOFFSET, - (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET, - sizeof(const char *), pstrcmp); -} /*** Command hashing code ***/ -static int hashcmd(int argc, char **argv) + +static int +hashcmd(int argc, char **argv) { struct tblentry **pp; struct tblentry *cmdp; int c; - int verbose; struct cmdentry entry; char *name; -#ifdef CONFIG_ASH_ALIAS - const struct alias *ap; -#endif - - verbose = 0; - while ((c = nextopt("rvV")) != '\0') { - if (c == 'r') { - clearcmdentry(0); - return 0; - } else if (c == 'v' || c == 'V') { - verbose = c; - } + while ((c = nextopt("r")) != '\0') { + clearcmdentry(0); + return 0; } if (*argptr == NULL) { - for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) { - for (cmdp = *pp; cmdp; cmdp = cmdp->next) { - if (cmdp->cmdtype != CMDBUILTIN) { - printentry(cmdp, verbose); - } + for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) { + for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { + if (cmdp->cmdtype == CMDNORMAL) + printentry(cmdp); } } return 0; } c = 0; - while ((name = *argptr++) != NULL) { + while ((name = *argptr) != NULL) { if ((cmdp = cmdlookup(name, 0)) != NULL - && (cmdp->cmdtype == CMDNORMAL - || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))) + && (cmdp->cmdtype == CMDNORMAL + || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))) delete_cmd_entry(); -#ifdef CONFIG_ASH_ALIAS - /* Then look at the aliases */ - if ((ap = *__lookupalias(name)) != NULL) { - if (verbose == 'v') - printf("%s is an alias for %s\n", name, ap->val); - else - printalias(ap); - continue; - } -#endif - /* First look at the keywords */ - if (findkwd(name) != 0) { - if (verbose == 'v') - printf("%s is a shell keyword\n", name); - else - puts(name); - continue; - } - find_command(name, &entry, DO_ERR, pathval()); if (entry.cmdtype == CMDUNKNOWN) c = 1; - else if (verbose) { - cmdp = cmdlookup(name, 0); - if (cmdp) - printentry(cmdp, verbose == 'v'); - flushall(); - } + argptr++; } return c; } -static void printentry(struct tblentry *cmdp, int verbose) + +static void +printentry(struct tblentry *cmdp) { int idx; const char *path; char *name; - printf("%s%s", cmdp->cmdname, (verbose ? " is " : "")); - if (cmdp->cmdtype == CMDNORMAL) { - idx = cmdp->param.index; - path = pathval(); - do { - name = padvance(&path, cmdp->cmdname); - stunalloc(name); - } while (--idx >= 0); - if (verbose) - out1str(name); - } else if (cmdp->cmdtype == CMDBUILTIN) { - if (verbose) - out1str("a shell builtin"); - } else if (cmdp->cmdtype == CMDFUNCTION) { - if (verbose) { - INTOFF; - out1str("a function\n"); - name = commandtext(cmdp->param.func); - printf("%s() {\n %s\n}", cmdp->cmdname, name); - free(name); - INTON; - } -#ifdef DEBUG - } else { - error("internal error: cmdtype %d", cmdp->cmdtype); -#endif - } - puts(cmdp->rehash ? "*" : nullstr); + idx = cmdp->param.index; + path = pathval(); + do { + name = padvance(&path, cmdp->cmdname); + stunalloc(name); + } while (--idx >= 0); + out1str(name); + out1fmt(snlfmt, cmdp->rehash ? "*" : nullstr); } -/*** List the available builtins ***/ - - -static int helpcmd(int argc, char **argv) -{ - int col, i; - - printf("\nBuilt-in commands:\n-------------------\n"); - for (col = 0, i = 0; i < NUMBUILTINS; i++) { - col += printf("%c%s", ((col == 0) ? '\t' : ' '), - builtincmds[i].name + 1); - if (col > 60) { - printf("\n"); - col = 0; - } - } -#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL - { - extern const struct BB_applet applets[]; - extern const size_t NUM_APPLETS; - - for (i = 0; i < NUM_APPLETS; i++) { - - col += printf("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name); - if (col > 60) { - printf("\n"); - col = 0; - } - } - } -#endif - printf("\n\n"); - return EXIT_SUCCESS; -} - /* * Resolve a command name. If you change this routine, you may have to * change the shellexec routine as well. */ -static int prefix(const char *, const char *); - static void -find_command(const char *name, struct cmdentry *entry, int act, - const char *path) +find_command(char *name, struct cmdentry *entry, int act, const char *path) { struct tblentry *cmdp; int idx; @@ -3560,28 +3871,23 @@ find_command(const char *name, struct cmdentry *entry, int act, char *fullname; struct stat statb; int e; - int bltin; - int firstchange; int updatetbl; - int regular; struct builtincmd *bcmd; - /* If name contains a slash, don't use the hash table */ + /* If name contains a slash, don't use PATH or hash table */ if (strchr(name, '/') != NULL) { + entry->u.index = -1; if (act & DO_ABS) { while (stat(name, &statb) < 0) { - if (errno != ENOENT && errno != ENOTDIR) - e = errno; +#ifdef SYSV + if (errno == EINTR) + continue; +#endif entry->cmdtype = CMDUNKNOWN; - entry->u.index = -1; return; } - entry->cmdtype = CMDNORMAL; - entry->u.index = -1; - return; } entry->cmdtype = CMDNORMAL; - entry->u.index = 0; return; } @@ -3593,69 +3899,50 @@ find_command(const char *name, struct cmdentry *entry, int act, } #endif - updatetbl = 1; - if (act & DO_BRUTE) { - firstchange = path_change(path, &bltin); - } else { - bltin = builtinloc; - firstchange = 9999; + updatetbl = (path == pathval()); + if (!updatetbl) { + act |= DO_ALTPATH; + if (strstr(path, "%builtin") != NULL) + act |= DO_ALTBLTIN; } - /* If name is in the table, and not invalidated by cd, we're done */ - 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; - } - } - - bcmd = find_builtin(name); - regular = bcmd && IS_BUILTIN_REGULAR(bcmd); + /* If name is in the table, check answer will be ok */ + if ((cmdp = cmdlookup(name, 0)) != NULL) { + int bit; - if (regular) { - if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) { - goto success; + switch (cmdp->cmdtype) { + default: +#if DEBUG + abort(); +#endif + case CMDNORMAL: + bit = DO_ALTPATH; + break; + case CMDFUNCTION: + bit = DO_NOFUNC; + break; + case CMDBUILTIN: + bit = DO_ALTBLTIN; + break; } - } else if (act & DO_BRUTE) { - if (firstchange == 0) { + if (act & bit) { updatetbl = 0; - } + cmdp = NULL; + } else if (cmdp->rehash == 0) + /* if not invalidated by cd, we're done */ + goto success; } /* If %builtin not in path, check for builtin next */ - if (regular || (bltin < 0 && bcmd)) { - builtin: - if (!updatetbl) { - entry->cmdtype = CMDBUILTIN; - entry->u.cmd = bcmd; - return; - } - INTOFF; - cmdp = cmdlookup(name, 1); - cmdp->cmdtype = CMDBUILTIN; - cmdp->param.cmd = bcmd; - INTON; - goto success; - } + bcmd = find_builtin(name); + if (bcmd && (IS_BUILTIN_REGULAR(bcmd) || ( + act & DO_ALTPATH ? !(act & DO_ALTBLTIN) : builtinloc <= 0 + ))) + goto builtin_success; /* We have to search path. */ - prev = -1; /* where to start */ - if (cmdp && cmdp->rehash) { /* doing a rehash */ + prev = -1; /* where to start */ + if (cmdp && cmdp->rehash) { /* doing a rehash */ if (cmdp->cmdtype == CMDBUILTIN) prev = builtinloc; else @@ -3664,52 +3951,52 @@ find_command(const char *name, struct cmdentry *entry, int act, e = ENOENT; idx = -1; - loop: +loop: while ((fullname = padvance(&path, name)) != NULL) { stunalloc(fullname); idx++; - if (idx >= firstchange) { - updatetbl = 0; - } if (pathopt) { - if (prefix("builtin", pathopt)) { - if ((bcmd = find_builtin(name))) { - goto builtin; - } + if (prefix(pathopt, "builtin")) { + if (bcmd) + goto builtin_success; continue; - } else if (!(act & DO_NOFUN) && prefix("func", pathopt)) { + } else if (!(act & DO_NOFUNC) && + prefix(pathopt, "func")) { /* handled below */ } else { - continue; /* ignore unimplemented options */ + /* ignore unimplemented options */ + continue; } } /* if rehash, don't redo absolute path names */ - if (fullname[0] == '/' && idx <= prev && idx < firstchange) { + if (fullname[0] == '/' && idx <= prev) { if (idx < prev) continue; TRACE(("searchexec \"%s\": no change\n", name)); goto success; } while (stat(fullname, &statb) < 0) { +#ifdef SYSV + if (errno == EINTR) + continue; +#endif if (errno != ENOENT && errno != ENOTDIR) e = errno; goto loop; } - e = EACCES; /* if we fail, this will be the error */ + e = EACCES; /* if we fail, this will be the error */ if (!S_ISREG(statb.st_mode)) continue; - if (pathopt) { /* this is a %func directory */ + if (pathopt) { /* this is a %func directory */ stalloc(strlen(fullname) + 1); readcmdfile(fullname); - if ((cmdp = cmdlookup(name, 0)) == NULL - || cmdp->cmdtype != CMDFUNCTION) + if ((cmdp = cmdlookup(name, 0)) == NULL || + cmdp->cmdtype != CMDFUNCTION) error("%s not defined in %s", name, fullname); stunalloc(fullname); goto success; } 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; @@ -3727,46 +4014,72 @@ find_command(const char *name, struct cmdentry *entry, int act, if (cmdp && updatetbl) delete_cmd_entry(); if (act & DO_ERR) - out2fmt("%s: %s\n", name, errmsg(e, E_EXEC)); + sh_warnx("%s: %s", name, errmsg(e, E_EXEC)); entry->cmdtype = CMDUNKNOWN; return; - success: +builtin_success: + if (!updatetbl) { + entry->cmdtype = CMDBUILTIN; + entry->u.cmd = bcmd; + return; + } + INTOFF; + cmdp = cmdlookup(name, 1); + cmdp->cmdtype = CMDBUILTIN; + cmdp->param.cmd = bcmd; + INTON; +success: cmdp->rehash = 0; entry->cmdtype = cmdp->cmdtype; entry->u = cmdp->param; } +/* + * Wrapper around strcmp for qsort/bsearch/... + */ +static int pstrcmp(const void *a, const void *b) +{ + return strcmp((const char *) a, (*(const char *const *) b) + 1); +} /* * Search the table of builtin commands. */ -static struct builtincmd *find_builtin(const char *name) +static struct builtincmd * +find_builtin(const char *name) { struct builtincmd *bp; - bp = bsearch(name, builtincmds, NUMBUILTINS, sizeof(struct builtincmd), - pstrcmp); + bp = bsearch( + name, builtincmd, NUMBUILTINS, sizeof(struct builtincmd), + pstrcmp + ); return bp; } + /* * Called when a cd is done. Marks all commands so the next time they * are executed they will be rehashed. */ -static void hashcd(void) +static void +hashcd(void) { struct tblentry **pp; struct tblentry *cmdp; - for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) { - for (cmdp = *pp; cmdp; cmdp = cmdp->next) { - if (cmdp->cmdtype == CMDNORMAL - || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)) + for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) { + for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { + if (cmdp->cmdtype == CMDNORMAL || ( + cmdp->cmdtype == CMDBUILTIN && + !(IS_BUILTIN_REGULAR(cmdp->param.cmd)) && + builtinloc > 0 + )) cmdp->rehash = 1; } } @@ -3775,23 +4088,48 @@ static void hashcd(void) /* + * Fix command hash table when PATH changed. * Called before PATH is changed. The argument is the new value of PATH; - * pathval() still returns the old value at this point. Called with - * interrupts off. + * pathval() still returns the old value at this point. + * Called with interrupts off. */ -static void changepath(const char *newval) +static void +changepath(const char *newval) { + const char *old, *new; + int idx; int firstchange; - int bltin; + int idx_bltin; - firstchange = path_change(newval, &bltin); - if (builtinloc < 0 && bltin >= 0) - builtinloc = bltin; /* zap builtins */ + old = pathval(); + new = newval; + firstchange = 9999; /* assume no change */ + idx = 0; + idx_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 == '%' && idx_bltin < 0 && prefix(new + 1, "builtin")) + idx_bltin = idx; + if (*new == ':') { + idx++; + } + new++, old++; + } + if (builtinloc < 0 && idx_bltin >= 0) + builtinloc = idx_bltin; /* zap builtins */ + if (builtinloc >= 0 && idx_bltin < 0) + firstchange = 0; clearcmdentry(firstchange); - builtinloc = bltin; - /* Ensure that getenv("PATH") stays current */ - setenv("PATH", newval, 1); + builtinloc = idx_bltin; } @@ -3800,21 +4138,23 @@ static void changepath(const char *newval) * PATH which has changed. */ -static void clearcmdentry(int firstchange) +static void +clearcmdentry(int firstchange) { struct tblentry **tblp; struct tblentry **pp; struct tblentry *cmdp; INTOFF; - for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) { + for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) { pp = tblp; while ((cmdp = *pp) != NULL) { if ((cmdp->cmdtype == CMDNORMAL && - cmdp->param.index >= firstchange) - || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= firstchange)) { + cmdp->param.index >= firstchange) + || (cmdp->cmdtype == CMDBUILTIN && + builtinloc >= firstchange)) { *pp = cmdp->next; - free(cmdp); + ckfree(cmdp); } else { pp = &cmdp->next; } @@ -3824,43 +4164,45 @@ static void clearcmdentry(int firstchange) } + /* * Locate a command in the command hash table. If "add" is nonzero, * add the command to the table if it is not already present. The * variable "lastcmdentry" is set to point to the address of the link * pointing to the entry, so that delete_cmd_entry can delete the * entry. + * + * Interrupts must be off if called with add != 0. */ static struct tblentry **lastcmdentry; -static struct tblentry *cmdlookup(const char *name, int add) + +static struct tblentry * +cmdlookup(const char *name, int add) { - int hashval; + unsigned int hashval; const char *p; struct tblentry *cmdp; struct tblentry **pp; p = name; - hashval = *p << 4; + hashval = (unsigned char)*p << 4; while (*p) - hashval += *p++; + hashval += (unsigned char)*p++; hashval &= 0x7FFF; pp = &cmdtable[hashval % CMDTABLESIZE]; - for (cmdp = *pp; cmdp; cmdp = cmdp->next) { + for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { if (equal(cmdp->cmdname, name)) break; pp = &cmdp->next; } if (add && cmdp == NULL) { - INTOFF; - cmdp = *pp = xmalloc(sizeof(struct tblentry) - ARB - + strlen(name) + 1); + cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB + + strlen(name) + 1); cmdp->next = NULL; cmdp->cmdtype = CMDUNKNOWN; - cmdp->rehash = 0; strcpy(cmdp->cmdname, name); - INTON; } lastcmdentry = pp; return cmdp; @@ -3870,90 +4212,218 @@ static struct tblentry *cmdlookup(const char *name, int add) * Delete the command entry returned on the last lookup. */ -static void delete_cmd_entry(void) +static void +delete_cmd_entry(void) { struct tblentry *cmdp; INTOFF; cmdp = *lastcmdentry; *lastcmdentry = cmdp->next; - free(cmdp); + if (cmdp->cmdtype == CMDFUNCTION) + freefunc(cmdp->param.func); + ckfree(cmdp); INTON; } +/* + * Add a new command entry, replacing any existing command entry for + * the same name - except special builtins. + */ +static inline void +addcmdentry(char *name, struct cmdentry *entry) +{ + struct tblentry *cmdp; + cmdp = cmdlookup(name, 1); + if (cmdp->cmdtype == CMDFUNCTION) { + freefunc(cmdp->param.func); + } + cmdp->cmdtype = entry->cmdtype; + cmdp->param = entry->u; + cmdp->rehash = 0; +} -static const unsigned char nodesize[26] = { - ALIGN(sizeof(struct nbinary)), - ALIGN(sizeof(struct ncmd)), - ALIGN(sizeof(struct npipe)), - ALIGN(sizeof(struct nredir)), - ALIGN(sizeof(struct nredir)), - ALIGN(sizeof(struct nredir)), - ALIGN(sizeof(struct nbinary)), - ALIGN(sizeof(struct nbinary)), - ALIGN(sizeof(struct nif)), - ALIGN(sizeof(struct nbinary)), - ALIGN(sizeof(struct nbinary)), - ALIGN(sizeof(struct nfor)), - ALIGN(sizeof(struct ncase)), - ALIGN(sizeof(struct nclist)), - ALIGN(sizeof(struct narg)), - ALIGN(sizeof(struct narg)), - ALIGN(sizeof(struct nfile)), - ALIGN(sizeof(struct nfile)), - ALIGN(sizeof(struct nfile)), - ALIGN(sizeof(struct nfile)), - ALIGN(sizeof(struct nfile)), - ALIGN(sizeof(struct ndup)), - ALIGN(sizeof(struct ndup)), - ALIGN(sizeof(struct nhere)), - ALIGN(sizeof(struct nhere)), - ALIGN(sizeof(struct nnot)), -}; +/* + * Make a copy of a parse tree. + */ + +static inline struct funcnode * +copyfunc(union node *n) +{ + struct funcnode *f; + size_t blocksize; + + funcblocksize = offsetof(struct funcnode, n); + funcstringsize = 0; + calcsize(n); + blocksize = funcblocksize; + f = ckmalloc(blocksize + funcstringsize); + funcblock = (char *) f + offsetof(struct funcnode, n); + funcstring = (char *) f + blocksize; + copynode(n); + f->count = 0; + return f; +} + +/* + * Define a shell function. + */ + +static void +defun(char *name, union node *func) +{ + struct cmdentry entry; + INTOFF; + entry.cmdtype = CMDFUNCTION; + entry.u.func = copyfunc(func); + addcmdentry(name, &entry); + INTON; +} /* * Delete a function if it exists. */ -static void unsetfunc(char *name) +static void +unsetfunc(const char *name) { struct tblentry *cmdp; - if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) { - free(cmdp->param.func); + if ((cmdp = cmdlookup(name, 0)) != NULL && + cmdp->cmdtype == CMDFUNCTION) delete_cmd_entry(); - } } - /* * Locate and print what a word is... */ -static int typecmd(int argc, char **argv) + +#ifdef CONFIG_ASH_CMDCMD +static int +describe_command(char *command, int describe_command_verbose) +#else +#define describe_command_verbose 1 +static int +describe_command(char *command) +#endif +{ + struct cmdentry entry; + struct tblentry *cmdp; +#ifdef CONFIG_ASH_ALIAS + const struct alias *ap; +#endif + const char *path = pathval(); + + if (describe_command_verbose) { + out1str(command); + } + + /* First look at the keywords */ + if (findkwd(command)) { + out1str(describe_command_verbose ? " is a shell keyword" : command); + goto out; + } + +#ifdef CONFIG_ASH_ALIAS + /* Then look at the aliases */ + if ((ap = lookupalias(command, 0)) != NULL) { + if (describe_command_verbose) { + out1fmt(" is an alias for %s", ap->val); + } else { + out1str("alias "); + printalias(ap); + return 0; + } + goto out; + } +#endif + /* 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, path); + } + + switch (entry.cmdtype) { + case CMDNORMAL: { + int j = entry.u.index; + char *p; + if (j == -1) { + p = command; + } else { + do { + p = padvance(&path, command); + stunalloc(p); + } while (--j >= 0); + } + if (describe_command_verbose) { + out1fmt(" is%s %s", + (cmdp ? " a tracked alias for" : nullstr), p + ); + } else { + out1str(p); + } + break; + } + + case CMDFUNCTION: + if (describe_command_verbose) { + out1str(" is a shell function"); + } else { + out1str(command); + } + break; + + case CMDBUILTIN: + if (describe_command_verbose) { + out1fmt(" is a %sshell builtin", + IS_BUILTIN_SPECIAL(entry.u.cmd) ? + "special " : nullstr + ); + } else { + out1str(command); + } + break; + + default: + if (describe_command_verbose) { + out1str(": not found\n"); + } + return 127; + } + +out: + out1c('\n'); + return 0; +} + +static int +typecmd(int argc, char **argv) { int i; int err = 0; - char *argv_a[2]; - - argv_a[1] = 0; for (i = 1; i < argc; i++) { - argv_a[0] = argv[i]; - argptr = argv_a; - optptr = "v"; - err |= hashcmd(2, argv); +#ifdef CONFIG_ASH_CMDCMD + err |= describe_command(argv[i], 1); +#else + err |= describe_command(argv[i]); +#endif } return err; } #ifdef CONFIG_ASH_CMDCMD -static int commandcmd(int argc, char **argv) +static int +commandcmd(int argc, char **argv) { int c; int default_path = 0; @@ -3962,6 +4432,12 @@ static int commandcmd(int argc, char **argv) while ((c = nextopt("pvV")) != '\0') switch (c) { + default: +#ifdef DEBUG + fprintf(stderr, +"command: nextopt returned character code 0%o\n", c); + return EX_SOFTWARE; +#endif case 'p': default_path = 1; break; @@ -3973,68 +4449,37 @@ static int commandcmd(int argc, char **argv) break; } - if (default_path + verify_only + verbose_verify_only > 1 || !*argptr) { - out2str("command [-p] command [arg ...]\n" + if (default_path + verify_only + verbose_verify_only > 1 || + !*argptr) { + fprintf(stderr, + "command [-p] command [arg ...]\n" "command {-v|-V} command\n"); - return EX_USAGE; + return EX_USAGE; } if (verify_only || verbose_verify_only) { - char *argv_a[2]; - - argv_a[1] = 0; - argv_a[0] = *argptr; - argptr = argv_a; - optptr = verbose_verify_only ? "v" : "V"; /* reverse special */ - return hashcmd(argc, argv); + return describe_command(*argptr, verbose_verify_only); } return 0; } #endif -static int path_change(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; -} +/* $NetBSD: expand.c,v 1.56 2002/11/24 22:35:39 christos Exp $ */ /* * Routines to expand arguments to commands. We have to deal with * backquotes, shell variables, and file metacharacters. */ + /* * _rmescape() flags */ -#define RMESCAPE_ALLOC 0x1 /* Allocate a new string */ -#define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */ +#define RMESCAPE_ALLOC 0x1 /* Allocate a new string */ +#define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */ +#define RMESCAPE_QUOTED 0x4 /* Remove CTLESC unless in quotes */ +#define RMESCAPE_GROW 0x8 /* Grow strings instead of stalloc */ +#define RMESCAPE_HEAP 0x10 /* Malloc strings instead of stalloc */ /* * Structure specifying which parts of the string should be searched @@ -4042,66 +4487,87 @@ static int path_change(const char *newval, int *bltin) */ struct ifsregion { - struct ifsregion *next; /* next region in list */ - int begoff; /* offset of start of region */ - int endoff; /* offset of end of region */ - int nulonly; /* search for nul bytes only */ + struct ifsregion *next; /* next region in list */ + int begoff; /* offset of start of region */ + int endoff; /* offset of end of region */ + int nulonly; /* search for nul bytes only */ }; - -static char *expdest; /* output of current string */ -static struct nodelist *argbackq; /* list of back quote expressions */ -static struct ifsregion ifsfirst; /* first struct in list of ifs regions */ -static struct ifsregion *ifslastp; /* last struct in list */ -static struct arglist exparg; /* holds expanded arg list */ +/* output of current string */ +static char *expdest; +/* list of back quote expressions */ +static struct nodelist *argbackq; +/* first struct in list of ifs regions */ +static struct ifsregion ifsfirst; +/* last struct in list */ +static struct ifsregion *ifslastp; +/* holds expanded arg list */ +static struct arglist exparg; static void argstr(char *, int); -static char *exptilde(char *, int); +static char *exptilde(char *, char *, int); static void expbackq(union node *, int, int); -static int subevalvar(char *, char *, int, int, int, int, int); +static const char *subevalvar(char *, char *, int, int, int, int, int); +static char *evalvar(char *, int); static int varisset(char *, int); static void strtodest(const char *, int, int); +static void memtodest(const char *p, size_t len, int syntax, int quotes); static void varvalue(char *, int, int); static void recordregion(int, int, int); static void removerecordregions(int); static void ifsbreakup(char *, struct arglist *); static void ifsfree(void); static void expandmeta(struct strlist *, int); - -#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) -#define preglob(p) _rmescapes((p), RMESCAPE_ALLOC | RMESCAPE_GLOB) -#if !defined(GLOB_BROKEN) static void addglob(const glob_t *); -#endif -#endif -#if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)) -static void expmeta(char *, char *); -#endif -#if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)) -static struct strlist *expsort(struct strlist *); -static struct strlist *msort(struct strlist *, int); -#endif -static int patmatch(char *, char *, int); +static void addfname(char *); +static int patmatch(char *, const char *); -#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) -static int patmatch2(char *, char *, int); -#else -static int pmatch(char *, char *, int); +static int cvtnum(long); +static size_t esclen(const char *, const char *); +static char *scanleft(char *, char *, char *, char *, int, int); +static char *scanright(char *, char *, char *, char *, int, int); +static void varunset(const char *, const char *, const char *, int) + __attribute__((__noreturn__)); + + +#define pmatch(a, b) !fnmatch((a), (b), 0) +/* + * Prepare a pattern for a glob(3) call. + * + * Returns an stalloced string. + */ + +static inline char * +preglob(const char *pattern, int quoted, int flag) { + flag |= RMESCAPE_GLOB; + if (quoted) { + flag |= RMESCAPE_QUOTED; + } + return _rmescapes((char *)pattern, flag); +} + + +static size_t +esclen(const char *start, const char *p) { + size_t esc = 0; + + while (p > start && *--p == CTLESC) { + esc++; + } + return esc; +} -#define patmatch2 patmatch -#endif -static char *cvtnum(int, char *); /* * Expand shell variables and backquotes inside a here document. */ -/* arg: the document, fd: where to write the expanded version */ -static inline void expandhere(union node *arg, int fd) +static inline void +expandhere(union node *arg, int fd) { herefd = fd; - expandarg(arg, (struct arglist *) NULL, 0); - xwrite(fd, stackblock(), expdest - stackblock()); + expandarg(arg, (struct arglist *)NULL, 0); + xwrite(fd, stackblock(), expdest - (char *)stackblock()); } @@ -4112,7 +4578,8 @@ static inline void expandhere(union node *arg, int fd) * here document expansion. */ -static void expandarg(union node *arg, struct arglist *arglist, int flag) +void +expandarg(union node *arg, struct arglist *arglist, int flag) { struct strlist *sp; char *p; @@ -4123,7 +4590,7 @@ static void expandarg(union node *arg, struct arglist *arglist, int flag) ifslastp = NULL; argstr(arg->narg.text, flag); if (arglist == NULL) { - return; /* here document expanded */ + return; /* here document expanded */ } STPUTC('\0', expdest); p = grabstackstr(expdest); @@ -4137,14 +4604,15 @@ static void expandarg(union node *arg, struct arglist *arglist, int flag) exparg.lastp = &exparg.list; expandmeta(exparg.list, flag); } else { - if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */ + if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */ rmescapes(p); - sp = (struct strlist *) stalloc(sizeof(struct strlist)); + sp = (struct strlist *)stalloc(sizeof (struct strlist)); sp->text = p; *exparg.lastp = sp; exparg.lastp = &sp->next; } - ifsfree(); + if (ifsfirst.next) + ifsfree(); *exparg.lastp = NULL; if (exparg.list) { *arglist->lastp = exparg.list; @@ -4153,239 +4621,166 @@ static void expandarg(union node *arg, struct arglist *arglist, int flag) } + /* - * Expand a variable, and return a pointer to the next character in the - * input string. + * Perform variable and command substitution. If EXP_FULL is set, output CTLESC + * characters to allow for further processing. Otherwise treat + * $@ like $* since no splitting will be performed. */ -static inline char *evalvar(char *p, int flag) -{ - int subtype; - int varflags; - char *var; - const char *val; - int patloc; +static void +argstr(char *p, int flag) +{ + static const char spclchars[] = { + '=', + ':', + CTLQUOTEMARK, + CTLENDVAR, + CTLESC, + CTLVAR, + CTLBACKQ, + CTLBACKQ | CTLQUOTE, +#ifdef CONFIG_ASH_MATH_SUPPORT + CTLENDARI, +#endif + 0 + }; + const char *reject = spclchars; int c; - int set; - int special; + int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */ + int breakall = flag & EXP_WORD; + int inquotes; + size_t length; int startloc; - int varlen; - int easy; - int quotes = flag & (EXP_FULL | EXP_CASE); - varflags = *p++; - subtype = varflags & VSTYPE; - var = p; - special = 0; - if (!is_name(*p)) - special = 1; - p = strchr(p, '=') + 1; - again: /* jump here after setting a variable with ${var=text} */ - if (special) { - set = varisset(var, varflags & VSNUL); - val = NULL; - } else { - val = lookupvar(var); - if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) { - val = NULL; - set = 0; - } else - set = 1; + if (!(flag & EXP_VARTILDE)) { + reject += 2; + } else if (flag & EXP_VARTILDE2) { + reject++; } - varlen = 0; - startloc = expdest - stackblock(); - if (set && subtype != VSPLUS) { - /* insert the value of the variable */ - if (special) { - varvalue(var, varflags & VSQUOTE, flag); - if (subtype == VSLENGTH) { - varlen = expdest - stackblock() - startloc; - STADJUST(-varlen, expdest); - } - } else { - if (subtype == VSLENGTH) { - varlen = strlen(val); - } else { - strtodest(val, - varflags & VSQUOTE ? DQSYNTAX : BASESYNTAX, quotes); - } - } - } - - if (subtype == VSPLUS) - set = !set; - - easy = ((varflags & VSQUOTE) == 0 || - (*var == '@' && shellparam.nparam != 1)); - + inquotes = 0; + length = 0; + if (flag & EXP_TILDE) { + char *q; - switch (subtype) { - case VSLENGTH: - expdest = cvtnum(varlen, expdest); - goto record; - - case VSNORMAL: - if (!easy) - break; - record: - recordregion(startloc, expdest - stackblock(), varflags & VSQUOTE); - break; - - case VSPLUS: - case VSMINUS: - if (!set) { - argstr(p, flag); - break; - } - if (easy) - goto record; - break; - - case VSTRIMLEFT: - case VSTRIMLEFTMAX: - case VSTRIMRIGHT: - case VSTRIMRIGHTMAX: - if (!set) - break; - /* - * Terminate the string and start recording the pattern - * right after it - */ - STPUTC('\0', expdest); - patloc = expdest - stackblock(); - if (subevalvar(p, NULL, patloc, subtype, - startloc, varflags, quotes) == 0) { - int amount = (expdest - stackblock() - patloc) + 1; - - STADJUST(-amount, expdest); - } - /* Remove any recorded regions beyond start of variable */ - removerecordregions(startloc); - goto record; - - case VSASSIGN: - case VSQUESTION: - if (!set) { - if (subevalvar(p, var, 0, subtype, startloc, varflags, quotes)) { - varflags &= ~VSNUL; - /* - * Remove any recorded regions beyond - * start of variable - */ - removerecordregions(startloc); - goto again; + flag &= ~EXP_TILDE; +tilde: + q = p; + if (*q == CTLESC && (flag & EXP_QWORD)) + q++; + if (*q == '~') + p = exptilde(p, q, flag); + } +start: + startloc = expdest - (char *)stackblock(); + for (;;) { + length += strcspn(p + length, reject); + c = p[length]; + if (c && (!(c & 0x80) +#ifdef CONFIG_ASH_MATH_SUPPORT + || c == CTLENDARI +#endif + )) { + /* c == '=' || c == ':' || c == CTLENDARI */ + length++; + } + if (length > 0) { + int newloc; + expdest = stnputs(p, length, expdest); + newloc = expdest - (char *)stackblock(); + if (breakall && !inquotes && newloc > startloc) { + recordregion(startloc, newloc, 0); } - break; + startloc = newloc; } - if (easy) - goto record; - break; - -#ifdef DEBUG - default: - abort(); -#endif - } + p += length + 1; + length = 0; - if (subtype != VSNORMAL) { /* skip to end of alternative */ - int nesting = 1; - - for (;;) { - if ((c = *p++) == CTLESC) - p++; - else if (c == CTLBACKQ || c == (CTLBACKQ | CTLQUOTE)) { - if (set) - argbackq = argbackq->next; - } else if (c == CTLVAR) { - if ((*p++ & VSTYPE) != VSNORMAL) - nesting++; - } else if (c == CTLENDVAR) { - if (--nesting == 0) - break; + switch (c) { + case '\0': + goto breakloop; + case '=': + if (flag & EXP_VARTILDE2) { + p--; + continue; } + flag |= EXP_VARTILDE2; + reject++; + /* fall through */ + case ':': + /* + * sort of a hack - expand tildes in variable + * assignments (after the first '=' and after ':'s). + */ + if (*--p == '~') { + goto tilde; + } + continue; } - } - return p; -} - -/* - * Perform variable and command substitution. If EXP_FULL is set, output CTLESC - * characters to allow for further processing. Otherwise treat - * $@ like $* since no splitting will be performed. - */ - -static void argstr(char *p, int flag) -{ - char c; - int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */ - int firsteq = 1; - - if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE))) - p = exptilde(p, flag); - for (;;) { - switch (c = *p++) { - case '\0': - case CTLENDVAR: /* ??? */ - return; + switch (c) { + case CTLENDVAR: /* ??? */ + goto breakloop; case CTLQUOTEMARK: /* "$@" syntax adherence hack */ - if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=') - break; - if ((flag & EXP_FULL) != 0) - STPUTC(c, expdest); + if ( + !inquotes && + !memcmp(p, dolatstr, DOLATSTRLEN) && + (p[4] == CTLQUOTEMARK || ( + p[4] == CTLENDVAR && + p[5] == CTLQUOTEMARK + )) + ) { + p = evalvar(p + 1, flag) + 1; + goto start; + } + inquotes = !inquotes; +addquote: + if (quotes) { + p--; + length++; + startloc++; + } break; case CTLESC: - if (quotes) - STPUTC(c, expdest); - c = *p++; - STPUTC(c, expdest); - break; + startloc++; + length++; + goto addquote; case CTLVAR: p = evalvar(p, flag); - break; + goto start; case CTLBACKQ: - case CTLBACKQ | CTLQUOTE: - expbackq(argbackq->n, c & CTLQUOTE, flag); + c = 0; + case CTLBACKQ|CTLQUOTE: + expbackq(argbackq->n, c, quotes); argbackq = argbackq->next; - break; + goto start; #ifdef CONFIG_ASH_MATH_SUPPORT case CTLENDARI: - expari(flag); - break; + p--; + expari(quotes); + goto start; #endif - case ':': - case '=': - /* - * sort of a hack - expand tildes in variable - * assignments (after the first '=' and after ':'s). - */ - STPUTC(c, expdest); - if (flag & EXP_VARTILDE && *p == '~') { - if (c == '=') { - if (firsteq) - firsteq = 0; - else - break; - } - p = exptilde(p, flag); - } - break; - default: - STPUTC(c, expdest); } } +breakloop: + ; } -static char *exptilde(char *p, int flag) +static char * +exptilde(char *startp, char *p, int flag) { - char c, *startp = p; + char c; + char *name; struct passwd *pw; const char *home; int quotes = flag & (EXP_FULL | EXP_CASE); + int startloc; - while ((c = *p) != '\0') { - switch (c) { + name = p + 1; + + while ((c = *++p) != '\0') { + switch(c) { case CTLESC: return (startp); case CTLQUOTEMARK: @@ -4395,32 +4790,35 @@ static char *exptilde(char *p, int flag) goto done; break; case '/': + case CTLENDVAR: goto done; } - p++; } - done: +done: *p = '\0'; - if (*(startp + 1) == '\0') { - if ((home = lookupvar("HOME")) == NULL) + if (*name == '\0') { + if ((home = lookupvar(homestr)) == NULL) goto lose; } else { - if ((pw = getpwnam(startp + 1)) == NULL) + if ((pw = getpwnam(name)) == NULL) goto lose; home = pw->pw_dir; } if (*home == '\0') goto lose; *p = c; + startloc = expdest - (char *)stackblock(); strtodest(home, SQSYNTAX, quotes); + recordregion(startloc, expdest - (char *)stackblock(), 0); return (p); - lose: +lose: *p = c; return (startp); } -static void removerecordregions(int endoff) +static void +removerecordregions(int endoff) { if (ifslastp == NULL) return; @@ -4428,10 +4826,9 @@ static void removerecordregions(int endoff) if (ifsfirst.endoff > endoff) { while (ifsfirst.next != NULL) { struct ifsregion *ifsp; - INTOFF; ifsp = ifsfirst.next->next; - free(ifsfirst.next); + ckfree(ifsfirst.next); ifsfirst.next = ifsp; INTON; } @@ -4446,13 +4843,12 @@ static void removerecordregions(int endoff) ifslastp = &ifsfirst; while (ifslastp->next && ifslastp->next->begoff < endoff) - ifslastp = ifslastp->next; + ifslastp=ifslastp->next; while (ifslastp->next != NULL) { struct ifsregion *ifsp; - INTOFF; ifsp = ifslastp->next->next; - free(ifslastp->next); + ckfree(ifslastp->next); ifslastp->next = ifsp; INTON; } @@ -4466,62 +4862,60 @@ static void removerecordregions(int endoff) * Expand arithmetic expression. Backup to start of expression, * evaluate, place result in (backed up) result, adjust string position. */ -static void expari(int flag) +void +expari(int quotes) { char *p, *start; - int errcode; - int result; int begoff; - int quotes = flag & (EXP_FULL | EXP_CASE); - int quoted; + int flag; + int len; /* ifsfree(); */ /* * This routine is slightly over-complicated for - * efficiency. First we make sure there is - * enough space for the result, which may be bigger - * than the expression if we add exponentation. Next we - * scan backwards looking for the start of arithmetic. If the - * next previous character is a CTLESC character, then we - * have to rescan starting from the beginning since CTLESC - * characters have to be processed left to right. + * efficiency. Next we scan backwards looking for the + * start of arithmetic. */ - CHECKSTRSPACE(10, expdest); - USTPUTC('\0', expdest); start = stackblock(); p = expdest - 1; - while (*p != CTLARI && p >= start) - --p; - if (*p != CTLARI) - error("missing CTLARI (shouldn't happen)"); - if (p > start && *(p - 1) == CTLESC) - for (p = start; *p != CTLARI; p++) - if (*p == CTLESC) - p++; + *p = '\0'; + p--; + do { + int esc; + + while (*p != CTLARI) { + p--; +#ifdef DEBUG + if (p < start) { + error("missing CTLARI (shouldn't happen)"); + } +#endif + } + + esc = esclen(start, p); + if (!(esc % 2)) { + break; + } + + p -= esc + 1; + } while (1); - if (p[1] == '"') - quoted = 1; - else - quoted = 0; begoff = p - start; + removerecordregions(begoff); + + flag = p[1]; + + expdest = p; + if (quotes) rmescapes(p + 2); - result = arith(p + 2, &errcode); - if (errcode < 0) { - if (errcode == -2) - error("divide by zero"); - else - error("syntax error: \"%s\"\n", p + 2); - } - snprintf(p, 12, "%d", result); - while (*p++); - if (quoted == 0) - recordregion(begoff, p - 1 - start, 0); - result = expdest - p + 1; - STADJUST(-result, expdest); + len = cvtnum(dash_arith(p + 2)); + + if (flag != '"') + recordregion(begoff, begoff + len, 0); } #endif @@ -4529,229 +4923,378 @@ static void expari(int flag) * Expand stuff in backwards quotes. */ -static void expbackq(union node *cmd, int quoted, int flag) +static void +expbackq(union node *cmd, int quoted, int quotes) { - volatile struct backcmd in; + struct backcmd in; int i; char buf[128]; char *p; - char *dest = expdest; - volatile struct ifsregion saveifs; - struct ifsregion *volatile savelastp; - struct nodelist *volatile saveargbackq; - char lastc; - int startloc = dest - stackblock(); - int syntax = quoted ? DQSYNTAX : BASESYNTAX; - volatile int saveherefd; - int quotes = flag & (EXP_FULL | EXP_CASE); - struct jmploc jmploc; - struct jmploc *volatile savehandler; - int ex; - -#if __GNUC__ - /* Avoid longjmp clobbering */ - (void) &dest; - (void) &syntax; -#endif - - in.fd = -1; - in.buf = 0; - in.jp = 0; + char *dest; + int startloc; + int syntax = quoted? DQSYNTAX : BASESYNTAX; + struct stackmark smark; INTOFF; - saveifs = ifsfirst; - savelastp = ifslastp; - saveargbackq = argbackq; - saveherefd = herefd; - herefd = -1; - if ((ex = setjmp(jmploc.loc))) { - goto err1; - } - savehandler = handler; - handler = &jmploc; - INTON; - p = grabstackstr(dest); + setstackmark(&smark); + dest = expdest; + startloc = dest - (char *)stackblock(); + grabstackstr(dest); evalbackcmd(cmd, (struct backcmd *) &in); - ungrabstackstr(p, dest); - err1: - INTOFF; - ifsfirst = saveifs; - ifslastp = savelastp; - argbackq = saveargbackq; - herefd = saveherefd; - if (ex) { - goto err2; - } + popstackmark(&smark); p = in.buf; - lastc = '\0'; + i = in.nleft; + if (i == 0) + goto read; for (;;) { - if (--in.nleft < 0) { - if (in.fd < 0) - break; - i = safe_read(in.fd, buf, sizeof buf); - TRACE(("expbackq: read returns %d\n", i)); - if (i <= 0) - break; - p = buf; - in.nleft = i - 1; - } - lastc = *p++; - if (lastc != '\0') { - if (quotes && SIT(lastc, syntax) == CCTL) - STPUTC(CTLESC, dest); - STPUTC(lastc, dest); - } + memtodest(p, i, syntax, quotes); +read: + if (in.fd < 0) + break; + i = safe_read(in.fd, buf, sizeof buf); + TRACE(("expbackq: read returns %d\n", i)); + if (i <= 0) + break; + p = buf; } + if (in.buf) + ckfree(in.buf); + if (in.fd >= 0) { + close(in.fd); + back_exitstatus = waitforjob(in.jp); + } + INTON; + /* Eat all trailing newlines */ - for (; dest > stackblock() && dest[-1] == '\n';) + dest = expdest; + for (; dest > (char *)stackblock() && dest[-1] == '\n';) STUNPUTC(dest); + expdest = dest; - err2: - if (in.fd >= 0) - close(in.fd); - free(in.buf); - if (in.jp) - exitstatus = waitforjob(in.jp); - handler = savehandler; - if (ex) { - longjmp(handler->loc, 1); - } if (quoted == 0) - recordregion(startloc, dest - stackblock(), 0); + recordregion(startloc, dest - (char *)stackblock(), 0); TRACE(("evalbackq: size=%d: \"%.*s\"\n", - (dest - stackblock()) - startloc, - (dest - stackblock()) - startloc, stackblock() + startloc)); - expdest = dest; - INTON; + (dest - (char *)stackblock()) - startloc, + (dest - (char *)stackblock()) - startloc, + stackblock() + startloc)); } -static int -subevalvar(char *p, char *str, int strloc, int subtype, int startloc, - int varflags, int quotes) + +static char * +scanleft( + char *startp, char *rmesc, char *rmescend, char *str, int quotes, + int zero +) { + char *loc; + char *loc2; + char c; + + loc = startp; + loc2 = rmesc; + do { + int match; + const char *s = loc2; + c = *loc2; + if (zero) { + *loc2 = '\0'; + s = rmesc; + } + match = pmatch(str, s); + *loc2 = c; + if (match) + return loc; + if (quotes && *loc == CTLESC) + loc++; + loc++; + loc2++; + } while (c); + return 0; +} + + +static char * +scanright( + char *startp, char *rmesc, char *rmescend, char *str, int quotes, + int zero +) { + int esc = 0; + char *loc; + char *loc2; + + for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) { + int match; + char c = *loc2; + const char *s = loc2; + if (zero) { + *loc2 = '\0'; + s = rmesc; + } + match = pmatch(str, s); + *loc2 = c; + if (match) + return loc; + loc--; + if (quotes) { + if (--esc < 0) { + esc = esclen(startp, loc); + } + if (esc % 2) { + esc--; + loc--; + } + } + } + return 0; +} + +static const char * +subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes) { char *startp; - char *loc = NULL; - char *q; - int c = 0; + char *loc; int saveherefd = herefd; struct nodelist *saveargbackq = argbackq; int amount; + char *rmesc, *rmescend; + int zero; + char *(*scan)(char *, char *, char *, char *, int , int); herefd = -1; argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0); - STACKSTRNUL(expdest); + STPUTC('\0', expdest); herefd = saveherefd; argbackq = saveargbackq; startp = stackblock() + startloc; - if (str == NULL) - str = stackblock() + strloc; switch (subtype) { case VSASSIGN: setvar(str, startp, 0); amount = startp - expdest; STADJUST(amount, expdest); - varflags &= ~VSNUL; - if (c != 0) - *loc = c; - return 1; + return startp; case VSQUESTION: - if (*p != CTLENDVAR) { - out2fmt(snlfmt, startp); - error((char *) NULL); - } - error("%.*s: parameter %snot set", p - str - 1, - str, (varflags & VSNUL) ? "null or " : nullstr); + varunset(p, str, startp, varflags); /* NOTREACHED */ + } - case VSTRIMLEFT: - for (loc = startp; loc < str; loc++) { - c = *loc; - *loc = '\0'; - if (patmatch2(str, startp, quotes)) - goto recordleft; - *loc = c; - if (quotes && *loc == CTLESC) - loc++; + subtype -= VSTRIMRIGHT; +#ifdef DEBUG + if (subtype < 0 || subtype > 3) + abort(); +#endif + + rmesc = startp; + rmescend = stackblock() + strloc; + if (quotes) { + rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW); + if (rmesc != startp) { + rmescend = expdest; + startp = stackblock() + startloc; } - return 0; + } + rmescend--; + str = stackblock() + strloc; + preglob(str, varflags & VSQUOTE, 0); - case VSTRIMLEFTMAX: - for (loc = str - 1; loc >= startp;) { - c = *loc; - *loc = '\0'; - if (patmatch2(str, startp, quotes)) - goto recordleft; - *loc = c; - loc--; - if (quotes && loc > startp && *(loc - 1) == CTLESC) { - for (q = startp; q < loc; q++) - if (*q == CTLESC) - q++; - if (q > loc) - loc--; - } + /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */ + zero = subtype >> 1; + /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */ + scan = (subtype & 1) ^ zero ? scanleft : scanright; + + loc = scan(startp, rmesc, rmescend, str, quotes, zero); + if (loc) { + if (zero) { + memmove(startp, loc, str - loc); + loc = startp + (str - loc) - 1; } - return 0; + *loc = '\0'; + amount = loc - expdest; + STADJUST(amount, expdest); + } + return loc; +} - case VSTRIMRIGHT: - for (loc = str - 1; loc >= startp;) { - if (patmatch2(str, loc, quotes)) - goto recordright; - loc--; - if (quotes && loc > startp && *(loc - 1) == CTLESC) { - for (q = startp; q < loc; q++) - if (*q == CTLESC) - q++; - if (q > loc) - loc--; + +/* + * Expand a variable, and return a pointer to the next character in the + * input string. + */ +static char * +evalvar(char *p, int flag) +{ + int subtype; + int varflags; + char *var; + int patloc; + int c; + int set; + int startloc; + size_t varlen; + int easy; + int quotes; + int quoted; + + quotes = flag & (EXP_FULL | EXP_CASE); + varflags = *p++; + subtype = varflags & VSTYPE; + quoted = varflags & VSQUOTE; + var = p; + easy = (!quoted || (*var == '@' && shellparam.nparam)); + varlen = 0; + startloc = expdest - (char *)stackblock(); + p = strchr(p, '=') + 1; + + if (!is_name(*var)) { + set = varisset(var, varflags & VSNUL); + set--; + if (subtype == VSPLUS) + goto vsplus; + if (++set) { + varvalue(var, quoted, flag); + if (subtype == VSLENGTH) { + varlen = + expdest - (char *)stackblock() - + startloc; + STADJUST(-varlen, expdest); + goto vslen; } } - return 0; + } else { + const char *val; +again: + /* jump here after setting a variable with ${var=text} */ + val = lookupvar(var); + set = !val || ((varflags & VSNUL) && !*val); + if (subtype == VSPLUS) + goto vsplus; + if (--set) { + varlen = strlen(val); + if (subtype == VSLENGTH) + goto vslen; + memtodest( + val, varlen, quoted ? DQSYNTAX : BASESYNTAX, + quotes + ); + } + } - case VSTRIMRIGHTMAX: - for (loc = startp; loc < str - 1; loc++) { - if (patmatch2(str, loc, quotes)) - goto recordright; - if (quotes && *loc == CTLESC) - loc++; + + if (subtype == VSMINUS) { +vsplus: + if (!set) { + argstr( + p, flag | EXP_TILDE | + (quoted ? EXP_QWORD : EXP_WORD) + ); + goto end; } - return 0; + if (easy) + goto record; + goto end; + } + + if (subtype == VSASSIGN || subtype == VSQUESTION) { + if (!set) { + if (subevalvar(p, var, 0, subtype, startloc, + varflags, 0)) { + varflags &= ~VSNUL; + /* + * Remove any recorded regions beyond + * start of variable + */ + removerecordregions(startloc); + goto again; + } + goto end; + } + if (easy) + goto record; + goto end; + } + + if (!set && uflag) + varunset(p, var, 0, 0); + + if (subtype == VSLENGTH) { +vslen: + cvtnum(varlen); + goto record; + } + + if (subtype == VSNORMAL) { + if (!easy) + goto end; +record: + recordregion(startloc, expdest - (char *)stackblock(), quoted); + goto end; + } #ifdef DEBUG + switch (subtype) { + case VSTRIMLEFT: + case VSTRIMLEFTMAX: + case VSTRIMRIGHT: + case VSTRIMRIGHTMAX: + break; default: abort(); -#endif } +#endif - recordleft: - *loc = c; - amount = ((str - 1) - (loc - startp)) - expdest; - STADJUST(amount, expdest); - while (loc != str - 1) - *startp++ = *loc++; - return 1; + if (set) { + /* + * Terminate the string and start recording the pattern + * right after it + */ + STPUTC('\0', expdest); + patloc = expdest - (char *)stackblock(); + if (subevalvar(p, NULL, patloc, subtype, + startloc, varflags, quotes) == 0) { + int amount = expdest - ( + (char *)stackblock() + patloc - 1 + ); + STADJUST(-amount, expdest); + } + /* Remove any recorded regions beyond start of variable */ + removerecordregions(startloc); + goto record; + } - recordright: - amount = loc - expdest; - STADJUST(amount, expdest); - STPUTC('\0', expdest); - STADJUST(-1, expdest); - return 1; +end: + if (subtype != VSNORMAL) { /* skip to end of alternative */ + int nesting = 1; + for (;;) { + if ((c = *p++) == CTLESC) + p++; + else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) { + if (set) + argbackq = argbackq->next; + } else if (c == CTLVAR) { + if ((*p++ & VSTYPE) != VSNORMAL) + nesting++; + } else if (c == CTLENDVAR) { + if (--nesting == 0) + break; + } + } + } + return p; } + /* * Test whether a specialized variable is set. */ -static int varisset(char *name, int nulok) +static int +varisset(char *name, int nulok) { if (*name == '!') - return backgndpid != -1; + return backgndpid != 0; else if (*name == '@' || *name == '*') { if (*shellparam.p == NULL) return 0; @@ -4782,24 +5325,45 @@ static int varisset(char *name, int nulok) return 1; } + + /* * Put a string on the stack. */ -static void strtodest(const char *p, int syntax, int quotes) -{ - while (*p) { - if (quotes && SIT(*p, syntax) == CCTL) - STPUTC(CTLESC, expdest); - STPUTC(*p++, expdest); +static void +memtodest(const char *p, size_t len, int syntax, int quotes) { + char *q = expdest; + + q = makestrspace(len * 2, q); + + while (len--) { + int c = *p++; + if (!c) + continue; + if (quotes && (SIT(c, syntax) == CCTL || SIT(c, syntax) == CBACK)) + USTPUTC(CTLESC, q); + USTPUTC(c, q); } + + expdest = q; +} + + +static void +strtodest(const char *p, int syntax, int quotes) +{ + memtodest(p, strlen(p), syntax, quotes); } + + /* * Add the value of a specialized variable to the stack string. */ -static void varvalue(char *name, int quoted, int flags) +static void +varvalue(char *name, int quoted, int flags) { int num; char *p; @@ -4817,20 +5381,20 @@ static void varvalue(char *name, int quoted, int flags) num = rootpid; goto numvar; case '?': - num = oexitstatus; + num = exitstatus; goto numvar; case '#': num = shellparam.nparam; goto numvar; case '!': num = backgndpid; - numvar: - expdest = cvtnum(num, expdest); +numvar: + cvtnum(num); break; case '-': - for (i = 0; i < NOPTS; i++) { - if (optent_val(i)) - STPUTC(optent_letter(optlist[i]), expdest); + for (i = 0 ; i < NOPTS ; i++) { + if (optlist[i]) + STPUTC(optletters(i), expdest); } break; case '@': @@ -4840,17 +5404,19 @@ static void varvalue(char *name, int quoted, int flags) } /* fall through */ case '*': - sep = ifsset()? ifsval()[0] : ' '; + sep = ifsset() ? ifsval()[0] : ' '; if (quotes) { - sepq = SIT(sep, syntax) == CCTL; + sepq = (SIT(sep, syntax) == CCTL) || (SIT(sep, syntax) == CBACK); } - param: - for (ap = shellparam.p; (p = *ap++) != NULL;) { +param: + for (ap = shellparam.p ; (p = *ap++) != NULL ; ) { strtodest(p, syntax, quotes); if (*ap && sep) { + p = expdest; if (sepq) - STPUTC(CTLESC, expdest); - STPUTC(sep, expdest); + STPUTC(CTLESC, p); + STPUTC(sep, p); + expdest = p; } } break; @@ -4867,12 +5433,14 @@ static void varvalue(char *name, int quoted, int flags) } + /* * Record the fact that we have to scan this region of the * string for IFS characters. */ -static void recordregion(int start, int end, int nulonly) +static void +recordregion(int start, int end, int nulonly) { struct ifsregion *ifsp; @@ -4880,7 +5448,7 @@ static void recordregion(int start, int end, int nulonly) ifsp = &ifsfirst; } else { INTOFF; - ifsp = (struct ifsregion *) xmalloc(sizeof(struct ifsregion)); + ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion)); ifsp->next = NULL; ifslastp->next = ifsp; INTON; @@ -4898,7 +5466,8 @@ static void recordregion(int start, int end, int nulonly) * strings to the argument list. The regions of the string to be * searched for IFS characters have been stored by recordregion. */ -static void ifsbreakup(char *string, struct arglist *arglist) +static void +ifsbreakup(char *string, struct arglist *arglist) { struct ifsregion *ifsp; struct strlist *sp; @@ -4911,10 +5480,10 @@ static void ifsbreakup(char *string, struct arglist *arglist) start = string; - ifsspc = 0; - nulonly = 0; - realifs = ifsset()? ifsval() : defifs; if (ifslastp != NULL) { + ifsspc = 0; + nulonly = 0; + realifs = ifsset() ? ifsval() : defifs; ifsp = &ifsfirst; do { p = string + ifsp->begoff; @@ -4935,7 +5504,7 @@ static void ifsbreakup(char *string, struct arglist *arglist) continue; } *q = '\0'; - sp = (struct strlist *) stalloc(sizeof *sp); + sp = (struct strlist *)stalloc(sizeof *sp); sp->text = start; *arglist->lastp = sp; arglist->lastp = &sp->next; @@ -4948,7 +5517,7 @@ static void ifsbreakup(char *string, struct arglist *arglist) q = p; if (*p == CTLESC) p++; - if (strchr(ifs, *p) == NULL) { + if (strchr(ifs, *p) == NULL ) { p = q; break; } else if (strchr(defifs, *p) == NULL) { @@ -4968,84 +5537,83 @@ static void ifsbreakup(char *string, struct arglist *arglist) p++; } } while ((ifsp = ifsp->next) != NULL); - if (!(*start || (!ifsspc && start > string && nulonly))) { - return; - } + if (nulonly) + goto add; } - sp = (struct strlist *) stalloc(sizeof *sp); + if (!*start) + return; + +add: + sp = (struct strlist *)stalloc(sizeof *sp); sp->text = start; *arglist->lastp = sp; arglist->lastp = &sp->next; } -static void ifsfree(void) +static void +ifsfree(void) { - while (ifsfirst.next != NULL) { - struct ifsregion *ifsp; + struct ifsregion *p; - INTOFF; - ifsp = ifsfirst.next->next; - free(ifsfirst.next); - ifsfirst.next = ifsp; - INTON; - } + INTOFF; + p = ifsfirst.next; + do { + struct ifsregion *ifsp; + ifsp = p->next; + ckfree(p); + p = ifsp; + } while (p); ifslastp = NULL; ifsfirst.next = NULL; + INTON; } -/* - * Add a file name to the list. - */ - -static void addfname(const char *name) -{ - struct strlist *sp; - size_t len = strlen(name) + 1; - sp = (struct strlist *) stalloc(sizeof *sp); - sp->text = memcpy(stalloc(len), name, len); - *exparg.lastp = sp; - exparg.lastp = &sp->next; -} /* * Expand shell metacharacters. At this point, the only control characters * should be escapes. The results are stored in the list exparg. */ -#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) -static void expandmeta(struct strlist *str, int flag) +static void +expandmeta(str, flag) + struct strlist *str; + int flag; { - const char *p; - glob_t pglob; - /* TODO - EXP_REDIR */ while (str) { + const char *p; + glob_t pglob; + int i; + if (fflag) goto nometa; - p = preglob(str->text); INTOFF; - switch (glob(p, 0, 0, &pglob)) { + p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP); + i = glob(p, GLOB_NOMAGIC, 0, &pglob); + if (p != str->text) + ckfree(p); + switch (i) { case 0: - if (pglob.gl_pathv[1] == 0 && !strcmp(p, pglob.gl_pathv[0])) + if (!(pglob.gl_flags & GLOB_MAGCHAR)) goto nometa2; addglob(&pglob); globfree(&pglob); INTON; break; case GLOB_NOMATCH: - nometa2: +nometa2: globfree(&pglob); INTON; - nometa: +nometa: *exparg.lastp = str; rmescapes(str->text); exparg.lastp = &str->next; break; - default: /* GLOB_NOSPACE */ - error("Out of space"); + default: /* GLOB_NOSPACE */ + error(bb_msg_memory_exhausted); } str = str->next; } @@ -5056,7 +5624,9 @@ static void expandmeta(struct strlist *str, int flag) * Add the result of glob(3) to the list. */ -static void addglob(const glob_t * pglob) +static void +addglob(pglob) + const glob_t *pglob; { char **p = pglob->gl_pathv; @@ -5066,414 +5636,45 @@ static void addglob(const glob_t * pglob) } -#else /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */ -static char *expdir; - - -static void expandmeta(struct strlist *str, int flag) -{ - char *p; - struct strlist **savelastp; - struct strlist *sp; - char c; - - /* TODO - EXP_REDIR */ - - while (str) { - if (fflag) - goto nometa; - p = str->text; - for (;;) { /* fast check for meta chars */ - if ((c = *p++) == '\0') - goto nometa; - if (c == '*' || c == '?' || c == '[' || c == '!') - break; - } - savelastp = exparg.lastp; - INTOFF; - if (expdir == NULL) { - int i = strlen(str->text); - - expdir = xmalloc(i < 2048 ? 2048 : i); /* XXX */ - } - - expmeta(expdir, str->text); - free(expdir); - expdir = NULL; - INTON; - if (exparg.lastp == savelastp) { - /* - * no matches - */ - nometa: - *exparg.lastp = str; - rmescapes(str->text); - exparg.lastp = &str->next; - } else { - *exparg.lastp = NULL; - *savelastp = sp = expsort(*savelastp); - while (sp->next != NULL) - sp = sp->next; - exparg.lastp = &sp->next; - } - str = str->next; - } -} - - /* - * Do metacharacter (i.e. *, ?, [...]) expansion. - */ - -static void expmeta(char *enddir, char *name) -{ - char *p; - const char *cp; - char *q; - char *start; - char *endname; - int metaflag; - struct stat statb; - DIR *dirp; - struct dirent *dp; - int atend; - int matchdot; - - metaflag = 0; - start = name; - for (p = name;; p++) { - if (*p == '*' || *p == '?') - metaflag = 1; - else if (*p == '[') { - q = p + 1; - if (*q == '!') - q++; - for (;;) { - while (*q == CTLQUOTEMARK) - q++; - if (*q == CTLESC) - q++; - if (*q == '/' || *q == '\0') - break; - if (*++q == ']') { - metaflag = 1; - break; - } - } - } else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) { - metaflag = 1; - } else if (*p == '\0') - break; - else if (*p == CTLQUOTEMARK) - continue; - else if (*p == CTLESC) - p++; - if (*p == '/') { - if (metaflag) - break; - start = p + 1; - } - } - if (metaflag == 0) { /* we've reached the end of the file name */ - if (enddir != expdir) - metaflag++; - for (p = name;; p++) { - if (*p == CTLQUOTEMARK) - continue; - if (*p == CTLESC) - p++; - *enddir++ = *p; - if (*p == '\0') - break; - } - if (metaflag == 0 || lstat(expdir, &statb) >= 0) - addfname(expdir); - return; - } - endname = p; - if (start != name) { - p = name; - while (p < start) { - while (*p == CTLQUOTEMARK) - p++; - if (*p == CTLESC) - p++; - *enddir++ = *p++; - } - } - if (enddir == expdir) { - cp = "."; - } else if (enddir == expdir + 1 && *expdir == '/') { - cp = "/"; - } else { - cp = expdir; - enddir[-1] = '\0'; - } - if ((dirp = opendir(cp)) == NULL) - return; - if (enddir != expdir) - enddir[-1] = '/'; - if (*endname == 0) { - atend = 1; - } else { - atend = 0; - *endname++ = '\0'; - } - matchdot = 0; - p = start; - while (*p == CTLQUOTEMARK) - p++; - if (*p == CTLESC) - p++; - if (*p == '.') - matchdot++; - while (!int_pending() && (dp = readdir(dirp)) != NULL) { - if (dp->d_name[0] == '.' && !matchdot) - continue; - if (patmatch(start, dp->d_name, 0)) { - if (atend) { - strcpy(enddir, dp->d_name); - addfname(expdir); - } else { - for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';) - continue; - p[-1] = '/'; - expmeta(p, endname); - } - } - } - closedir(dirp); - if (!atend) - endname[-1] = '/'; -} -#endif /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */ - - - -#if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !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 - * work. + * Add a file name to the list. */ -static struct strlist *expsort(struct strlist *str) +static void +addfname(char *name) { - int len; struct strlist *sp; - len = 0; - for (sp = str; sp; sp = sp->next) - len++; - return msort(str, len); -} - - -static struct strlist *msort(struct strlist *list, int len) -{ - struct strlist *p, *q = NULL; - struct strlist **lpp; - int half; - int n; - - if (len <= 1) - return list; - half = len >> 1; - p = list; - for (n = half; --n >= 0;) { - q = p; - p = p->next; - } - q->next = NULL; /* terminate first half of list */ - q = msort(list, half); /* sort first half of list */ - p = msort(p, len - half); /* sort second half */ - lpp = &list; - for (;;) { - if (strcmp(p->text, q->text) < 0) { - *lpp = p; - lpp = &p->next; - if ((p = *lpp) == NULL) { - *lpp = q; - break; - } - } else { - *lpp = q; - lpp = &q->next; - if ((q = *lpp) == NULL) { - *lpp = p; - break; - } - } - } - return list; + sp = (struct strlist *)stalloc(sizeof *sp); + sp->text = sstrdup(name); + *exparg.lastp = sp; + exparg.lastp = &sp->next; } -#endif - /* * Returns true if the pattern matches the string. */ -#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) -/* squoted: string might have quote chars */ -static int patmatch(char *pattern, char *string, int squoted) -{ - const char *p; - char *q; - - p = preglob(pattern); - q = squoted ? _rmescapes(string, RMESCAPE_ALLOC) : string; - - return !fnmatch(p, q, 0); -} - - -static int patmatch2(char *pattern, char *string, int squoted) +static inline int +patmatch(char *pattern, const char *string) { - char *p; - int res; - - sstrnleft--; - p = grabstackstr(expdest); - res = patmatch(pattern, string, squoted); - ungrabstackstr(p, expdest); - return res; -} -#else -static int patmatch(char *pattern, char *string, int squoted) -{ - return pmatch(pattern, string, squoted); -} - - -static int pmatch(char *pattern, char *string, int squoted) -{ - char *p, *q; - char c; - - p = pattern; - q = string; - for (;;) { - switch (c = *p++) { - case '\0': - goto breakloop; - case CTLESC: - if (squoted && *q == CTLESC) - q++; - if (*q++ != *p++) - return 0; - break; - case CTLQUOTEMARK: - continue; - case '?': - if (squoted && *q == CTLESC) - q++; - if (*q++ == '\0') - return 0; - break; - case '*': - c = *p; - while (c == CTLQUOTEMARK || c == '*') - c = *++p; - if (c != CTLESC && c != CTLQUOTEMARK && - c != '?' && c != '*' && c != '[') { - while (*q != c) { - if (squoted && *q == CTLESC && q[1] == c) - break; - if (*q == '\0') - return 0; - if (squoted && *q == CTLESC) - q++; - q++; - } - } - do { - if (pmatch(p, q, squoted)) - return 1; - if (squoted && *q == CTLESC) - q++; - } while (*q++ != '\0'); - return 0; - case '[':{ - char *endp; - int invert, found; - char chr; - - endp = p; - if (*endp == '!') - endp++; - for (;;) { - while (*endp == CTLQUOTEMARK) - endp++; - if (*endp == '\0') - goto dft; /* no matching ] */ - if (*endp == CTLESC) - endp++; - if (*++endp == ']') - break; - } - invert = 0; - if (*p == '!') { - invert++; - p++; - } - found = 0; - chr = *q++; - if (squoted && chr == CTLESC) - chr = *q++; - if (chr == '\0') - return 0; - c = *p++; - do { - if (c == CTLQUOTEMARK) - continue; - if (c == CTLESC) - c = *p++; - if (*p == '-' && p[1] != ']') { - p++; - while (*p == CTLQUOTEMARK) - p++; - if (*p == CTLESC) - p++; - if (chr >= c && chr <= *p) - found = 1; - p++; - } else { - if (chr == c) - found = 1; - } - } while ((c = *p++) != ']'); - if (found == invert) - return 0; - break; - } - dft: default: - if (squoted && *q == CTLESC) - q++; - if (*q++ != c) - return 0; - break; - } - } - breakloop: - if (*q != '\0') - return 0; - return 1; + return pmatch(preglob(pattern, 0, 0), string); } -#endif - /* * Remove any CTLESC characters from a string. */ -#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) -static char *_rmescapes(char *str, int flag) +static char * +_rmescapes(char *str, int flag) { char *p, *q, *r; static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 }; + unsigned inquotes; + int notescaped; + int globbing; p = strpbrk(str, qchars); if (!p) { @@ -5483,52 +5684,52 @@ static char *_rmescapes(char *str, int flag) r = str; if (flag & RMESCAPE_ALLOC) { size_t len = p - str; + size_t fulllen = len + strlen(p) + 1; - q = r = stalloc(strlen(p) + len + 1); + if (flag & RMESCAPE_GROW) { + r = makestrspace(fulllen, expdest); + } else if (flag & RMESCAPE_HEAP) { + r = ckmalloc(fulllen); + } else { + r = stalloc(fulllen); + } + q = r; if (len > 0) { - memcpy(q, str, len); - q += len; + q = mempcpy(q, str, len); } } + inquotes = (flag & RMESCAPE_QUOTED) ^ RMESCAPE_QUOTED; + globbing = flag & RMESCAPE_GLOB; + notescaped = globbing; while (*p) { if (*p == CTLQUOTEMARK) { + inquotes = ~inquotes; p++; + notescaped = globbing; continue; } + if (*p == '\\') { + /* naked back slash */ + notescaped = 0; + goto copy; + } if (*p == CTLESC) { p++; - if (flag & RMESCAPE_GLOB && *p != '/') { + if (notescaped && inquotes && *p != '/') { *q++ = '\\'; } } + notescaped = globbing; +copy: *q++ = *p++; } *q = '\0'; - return r; -} -#else -static void rmescapes(char *str) -{ - char *p, *q; - - p = str; - while (*p != CTLESC && *p != CTLQUOTEMARK) { - if (*p++ == '\0') - return; + if (flag & RMESCAPE_GROW) { + expdest = r; + STADJUST(q - r + 1, expdest); } - q = p; - while (*p) { - if (*p == CTLQUOTEMARK) { - p++; - continue; - } - if (*p == CTLESC) - p++; - *q++ = *p++; - } - *q = '\0'; + return r; } -#endif @@ -5536,20 +5737,19 @@ static void rmescapes(char *str) * See if a pattern matches in a case statement. */ -static int casematch(union node *pattern, const char *val) +int +casematch(union node *pattern, char *val) { struct stackmark smark; int result; - char *p; setstackmark(&smark); argbackq = pattern->narg.backquote; STARTSTACKSTR(expdest); ifslastp = NULL; argstr(pattern->narg.text, EXP_TILDE | EXP_CASE); - STPUTC('\0', expdest); - p = grabstackstr(expdest); - result = patmatch(p, (char *) val, 0); + STACKSTRNUL(expdest); + result = patmatch(stackblock(), val); popstackmark(&smark); return result; } @@ -5558,141 +5758,101 @@ static int casematch(union node *pattern, const char *val) * Our own itoa(). */ -static char *cvtnum(int num, char *buf) +static int +cvtnum(long num) { int len; - CHECKSTRSPACE(32, buf); - len = sprintf(buf, "%d", num); - STADJUST(len, buf); - return buf; + expdest = makestrspace(32, expdest); + len = fmtstr(expdest, 32, "%ld", num); + STADJUST(len, expdest); + return len; } -/* - * Editline and history functions (and glue). - */ -static int histcmd(int argc, char **argv) +static void +varunset(const char *end, const char *var, const char *umsg, int varflags) { - error("not compiled with history support"); - /* NOTREACHED */ -} - - -struct redirtab { - struct redirtab *next; - short renamed[10]; /* Current ash support only 0-9 descriptors */ - /* char on arm (and others) can't be negative */ -}; + const char *msg; + const char *tail; -static struct redirtab *redirlist; - -extern char **environ; + tail = nullstr; + msg = "parameter not set"; + if (umsg) { + if (*end == CTLENDVAR) { + if (varflags & VSNUL) + tail = " or null"; + } else + msg = umsg; + } + error("%.*s: %s%s", end - var - 1, var, msg, tail); +} +/* $NetBSD: input.c,v 1.37 2002/11/24 22:35:40 christos Exp $ */ /* - * Initialization code. + * This file implements the input routines used by the parser. */ -static void init(void) -{ - - /* from cd.c: */ - { - curdir = nullstr; - setpwd(0, 0); - } - - /* from input.c: */ - { - basepf.nextc = basepf.buf = basebuf; - } - - /* from var.c: */ - { - char **envp; - char ppid[32]; - - initvar(); - for (envp = environ; *envp; envp++) { - if (strchr(*envp, '=')) { - setvareq(*envp, VEXPORT | VTEXTFIXED); - } - } - - snprintf(ppid, sizeof(ppid), "%d", (int) getppid()); - setvar("PPID", ppid, 0); - } -} - +#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */ +#define IBUFSIZ (BUFSIZ + 1) +static void pushfile(void); /* - * This routine is called when an error or an interrupt occurs in an - * interactive shell and control is returned to the main command loop. + * Read a line from the script. */ -/* 1 == check for aliases, 2 == also check for assignments */ -static int checkalias; /* also used in no alias mode for check assignments */ - -static void reset(void) +static inline char * +pfgets(char *line, int len) { + char *p = line; + int nleft = len; + int c; - /* from eval.c: */ - { - evalskip = 0; - loopnest = 0; - funcnest = 0; - } - - /* from input.c: */ - { - parselleft = parsenleft = 0; /* clear input buffer */ - popallfiles(); - } - - /* from parser.c: */ - { - tokpushback = 0; - checkkwd = 0; - checkalias = 0; - } - - /* from redir.c: */ - { - while (redirlist) - popredir(); + while (--nleft > 0) { + c = pgetc2(); + if (c == PEOF) { + if (p == line) + return NULL; + break; + } + *p++ = c; + if (c == '\n') + break; } - + *p = '\0'; + return line; } - /* - * This file implements the input routines used by the parser. + * Read a character from the script, returning PEOF on end of file. + * Nul characters in the input are silently discarded. */ -#ifdef CONFIG_FEATURE_COMMAND_EDITING -static const char *cmdedit_prompt; -static inline void putprompt(const char *s) +#define pgetc_as_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer()) + +#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE +#define pgetc_macro() pgetc() +static int +pgetc(void) { - cmdedit_prompt = s; + return pgetc_as_macro(); } #else -static inline void putprompt(const char *s) +#define pgetc_macro() pgetc_as_macro() +static int +pgetc(void) { - out2str(s); + return pgetc_macro(); } #endif -#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */ - - /* * Same as pgetc(), but ignores PEOA. */ - #ifdef CONFIG_ASH_ALIAS static int pgetc2(void) { @@ -5710,45 +5870,41 @@ static inline int pgetc2(void) } #endif -/* - * Read a line from the script. - */ -static inline char *pfgets(char *line, int len) +#ifdef CONFIG_FEATURE_COMMAND_EDITING +static const char *cmdedit_prompt; +static inline void putprompt(const char *s) { - char *p = line; - int nleft = len; - int c; - - while (--nleft > 0) { - c = pgetc2(); - if (c == PEOF) { - if (p == line) - return NULL; - break; - } - *p++ = c; - if (c == '\n') - break; - } - *p = '\0'; - return line; + cmdedit_prompt = s; +} +#else +static inline void putprompt(const char *s) +{ + out2str(s); } +#endif -static inline int preadfd(void) +static inline int +preadfd(void) { int nr; - char *buf = parsefile->buf; - + char *buf = parsefile->buf; parsenextc = buf; - retry: +retry: #ifdef CONFIG_FEATURE_COMMAND_EDITING - { - if (!iflag || parsefile->fd) - nr = safe_read(parsefile->fd, buf, BUFSIZ - 1); - else { - nr = cmdedit_read_input((char *) cmdedit_prompt, buf); + if (!iflag || parsefile->fd) + nr = safe_read(parsefile->fd, buf, BUFSIZ - 1); + else { + nr = cmdedit_read_input((char *) cmdedit_prompt, buf); + if(nr == 0) { + /* Ctrl+C presend */ + raise(SIGINT); + goto retry; + } + if(nr < 0) { + /* Ctrl+D presend */ + nr = 0; } } #else @@ -5758,9 +5914,8 @@ static inline int preadfd(void) if (nr < 0) { if (parsefile->fd == 0 && errno == EWOULDBLOCK) { int flags = fcntl(0, F_GETFL, 0); - if (flags >= 0 && flags & O_NONBLOCK) { - flags &= ~O_NONBLOCK; + flags &=~ O_NONBLOCK; if (fcntl(0, F_SETFL, flags) >= 0) { out2str("sh: turning off NDELAY mode\n"); goto retry; @@ -5771,38 +5926,6 @@ static inline int preadfd(void) return nr; } -static void popstring(void) -{ - struct strpush *sp = parsefile->strpush; - - INTOFF; -#ifdef CONFIG_ASH_ALIAS - if (sp->ap) { - if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') { - if (!checkalias) { - checkalias = 1; - } - } - if (sp->string != sp->ap->val) { - free(sp->string); - } - - sp->ap->flag &= ~ALIASINUSE; - if (sp->ap->flag & ALIASDEAD) { - unalias(sp->ap->name); - } - } -#endif - parsenextc = sp->prevstring; - parsenleft = sp->prevnleft; -/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/ - parsefile->strpush = sp->prev; - if (sp != &(parsefile->basestrpush)) - free(sp); - INTON; -} - - /* * Refill the input buffer and return the next input character: * @@ -5813,7 +5936,8 @@ static void popstring(void) * 4) Process input up to the next newline, deleting nul characters. */ -static int preadbuffer(void) +int +preadbuffer(void) { char *p, *q; int more; @@ -5834,7 +5958,7 @@ static int preadbuffer(void) return PEOF; flushall(); - again: +again: if (parselleft <= 0) { if ((parselleft = preadfd()) <= 0) { parselleft = parsenleft = EOF_NLEFT; @@ -5848,18 +5972,18 @@ static int preadbuffer(void) for (more = 1; more;) { switch (*p) { case '\0': - p++; /* Skip nul */ + p++; /* Skip nul */ goto check; - case '\n': parsenleft = q - parsenextc; - more = 0; /* Stop processing here */ + more = 0; /* Stop processing here */ break; + } *q++ = *p++; - check: +check: if (--parselleft <= 0 && more) { parsenleft = q - parsenextc - 1; if (parsenleft < 0) @@ -5873,6 +5997,7 @@ static int preadbuffer(void) if (vflag) { out2str(parsenextc); + flushout(stderr); } *q = savec; @@ -5880,19 +6005,33 @@ static int preadbuffer(void) return *parsenextc++; } +/* + * Undo the last call to pgetc. Only one character may be pushed back. + * PEOF may be pushed back. + */ + +void +pungetc(void) +{ + parsenleft++; + parsenextc--; +} /* * Push a string back onto the input at this current parsefile level. * We handle aliases this way. */ -static void pushstring(char *s, int len, void *ap) +void +pushstring(char *s, void *ap) { struct strpush *sp; + size_t len; + len = strlen(s); INTOFF; /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/ if (parsefile->strpush) { - sp = xmalloc(sizeof(struct strpush)); + sp = ckmalloc(sizeof (struct strpush)); sp->prev = parsefile->strpush; parsefile->strpush = sp; } else @@ -5900,9 +6039,9 @@ static void pushstring(char *s, int len, void *ap) sp->prevstring = parsenextc; sp->prevnleft = parsenleft; #ifdef CONFIG_ASH_ALIAS - sp->ap = (struct alias *) ap; + sp->ap = (struct alias *)ap; if (ap) { - ((struct alias *) ap)->flag |= ALIASINUSE; + ((struct alias *)ap)->flag |= ALIASINUSE; sp->string = s; } #endif @@ -5911,12 +6050,88 @@ static void pushstring(char *s, int len, void *ap) INTON; } +void +popstring(void) +{ + struct strpush *sp = parsefile->strpush; + + INTOFF; +#ifdef CONFIG_ASH_ALIAS + if (sp->ap) { + if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') { + checkkwd |= CHKALIAS; + } + if (sp->string != sp->ap->val) { + ckfree(sp->string); + } + sp->ap->flag &= ~ALIASINUSE; + if (sp->ap->flag & ALIASDEAD) { + unalias(sp->ap->name); + } + } +#endif + parsenextc = sp->prevstring; + parsenleft = sp->prevnleft; +/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/ + parsefile->strpush = sp->prev; + if (sp != &(parsefile->basestrpush)) + ckfree(sp); + INTON; +} + +/* + * Set the input to take input from a file. If push is set, push the + * old input onto the stack first. + */ + +void +setinputfile(const char *fname, int push) +{ + int fd; + int fd2; + + INTOFF; + if ((fd = open(fname, O_RDONLY)) < 0) + error("Can't open %s", fname); + if (fd < 10) { + fd2 = copyfd(fd, 10); + close(fd); + if (fd2 < 0) + error("Out of file descriptors"); + fd = fd2; + } + setinputfd(fd, push); + INTON; +} + + +/* + * Like setinputfile, but takes an open file descriptor. Call this with + * interrupts off. + */ + +static void +setinputfd(int fd, int push) +{ + (void) fcntl(fd, F_SETFD, FD_CLOEXEC); + if (push) { + pushfile(); + parsefile->buf = 0; + } + parsefile->fd = fd; + if (parsefile->buf == NULL) + parsefile->buf = ckmalloc(IBUFSIZ); + parselleft = parsenleft = 0; + plinno = 1; +} + /* * Like setinputfile, but takes input from a string. */ -static void setinputstring(char *string) +static void +setinputstring(char *string) { INTOFF; pushfile(); @@ -5934,7 +6149,8 @@ static void setinputstring(char *string) * adds a new entry to the stack and popfile restores the previous level. */ -static void pushfile(void) +static void +pushfile(void) { struct parsefile *pf; @@ -5942,7 +6158,7 @@ static void pushfile(void) parsefile->lleft = parselleft; parsefile->nextc = parsenextc; parsefile->linno = plinno; - pf = (struct parsefile *) xmalloc(sizeof(struct parsefile)); + pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile)); pf->prev = parsefile; pf->fd = -1; pf->strpush = NULL; @@ -5950,75 +6166,221 @@ static void pushfile(void) parsefile = pf; } -#ifdef CONFIG_ASH_JOB_CONTROL -static void restartjob(struct job *); -#endif -static void freejob(struct job *); -static struct job *getjob(const char *); -static int dowait(int, struct job *); + +static void +popfile(void) +{ + struct parsefile *pf = parsefile; + + INTOFF; + if (pf->fd >= 0) + close(pf->fd); + if (pf->buf) + ckfree(pf->buf); + while (pf->strpush) + popstring(); + parsefile = pf->prev; + ckfree(pf); + parsenleft = parsefile->nleft; + parselleft = parsefile->lleft; + parsenextc = parsefile->nextc; + plinno = parsefile->linno; + INTON; +} /* - * We keep track of whether or not fd0 has been redirected. This is for - * background commands, where we want to redirect fd0 to /dev/null only - * if it hasn't already been redirected. -*/ -static int fd0_redirected = 0; + * Return to top level. + */ -/* Return true if fd 0 has already been redirected at least once. */ -static inline int fd0_redirected_p(void) +static void +popallfiles(void) { - return fd0_redirected != 0; + while (parsefile != &basepf) + popfile(); } -static void dupredirect(const union node *, int, int fd1dup); -#ifdef CONFIG_ASH_JOB_CONTROL + +/* + * Close the file(s) that the shell is reading commands from. Called + * after a fork is done. + */ + +static void +closescript(void) +{ + popallfiles(); + if (parsefile->fd > 0) { + close(parsefile->fd); + parsefile->fd = 0; + } +} +/* $NetBSD: jobs.c,v 1.56 2002/11/25 12:13:03 agc Exp $ */ + + +/* mode flags for set_curjob */ +#define CUR_DELETE 2 +#define CUR_RUNNING 1 +#define CUR_STOPPED 0 + +/* mode flags for dowait */ +#define DOWAIT_NORMAL 0 +#define DOWAIT_BLOCK 1 + +/* array of jobs */ +static struct job *jobtab; +/* size of array */ +static unsigned njobs; +#if JOBS +/* pgrp of shell on invocation */ +static int initialpgrp; +static int ttyfd = -1; +#endif +/* current job */ +static struct job *curjob; +/* number of presumed living untracked jobs */ +static int jobless; + +static void set_curjob(struct job *, unsigned); +#if JOBS +static int restartjob(struct job *, int); +static void xtcsetpgrp(int, pid_t); +static char *commandtext(union node *); +static void cmdlist(union node *, int); +static void cmdtxt(union node *); +static void cmdputs(const char *); +static void showpipe(struct job *, FILE *); +#endif +static int sprint_status(char *, int, int); +static void freejob(struct job *); +static struct job *getjob(const char *, int); +static struct job *growjobtab(void); +static void forkchild(struct job *, union node *, int); +static void forkparent(struct job *, union node *, int, pid_t); +static int dowait(int, struct job *); +static int getstatus(struct job *); + +static void +set_curjob(struct job *jp, unsigned mode) +{ + struct job *jp1; + struct job **jpp, **curp; + + /* first remove from list */ + jpp = curp = &curjob; + do { + jp1 = *jpp; + if (jp1 == jp) + break; + jpp = &jp1->prev_job; + } while (1); + *jpp = jp1->prev_job; + + /* Then re-insert in correct position */ + jpp = curp; + switch (mode) { + default: +#ifdef DEBUG + abort(); +#endif + case CUR_DELETE: + /* job being deleted */ + break; + case CUR_RUNNING: + /* newly created job or backgrounded job, + put after all stopped jobs. */ + do { + jp1 = *jpp; +#ifdef JOBS + if (!jp1 || jp1->state != JOBSTOPPED) +#endif + break; + jpp = &jp1->prev_job; + } while (1); + /* FALLTHROUGH */ +#ifdef JOBS + case CUR_STOPPED: +#endif + /* newly stopped job - becomes curjob */ + jp->prev_job = *jpp; + *jpp = jp; + break; + } +} + +#if JOBS /* * Turn job control on and off. * * Note: This code assumes that the third arg to ioctl is a character * pointer, which is true on Berkeley systems but not System V. Since * System V doesn't have job control yet, this isn't a problem now. + * + * Called with interrupts off. */ - - -static void setjobctl(int enable) +void +setjobctl(int on) { - if (enable == jobctl || rootshell == 0) + int fd; + int pgrp; + + if (on == jobctl || rootshell == 0) return; - if (enable) { - do { /* while we are in the background */ - initialpgrp = tcgetpgrp(2); - if (initialpgrp < 0) { - out2str("sh: can't access tty; job control turned off\n"); - mflag = 0; - return; + if (on) { + int ofd; + ofd = fd = open(_PATH_TTY, O_RDWR); + if (fd < 0) { + fd += 3; + while (!isatty(fd) && --fd >= 0) + ; + } + fd = fcntl(fd, F_DUPFD, 10); + close(ofd); + if (fd < 0) + goto out; + fcntl(fd, F_SETFD, FD_CLOEXEC); + do { /* while we are in the background */ + if ((pgrp = tcgetpgrp(fd)) < 0) { +out: + sh_warnx("can't access tty; job control turned off"); + mflag = on = 0; + goto close; } - if (initialpgrp == getpgrp()) + if (pgrp == getpgrp()) break; killpg(0, SIGTTIN); } while (1); + initialpgrp = pgrp; + setsignal(SIGTSTP); setsignal(SIGTTOU); setsignal(SIGTTIN); - setpgid(0, rootpid); - tcsetpgrp(2, rootpid); - } else { /* turning job control off */ - setpgid(0, initialpgrp); - tcsetpgrp(2, initialpgrp); + pgrp = rootpid; + setpgid(0, pgrp); + xtcsetpgrp(fd, pgrp); + } else { + /* turning job control off */ + fd = ttyfd; + pgrp = initialpgrp; + xtcsetpgrp(fd, pgrp); + setpgid(0, pgrp); setsignal(SIGTSTP); setsignal(SIGTTOU); setsignal(SIGTTIN); +close: + close(fd); + fd = -1; } - jobctl = enable; + ttyfd = fd; + jobctl = on; } -#endif - -#ifdef CONFIG_ASH_JOB_CONTROL -static int killcmd(int argc, char **argv) +static int +killcmd(argc, argv) + int argc; + char **argv; { int signo = -1; int list = 0; @@ -6027,135 +6389,283 @@ static int killcmd(int argc, char **argv) struct job *jp; if (argc <= 1) { - usage: - error - ("Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n" - "kill -l [exitstatus]"); +usage: + error( +"Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n" +"kill -l [exitstatus]" + ); } - if (*argv[1] == '-') { - signo = decode_signal(argv[1] + 1, 1); + if (**++argv == '-') { + signo = decode_signal(*argv + 1, 1); if (signo < 0) { int c; while ((c = nextopt("ls:")) != '\0') switch (c) { + default: +#ifdef DEBUG + abort(); +#endif case 'l': list = 1; break; case 's': signo = decode_signal(optionarg, 1); if (signo < 0) { - error("invalid signal number or name: %s", optionarg); + error( + "invalid signal number or name: %s", + optionarg + ); } break; -#ifdef DEBUG - default: - error("nextopt returned character code 0%o", c); -#endif } + argv = argptr; } else - argptr++; + argv++; } if (!list && signo < 0) signo = SIGTERM; - if ((signo < 0 || !*argptr) ^ list) { + if ((signo < 0 || !*argv) ^ list) { goto usage; } if (list) { const char *name; - if (!*argptr) { - out1str("0\n"); + if (!*argv) { for (i = 1; i < NSIG; i++) { name = u_signal_names(0, &i, 1); if (name) - puts(name); + out1fmt(snlfmt, name); } return 0; } name = u_signal_names(*argptr, &signo, -1); if (name) - puts(name); + out1fmt(snlfmt, name); else error("invalid signal number or exit status: %s", *argptr); return 0; } + i = 0; do { - if (**argptr == '%') { - jp = getjob(*argptr); - if (jp->jobctl == 0) - error("job %s not created under job control", *argptr); + if (**argv == '%') { + jp = getjob(*argv, 0); pid = -jp->ps[0].pid; } else - pid = atoi(*argptr); - if (kill(pid, signo) != 0) - error("%s: %m", *argptr); - } while (*++argptr); + pid = number(*argv); + if (kill(pid, signo) != 0) { + sh_warnx("%m\n"); + i = 1; + } + } while (*++argv); - return 0; + return i; } +#endif /* JOBS */ -static int fgcmd(int argc, char **argv) +#if defined(JOBS) || defined(DEBUG) +static int +jobno(const struct job *jp) { - struct job *jp; - int pgrp; - int status; - - jp = getjob(argv[1]); - if (jp->jobctl == 0) - error("job not created under job control"); - pgrp = jp->ps[0].pid; - ioctl(2, TIOCSPGRP, (char *) &pgrp); - restartjob(jp); - status = waitforjob(jp); - return status; + return jp - jobtab + 1; } +#endif - -static int bgcmd(int argc, char **argv) +#ifdef JOBS +static int +fgcmd(int argc, char **argv) { struct job *jp; + FILE *out; + int mode; + int retval; + mode = (**argv == 'f') ? FORK_FG : FORK_BG; + nextopt(nullstr); + argv = argptr; + out = stdout; do { - jp = getjob(*++argv); - if (jp->jobctl == 0) - error("job not created under job control"); - restartjob(jp); - } while (--argc > 1); - return 0; + jp = getjob(*argv, 1); + if (mode == FORK_BG) { + set_curjob(jp, CUR_RUNNING); + fprintf(out, "[%d] ", jobno(jp)); + } + outstr(jp->ps->cmd, out); + showpipe(jp, out); + retval = restartjob(jp, mode); + } while (*argv && *++argv); + return retval; } +static int bgcmd(int, char **) __attribute__((__alias__("fgcmd"))); + -static void restartjob(struct job *jp) +static int +restartjob(struct job *jp, int mode) { struct procstat *ps; int i; + int status; + pid_t pgid; - if (jp->state == JOBDONE) - return; INTOFF; - killpg(jp->ps[0].pid, SIGCONT); - for (ps = jp->ps, i = jp->nprocs; --i >= 0; ps++) { + if (jp->state == JOBDONE) + goto out; + jp->state = JOBRUNNING; + pgid = jp->ps->pid; + if (mode == FORK_FG) + xtcsetpgrp(ttyfd, pgid); + killpg(pgid, SIGCONT); + ps = jp->ps; + i = jp->nprocs; + do { if (WIFSTOPPED(ps->status)) { ps->status = -1; - jp->state = 0; } - } + } while (ps++, --i); +out: + status = (mode == FORK_FG) ? waitforjob(jp) : 0; INTON; + return status; } #endif -static void showjobs(int change); +static int +sprint_status(char *s, int status, int sigonly) +{ + int col; + int st; + col = 0; + st = WEXITSTATUS(status); + if (!WIFEXITED(status)) { + st = WSTOPSIG(status); +#if JOBS + if (!WIFSTOPPED(status)) + st = WTERMSIG(status); +#endif + if (sigonly) { + if (st == SIGINT || st == SIGPIPE) + goto out; + if (WIFSTOPPED(status)) + goto out; + } + st &= 0x7f; + col = fmtstr(s, 32, u_signal_names(NULL, &st, 0)); + if (WCOREDUMP(status)) { + col += fmtstr(s + col, 16, " (core dumped)"); + } + } else if (!sigonly) { + if (st) + col = fmtstr(s, 16, "Done(%d)", st); + else + col = fmtstr(s, 16, "Done"); + } -static int jobscmd(int argc, char **argv) +out: + return col; +} + +#if JOBS +static void +showjob(FILE *out, struct job *jp, int mode) { - showjobs(0); + struct procstat *ps; + struct procstat *psend; + int col; + int indent; + char s[80]; + + ps = jp->ps; + + if (mode & SHOW_PGID) { + /* just output process (group) id of pipeline */ + fprintf(out, "%d\n", ps->pid); + return; + } + + col = fmtstr(s, 16, "[%d] ", jobno(jp)); + indent = col; + + if (jp == curjob) + s[col - 2] = '+'; + else if (curjob && jp == curjob->prev_job) + s[col - 2] = '-'; + + if (mode & SHOW_PID) + col += fmtstr(s + col, 16, "%d ", ps->pid); + + psend = ps + jp->nprocs; + + if (jp->state == JOBRUNNING) { + scopy("Running", s + col); + col += strlen("Running"); + } else { + int status = psend[-1].status; +#if JOBS + if (jp->state == JOBSTOPPED) + status = jp->stopstatus; +#endif + col += sprint_status(s + col, status, 0); + } + + goto start; + + do { + /* for each process */ + col = fmtstr(s, 48, " |\n%*c%d ", indent, ' ', ps->pid) - 3; + +start: + fprintf( + out, "%s%*c%s", + s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd + ); + if (!(mode & SHOW_PID)) { + showpipe(jp, out); + break; + } + if (++ps == psend) { + outcslow('\n', out); + break; + } + } while (1); + + jp->changed = 0; + + if (jp->state == JOBDONE) { + TRACE(("showjob: freeing job %d\n", jobno(jp))); + freejob(jp); + } +} + + +static int +jobscmd(int argc, char **argv) +{ + int mode, m; + FILE *out; + + mode = 0; + while ((m = nextopt("lp"))) + if (m == 'l') + mode = SHOW_PID; + else + mode = SHOW_PGID; + + out = stdout; + argv = argptr; + if (*argv) + do + showjob(out, getjob(*argv,0), mode); + while (*++argv); + else + showjobs(out, mode); + return 0; } @@ -6163,146 +6673,107 @@ static int jobscmd(int argc, char **argv) /* * Print a list of jobs. If "change" is nonzero, only print jobs whose * statuses have changed since the last call to showjobs. - * - * If the shell is interrupted in the process of creating a job, the - * result may be a job structure containing zero processes. Such structures - * will be freed here. */ -static void showjobs(int change) +static void +showjobs(FILE *out, int mode) { - int jobno; - int procno; - int i; struct job *jp; - struct procstat *ps; - int col; - char s[64]; - TRACE(("showjobs(%d) called\n", change)); - while (dowait(0, (struct job *) NULL) > 0); - for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) { - if (!jp->used) - continue; - if (jp->nprocs == 0) { - freejob(jp); - continue; - } - if (change && !jp->changed) - continue; - procno = jp->nprocs; - for (ps = jp->ps;; ps++) { /* for each process */ - if (ps == jp->ps) - snprintf(s, 64, "[%d] %ld ", jobno, (long) ps->pid); - else - snprintf(s, 64, " %ld ", (long) ps->pid); - out1str(s); - col = strlen(s); - s[0] = '\0'; - if (ps->status == -1) { - /* don't print anything */ - } else if (WIFEXITED(ps->status)) { - snprintf(s, 64, "Exit %d", WEXITSTATUS(ps->status)); - } else { -#ifdef CONFIG_ASH_JOB_CONTROL - if (WIFSTOPPED(ps->status)) - i = WSTOPSIG(ps->status); - else /* WIFSIGNALED(ps->status) */ -#endif - i = WTERMSIG(ps->status); - if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F]) - strcpy(s, sys_siglist[i & 0x7F]); - else - snprintf(s, 64, "Signal %d", i & 0x7F); - if (WCOREDUMP(ps->status)) - strcat(s, " (core dumped)"); - } - out1str(s); - col += strlen(s); - printf("%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ', ps->cmd); - if (--procno <= 0) - break; - } - jp->changed = 0; - if (jp->state == JOBDONE) { - freejob(jp); - } + TRACE(("showjobs(%x) called\n", mode)); + + /* If not even one one job changed, there is nothing to do */ + while (dowait(DOWAIT_NORMAL, NULL) > 0) + continue; + + for (jp = curjob; jp; jp = jp->prev_job) { + if (!(mode & SHOW_CHANGED) || jp->changed) + showjob(out, jp, mode); } } - +#endif /* JOBS */ /* * Mark a job structure as unused. */ -static void freejob(struct job *jp) +static void +freejob(struct job *jp) { - const struct procstat *ps; + struct procstat *ps; int i; INTOFF; - for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) { + for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) { if (ps->cmd != nullstr) - free(ps->cmd); + ckfree(ps->cmd); } if (jp->ps != &jp->ps0) - free(jp->ps); + ckfree(jp->ps); jp->used = 0; -#ifdef CONFIG_ASH_JOB_CONTROL - if (curjob == jp - jobtab + 1) - curjob = 0; -#endif + set_curjob(jp, CUR_DELETE); INTON; } - -static int waitcmd(int argc, char **argv) +static int +waitcmd(int argc, char **argv) { struct job *job; - int status, retval; + int retval; struct job *jp; - if (--argc > 0) { - start: - job = getjob(*++argv); - } else { - job = NULL; - } - for (;;) { /* loop until process terminated or stopped */ - if (job != NULL) { - if (job->state) { - status = job->ps[job->nprocs - 1].status; - if (!iflag) - freejob(job); - if (--argc) { - goto start; - } - if (WIFEXITED(status)) - retval = WEXITSTATUS(status); -#ifdef CONFIG_ASH_JOB_CONTROL - else if (WIFSTOPPED(status)) - retval = WSTOPSIG(status) + 128; -#endif - else { - /* XXX: limits number of signals */ - retval = WTERMSIG(status) + 128; - } - return retval; - } - } else { - for (jp = jobtab;; jp++) { - if (jp >= jobtab + njobs) { /* no running procs */ - return 0; + EXSIGON(); + + nextopt(nullstr); + retval = 0; + + argv = argptr; + if (!*argv) { + /* wait for all jobs */ + for (;;) { + jp = curjob; + while (1) { + if (!jp) { + /* no running procs */ + goto out; } - if (jp->used && jp->state == 0) + if (jp->state == JOBRUNNING) break; + jp->waited = 1; + jp = jp->prev_job; } - } - if (dowait(2, 0) < 0 && errno == EINTR) { - return 129; + dowait(DOWAIT_BLOCK, 0); } } + + retval = 127; + do { + if (**argv != '%') { + pid_t pid = number(*argv); + job = curjob; + goto start; + do { + if (job->ps[job->nprocs - 1].pid == pid) + break; + job = job->prev_job; +start: + if (!job) + goto repeat; + } while (1); + } else + job = getjob(*argv, 0); + /* loop until process terminated or stopped */ + while (job->state == JOBRUNNING) + dowait(DOWAIT_BLOCK, 0); + job->waited = 1; + retval = getstatus(job); +repeat: + ; + } while (*++argv); + +out: + return retval; } @@ -6311,112 +6782,177 @@ static int waitcmd(int argc, char **argv) * Convert a job name to a job structure. */ -static struct job *getjob(const char *name) +static struct job * +getjob(const char *name, int getctl) { - int jobno; struct job *jp; - int pid; - int i; + struct job *found; + const char *err_msg = "No such job: %s"; + unsigned num; + int c; + const char *p; + char *(*match)(const char *, const char *); - if (name == NULL) { -#ifdef CONFIG_ASH_JOB_CONTROL - currentjob: - if ((jobno = curjob) == 0 || jobtab[jobno - 1].used == 0) - error("No current job"); - return &jobtab[jobno - 1]; -#else - error("No current job"); -#endif - } else if (name[0] == '%') { - if (is_digit(name[1])) { - jobno = number(name + 1); - if (jobno > 0 && jobno <= njobs && jobtab[jobno - 1].used != 0) - return &jobtab[jobno - 1]; -#ifdef CONFIG_ASH_JOB_CONTROL - } else if (name[1] == '%' && name[2] == '\0') { - goto currentjob; -#endif - } else { - struct job *found = NULL; - - for (jp = jobtab, i = njobs; --i >= 0; jp++) { - if (jp->used && jp->nprocs > 0 - && prefix(name + 1, jp->ps[0].cmd)) { - if (found) - error("%s: ambiguous", name); - found = jp; - } - } - if (found) - return found; + jp = curjob; + p = name; + if (!p) + goto currentjob; + + if (*p != '%') + goto err; + + c = *++p; + if (!c) + goto currentjob; + + if (!p[1]) { + if (c == '+' || c == '%') { +currentjob: + err_msg = "No current job"; + goto check; + } else if (c == '-') { + if (jp) + jp = jp->prev_job; + err_msg = "No previous job"; +check: + if (!jp) + goto err; + goto gotit; } - } else if (is_number(name, &pid)) { - for (jp = jobtab, i = njobs; --i >= 0; jp++) { - if (jp->used && jp->nprocs > 0 - && jp->ps[jp->nprocs - 1].pid == pid) - return jp; + } + + if (is_number(p)) { + num = atoi(p); + if (num < njobs) { + jp = jobtab + num - 1; + if (jp->used) + goto gotit; + goto err; } } - error("No such job: %s", name); - /* NOTREACHED */ + + match = prefix; + if (*p == '?') { + match = strstr; + p++; + } + + found = 0; + while (1) { + if (!jp) + goto err; + if (match(jp->ps[0].cmd, p)) { + if (found) + goto err; + found = jp; + err_msg = "%s: ambiguous"; + } + jp = jp->prev_job; + } + +gotit: +#if JOBS + err_msg = "job %s not created under job control"; + if (getctl && jp->jobctl == 0) + goto err; +#endif + return jp; +err: + error(err_msg, name); } /* - * Return a new job structure, + * Return a new job structure. + * Called with interrupts off. */ -static struct job *makejob(const union node *node, int nprocs) +static struct job * +makejob(union node *node, int nprocs) { int i; struct job *jp; - for (i = njobs, jp = jobtab;; jp++) { + for (i = njobs, jp = jobtab ; ; jp++) { if (--i < 0) { - INTOFF; - if (njobs == 0) { - jobtab = xmalloc(4 * sizeof jobtab[0]); - } else { - jp = xmalloc((njobs + 4) * sizeof jobtab[0]); - memcpy(jp, jobtab, njobs * sizeof jp[0]); - /* Relocate `ps' pointers */ - for (i = 0; i < njobs; i++) - if (jp[i].ps == &jobtab[i].ps0) - jp[i].ps = &jp[i].ps0; - free(jobtab); - jobtab = jp; - } - jp = jobtab + njobs; - for (i = 4; --i >= 0; jobtab[njobs++].used = 0); - INTON; + jp = growjobtab(); break; } if (jp->used == 0) break; + if (jp->state != JOBDONE || !jp->waited) + continue; +#if JOBS + if (jobctl) + continue; +#endif + freejob(jp); + break; } - INTOFF; - jp->state = 0; - jp->used = 1; - jp->changed = 0; - jp->nprocs = 0; -#ifdef CONFIG_ASH_JOB_CONTROL - jp->jobctl = jobctl; + memset(jp, 0, sizeof(*jp)); +#if JOBS + if (jobctl) + jp->jobctl = 1; #endif + jp->prev_job = curjob; + curjob = jp; + jp->used = 1; + jp->ps = &jp->ps0; if (nprocs > 1) { - jp->ps = xmalloc(nprocs * sizeof(struct procstat)); - } else { - jp->ps = &jp->ps0; + jp->ps = ckmalloc(nprocs * sizeof (struct procstat)); } - INTON; - TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long) node, nprocs, - jp - jobtab + 1)); + TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs, + jobno(jp))); + return jp; +} + +static struct job * +growjobtab(void) +{ + size_t len; + ptrdiff_t offset; + struct job *jp, *jq; + + len = njobs * sizeof(*jp); + jq = jobtab; + jp = ckrealloc(jq, len + 4 * sizeof(*jp)); + + offset = (char *)jp - (char *)jq; + if (offset) { + /* Relocate pointers */ + size_t l = len; + + jq = (struct job *)((char *)jq + l); + while (l) { + l -= sizeof(*jp); + jq--; +#define joff(p) ((struct job *)((char *)(p) + l)) +#define jmove(p) (p) = (void *)((char *)(p) + offset) + if (likely(joff(jp)->ps == &jq->ps0)) + jmove(joff(jp)->ps); + if (joff(jp)->prev_job) + jmove(joff(jp)->prev_job); + } + if (curjob) + jmove(curjob); +#undef joff +#undef jmove + } + + njobs += 4; + jobtab = jp; + jp = (struct job *)((char *)jp + len); + jq = jp + 3; + do { + jq->used = 0; + } while (--jq >= jp); return jp; } /* - * Fork of a subshell. If we are doing job control, give the subshell its + * Fork off a subshell. If we are doing job control, give the subshell its * own process group. Jp is a job structure that the job is to be added to. * N is the command that will be evaluated by the child. Both jp and n may * be NULL. The mode parameter can be one of the following: @@ -6428,103 +6964,114 @@ static struct job *makejob(const union node *node, int nprocs) * When job control is turned off, background processes have their standard * input redirected to /dev/null (except for the second and later processes * in a pipeline). + * + * Called with interrupts off. */ - - -static int forkshell(struct job *jp, const union node *n, int mode) +static inline void +forkchild(struct job *jp, union node *n, int mode) { - int pid; + int wasroot; -#ifdef CONFIG_ASH_JOB_CONTROL - int pgrp; -#endif - const char *devnull = _PATH_DEVNULL; - const char *nullerr = "Can't open %s"; + TRACE(("Child shell %d\n", getpid())); + wasroot = rootshell; + rootshell = 0; - TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long) n, - mode)); - INTOFF; - pid = fork(); - if (pid == -1) { - TRACE(("Fork failed, errno=%d\n", errno)); - INTON; - error("Cannot fork"); - } - if (pid == 0) { - struct job *p; - int wasroot; - int i; + closescript(); + clear_traps(); +#if JOBS + /* do job control only in root shell */ + jobctl = 0; + if (mode != FORK_NOJOB && jp->jobctl && wasroot) { + pid_t pgrp; - TRACE(("Child shell %d\n", getpid())); - wasroot = rootshell; - rootshell = 0; - closescript(); - INTON; - clear_traps(); -#ifdef CONFIG_ASH_JOB_CONTROL - jobctl = 0; /* do job control only in root shell */ - if (wasroot && mode != FORK_NOJOB && mflag) { - if (jp == NULL || jp->nprocs == 0) - pgrp = getpid(); - else - pgrp = jp->ps[0].pid; - setpgid(0, pgrp); - if (mode == FORK_FG) { - /*** this causes superfluous TIOCSPGRPS ***/ - if (tcsetpgrp(2, pgrp) < 0) - error("tcsetpgrp failed, errno=%d", errno); - } - setsignal(SIGTSTP); - setsignal(SIGTTOU); - } else if (mode == FORK_BG) { -#else - if (mode == FORK_BG) { + if (jp->nprocs == 0) + pgrp = getpid(); + else + pgrp = jp->ps[0].pid; + /* This can fail because we are doing it in the parent also */ + (void)setpgid(0, pgrp); + if (mode == FORK_FG) + xtcsetpgrp(ttyfd, pgrp); + setsignal(SIGTSTP); + setsignal(SIGTTOU); + } else #endif - ignoresig(SIGINT); - ignoresig(SIGQUIT); - if ((jp == NULL || jp->nprocs == 0) && !fd0_redirected_p()) { - close(0); - if (open(devnull, O_RDONLY) != 0) - error(nullerr, devnull); - } - } - for (i = njobs, p = jobtab; --i >= 0; p++) - if (p->used) - freejob(p); - if (wasroot && iflag) { - setsignal(SIGINT); - setsignal(SIGQUIT); - setsignal(SIGTERM); + if (mode == FORK_BG) { + ignoresig(SIGINT); + ignoresig(SIGQUIT); + if (jp->nprocs == 0) { + close(0); + if (open(_PATH_DEVNULL, O_RDONLY) != 0) + error("Can't open %s", _PATH_DEVNULL); } - return pid; } -#ifdef CONFIG_ASH_JOB_CONTROL - if (rootshell && mode != FORK_NOJOB && mflag) { - if (jp == NULL || jp->nprocs == 0) + if (wasroot && iflag) { + setsignal(SIGINT); + setsignal(SIGQUIT); + setsignal(SIGTERM); + } + for (jp = curjob; jp; jp = jp->prev_job) + freejob(jp); + jobless = 0; +} + +static inline void +forkparent(struct job *jp, union node *n, int mode, pid_t pid) +{ + TRACE(("In parent shell: child = %d\n", pid)); + if (!jp) { + while (jobless && dowait(DOWAIT_NORMAL, 0) > 0); + jobless++; + return; + } +#if JOBS + if (mode != FORK_NOJOB && jp->jobctl) { + int pgrp; + + if (jp->nprocs == 0) pgrp = pid; else pgrp = jp->ps[0].pid; - setpgid(pid, pgrp); + /* This can fail because we are doing it in the child also */ + (void)setpgid(pid, pgrp); } #endif - if (mode == FORK_BG) - backgndpid = pid; /* set $! */ + if (mode == FORK_BG) { + backgndpid = pid; /* set $! */ + set_curjob(jp, CUR_RUNNING); + } if (jp) { struct procstat *ps = &jp->ps[jp->nprocs++]; - ps->pid = pid; ps->status = -1; ps->cmd = nullstr; - if (iflag && rootshell && n) +#if JOBS + if (jobctl && n) ps->cmd = commandtext(n); +#endif } - INTON; - TRACE(("In parent shell: child = %d\n", pid)); - return pid; } +static int +forkshell(struct job *jp, union node *n, int mode) +{ + int pid; + TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode)); + pid = fork(); + if (pid < 0) { + TRACE(("Fork failed, errno=%d", errno)); + if (jp) + freejob(jp); + error("Cannot fork"); + } + if (pid == 0) + forkchild(jp, n, mode); + else + forkparent(jp, n, mode, pid); + return pid; +} /* * Wait for job to finish. @@ -6543,65 +7090,41 @@ static int forkshell(struct job *jp, const union node *n, int mode) * exit on interrupt; unless these processes terminate themselves by * sending a signal to themselves (instead of calling exit) they will * confuse this approach. + * + * Called with interrupts off. */ -static int waitforjob(struct job *jp) +int +waitforjob(struct job *jp) { -#ifdef CONFIG_ASH_JOB_CONTROL - int mypgrp = getpgrp(); -#endif - int status; int st; - INTOFF; - TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1)); - while (jp->state == 0) { - dowait(1, jp); + TRACE(("waitforjob(%%%d) called\n", jobno(jp))); + while (jp->state == JOBRUNNING) { + dowait(DOWAIT_BLOCK, jp); } -#ifdef CONFIG_ASH_JOB_CONTROL - if (jp->jobctl) { - if (tcsetpgrp(2, mypgrp) < 0) - error("tcsetpgrp failed, errno=%d\n", errno); - } - if (jp->state == JOBSTOPPED) - curjob = jp - jobtab + 1; -#endif - status = jp->ps[jp->nprocs - 1].status; - /* convert to 8 bits */ - if (WIFEXITED(status)) - st = WEXITSTATUS(status); -#ifdef CONFIG_ASH_JOB_CONTROL - else if (WIFSTOPPED(status)) - st = WSTOPSIG(status) + 128; -#endif - else - st = WTERMSIG(status) + 128; -#ifdef CONFIG_ASH_JOB_CONTROL + st = getstatus(jp); +#if JOBS if (jp->jobctl) { + xtcsetpgrp(ttyfd, rootpid); /* * This is truly gross. * If we're doing job control, then we did a TIOCSPGRP which * caused us (the shell) to no longer be in the controlling * session -- so we wouldn't have seen any ^C/SIGINT. So, we * intuit from the subprocess exit status whether a SIGINT - * occured, and if so interrupt ourselves. Yuck. - mycroft + * occurred, and if so interrupt ourselves. Yuck. - mycroft */ - if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT) + if (jp->sigint) raise(SIGINT); } if (jp->state == JOBDONE) #endif freejob(jp); - INTON; return st; } - -/* - * Wait for a process to terminate. - */ - /* * Do a wait system call. If job control is compiled in, we accept * stopped processes. If block is zero, we return a value of zero @@ -6624,635 +7147,554 @@ static int waitforjob(struct job *jp) * then checking to see whether it was called. If there are any * children to be waited for, it will be. * + * If neither SYSV nor BSD is defined, we don't implement nonblocking + * waits at all. In this case, the user will not be informed when + * a background process until the next time she runs a real program + * (as opposed to running a builtin command or just typing return), + * and the jobs command may give out of date information. */ -static inline int waitproc(int block, int *status) +static inline int +waitproc(int block, int *status) { - int flags; + int flags = 0; - flags = 0; -#ifdef CONFIG_ASH_JOB_CONTROL +#if JOBS if (jobctl) flags |= WUNTRACED; #endif if (block == 0) flags |= WNOHANG; - return wait3(status, flags, (struct rusage *) NULL); + return wait3(status, flags, (struct rusage *)NULL); } -static int dowait(int block, struct job *job) +/* + * Wait for a process to terminate. + */ + +static int +dowait(int block, struct job *job) { int pid; int status; - struct procstat *sp; struct job *jp; struct job *thisjob; - int done; - int stopped; - int core; - int sig; + int state; TRACE(("dowait(%d) called\n", block)); - do { - pid = waitproc(block, &status); - TRACE(("wait returns %d, status=%d\n", pid, status)); - } while (!(block & 2) && pid == -1 && errno == EINTR); + pid = waitproc(block, &status); + TRACE(("wait returns pid %d, status=%d\n", pid, status)); if (pid <= 0) return pid; INTOFF; thisjob = NULL; - for (jp = jobtab; jp < jobtab + njobs; jp++) { - if (jp->used) { - done = 1; - stopped = 1; - for (sp = jp->ps; sp < jp->ps + jp->nprocs; sp++) { - if (sp->pid == -1) - continue; - if (sp->pid == pid) { - TRACE(("Changing status of proc %d from 0x%x to 0x%x\n", - pid, sp->status, status)); - sp->status = status; - thisjob = jp; - } - if (sp->status == -1) - stopped = 0; - else if (WIFSTOPPED(sp->status)) - done = 0; + for (jp = curjob; jp; jp = jp->prev_job) { + struct procstat *sp; + struct procstat *spend; + if (jp->state == JOBDONE) + continue; + state = JOBDONE; + spend = jp->ps + jp->nprocs; + sp = jp->ps; + do { + if (sp->pid == pid) { + TRACE(("Job %d: changing status of proc %d from 0x%x to 0x%x\n", jobno(jp), pid, sp->status, status)); + sp->status = status; + thisjob = jp; + } + if (sp->status == -1) + state = JOBRUNNING; +#ifdef JOBS + if (state == JOBRUNNING) + continue; + if (WIFSTOPPED(sp->status)) { + jp->stopstatus = sp->status; + state = JOBSTOPPED; } - if (stopped) { /* stopped or done */ - int state = done ? JOBDONE : JOBSTOPPED; - - if (jp->state != state) { - TRACE(("Job %d: changing state from %d to %d\n", - jp - jobtab + 1, jp->state, state)); - jp->state = state; -#ifdef CONFIG_ASH_JOB_CONTROL - if (done && curjob == jp - jobtab + 1) - curjob = 0; /* no current job */ #endif - } + } while (++sp < spend); + if (thisjob) + goto gotjob; + } +#ifdef JOBS + if (!WIFSTOPPED(status)) +#endif + + jobless--; + goto out; + +gotjob: + if (state != JOBRUNNING) { + thisjob->changed = 1; + + if (thisjob->state != state) { + TRACE(("Job %d: changing state from %d to %d\n", jobno(thisjob), thisjob->state, state)); + thisjob->state = state; +#ifdef JOBS + if (state == JOBSTOPPED) { + set_curjob(thisjob, CUR_STOPPED); } +#endif } } + +out: INTON; - if (!rootshell || !iflag || (job && thisjob == job)) { - core = WCOREDUMP(status); -#ifdef CONFIG_ASH_JOB_CONTROL - if (WIFSTOPPED(status)) - sig = WSTOPSIG(status); - else -#endif - if (WIFEXITED(status)) - sig = 0; - else - sig = WTERMSIG(status); - if (sig != 0 && sig != SIGINT && sig != SIGPIPE) { - if (thisjob != job) - out2fmt("%d: ", pid); -#ifdef CONFIG_ASH_JOB_CONTROL - if (sig == SIGTSTP && rootshell && iflag) - out2fmt("%%%ld ", (long) (job - jobtab + 1)); -#endif - if (sig < NSIG && sys_siglist[sig]) - out2str(sys_siglist[sig]); - else - out2fmt("Signal %d", sig); - if (core) - out2str(" - core dumped"); - out2c('\n'); - } else { - TRACE(("Not printing status: status=%d, sig=%d\n", status, sig)); + if (thisjob && thisjob == job) { + char s[48 + 1]; + int len; + + len = sprint_status(s, status, 1); + if (len) { + s[len] = '\n'; + s[len + 1] = 0; + out2str(s); } - } else { - TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell, - job)); - if (thisjob) - thisjob->changed = 1; } return pid; } - /* * return 1 if there are stopped jobs, otherwise 0 */ -static int stoppedjobs(void) +int +stoppedjobs(void) { - int jobno; struct job *jp; + int retval; + retval = 0; if (job_warning) - return (0); - for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) { - if (jp->used == 0) - continue; - if (jp->state == JOBSTOPPED) { - out2str("You have stopped jobs.\n"); - job_warning = 2; - return (1); - } + goto out; + jp = curjob; + if (jp && jp->state == JOBSTOPPED) { + out2str("You have stopped jobs.\n"); + job_warning = 2; + retval++; } - return (0); +out: + return retval; } /* * Return a string identifying a command (to be printed by the - * jobs command. + * jobs command). */ +#if JOBS static char *cmdnextc; -static int cmdnleft; -#define MAXCMDTEXT 200 - -static void cmdputs(const char *s) +static char * +commandtext(union node *n) { - const char *p; - char *q; - char c; - int subtype = 0; + char *name; - if (cmdnleft <= 0) - return; - p = s; - q = cmdnextc; - while ((c = *p++) != '\0') { - if (c == CTLESC) - *q++ = *p++; - else if (c == CTLVAR) { - *q++ = '$'; - if (--cmdnleft > 0) - *q++ = '{'; - subtype = *p++; - } else if (c == '=' && subtype != 0) { - *q++ = "}-+?="[(subtype & VSTYPE) - VSNORMAL]; - subtype = 0; - } else if (c == CTLENDVAR) { - *q++ = '}'; - } else if (c == CTLBACKQ || c == CTLBACKQ + CTLQUOTE) - cmdnleft++; /* ignore it */ - else - *q++ = c; - if (--cmdnleft <= 0) { - *q++ = '.'; - *q++ = '.'; - *q++ = '.'; - break; - } - } - cmdnextc = q; + STARTSTACKSTR(cmdnextc); + cmdtxt(n); + name = stackblock(); + TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n", + name, cmdnextc, cmdnextc)); + return savestr(name); } -#define CMDTXT_TABLE -#ifdef CMDTXT_TABLE -/* - * To collect a lot of redundant code in cmdtxt() case statements, we - * implement a mini language here. Each type of node struct has an - * associated instruction sequence that operates on its members via - * their offsets. The instruction are pack in unsigned chars with - * format IIDDDDDE where the bits are - * I : part of the instruction opcode, which are - * 00 : member is a pointer to another node -- process it recursively - * 40 : member is a pointer to a char string -- output it - * 80 : output the string whose index is stored in the data field - * CC : flag signaling that this case needs external processing - * D : data - either the (shifted) index of a fixed string to output or - * the actual offset of the member to operate on in the struct - * (since we assume bit 0 is set, the offset is not shifted) - * E : flag signaling end of instruction sequence - * - * WARNING: In order to handle larger offsets for 64bit archs, this code - * assumes that no offset can be an odd number and stores the - * end-of-instructions flag in bit 0. - */ - -#define CMDTXT_NOMORE 0x01 /* NOTE: no offset should be odd */ -#define CMDTXT_CHARPTR 0x40 -#define CMDTXT_STRING 0x80 -#define CMDTXT_SPECIAL 0xC0 -#define CMDTXT_OFFSETMASK 0x3E - -static const char *const cmdtxt_strings[] = { - /* 0 1 2 3 4 5 6 7 */ - "; ", "(", ")", " && ", " || ", "if ", "; then ", "...", - /* 8 9 10 11 12 13 */ - "while ", "; do ", "; done", "until ", "for ", " in ...", - /* 14 15 16 17 */ - "case ", "???", "() ...", "<<..." -}; - -static const char *const redir_strings[] = { - ">", "<", "<>", ">>", ">|", ">&", "<&" -}; - -static const unsigned char cmdtxt_ops[] = { -#define CMDTXT_NSEMI 0 - offsetof(union node, nbinary.ch1), - 0 | CMDTXT_STRING, - offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE, -#define CMDTXT_NCMD (CMDTXT_NSEMI + 3) -#define CMDTXT_NPIPE (CMDTXT_NCMD) -#define CMDTXT_NCASE (CMDTXT_NCMD) -#define CMDTXT_NTO (CMDTXT_NCMD) -#define CMDTXT_NFROM (CMDTXT_NCMD) -#define CMDTXT_NFROMTO (CMDTXT_NCMD) -#define CMDTXT_NAPPEND (CMDTXT_NCMD) -#define CMDTXT_NTOOV (CMDTXT_NCMD) -#define CMDTXT_NTOFD (CMDTXT_NCMD) -#define CMDTXT_NFROMFD (CMDTXT_NCMD) - CMDTXT_SPECIAL, -#define CMDTXT_NREDIR (CMDTXT_NPIPE + 1) -#define CMDTXT_NBACKGND (CMDTXT_NREDIR) - offsetof(union node, nredir.n) | CMDTXT_NOMORE, -#define CMDTXT_NSUBSHELL (CMDTXT_NBACKGND + 1) - (1 * 2) | CMDTXT_STRING, - offsetof(union node, nredir.n), - (2 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -#define CMDTXT_NAND (CMDTXT_NSUBSHELL + 3) - offsetof(union node, nbinary.ch1), - (3 * 2) | CMDTXT_STRING, - offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE, -#define CMDTXT_NOR (CMDTXT_NAND + 3) - offsetof(union node, nbinary.ch1), - (4 * 2) | CMDTXT_STRING, - offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE, -#define CMDTXT_NIF (CMDTXT_NOR + 3) - (5 * 2) | CMDTXT_STRING, - offsetof(union node, nif.test), - (6 * 2) | CMDTXT_STRING, - offsetof(union node, nif.ifpart), - (7 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -#define CMDTXT_NWHILE (CMDTXT_NIF + 5) - (8 * 2) | CMDTXT_STRING, - offsetof(union node, nbinary.ch1), - (9 * 2) | CMDTXT_STRING, - offsetof(union node, nbinary.ch2), - (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -#define CMDTXT_NUNTIL (CMDTXT_NWHILE + 5) - (11 * 2) | CMDTXT_STRING, - offsetof(union node, nbinary.ch1), - (9 * 2) | CMDTXT_STRING, - offsetof(union node, nbinary.ch2), - (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -#define CMDTXT_NFOR (CMDTXT_NUNTIL + 5) - (12 * 2) | CMDTXT_STRING, - offsetof(union node, nfor.var) | CMDTXT_CHARPTR, - (13 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -#define CMDTXT_NCLIST (CMDTXT_NFOR + 3) /* TODO: IS THIS CORRECT??? */ -#define CMDTXT_NNOT (CMDTXT_NCLIST) /* TODO: IS THIS CORRECT??? */ - (15 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -#define CMDTXT_NDEFUN (CMDTXT_NCLIST + 1) - offsetof(union node, narg.text) | CMDTXT_CHARPTR, - (16 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -#define CMDTXT_NARG (CMDTXT_NDEFUN + 2) - offsetof(union node, narg.text) | CMDTXT_CHARPTR | CMDTXT_NOMORE, -#define CMDTXT_NHERE (CMDTXT_NARG + 1) -#define CMDTXT_NXHERE (CMDTXT_NHERE) - (17 * 2) | CMDTXT_STRING | CMDTXT_NOMORE, -}; - -#if CMDTXT_NXHERE != 36 -#error CMDTXT_NXHERE -#endif - -static const unsigned char cmdtxt_ops_index[26] = { - CMDTXT_NSEMI, - CMDTXT_NCMD, - CMDTXT_NPIPE, - CMDTXT_NREDIR, - CMDTXT_NBACKGND, - CMDTXT_NSUBSHELL, - CMDTXT_NAND, - CMDTXT_NOR, - CMDTXT_NIF, - CMDTXT_NWHILE, - CMDTXT_NUNTIL, - CMDTXT_NFOR, - CMDTXT_NCASE, - CMDTXT_NCLIST, - CMDTXT_NDEFUN, - CMDTXT_NARG, - CMDTXT_NTO, - CMDTXT_NFROM, - CMDTXT_NFROMTO, - CMDTXT_NAPPEND, - CMDTXT_NTOOV, - CMDTXT_NTOFD, - CMDTXT_NFROMFD, - CMDTXT_NHERE, - CMDTXT_NXHERE, - CMDTXT_NNOT, -}; - -static void cmdtxt(const union node *n) -{ - const char *p; - - if (n == NULL) - return; - - p = cmdtxt_ops + (int) cmdtxt_ops_index[n->type]; - if ((*p & CMDTXT_SPECIAL) != CMDTXT_SPECIAL) { /* normal case */ - do { - if (*p & CMDTXT_STRING) { /* output fixed string */ - cmdputs(cmdtxt_strings - [((int) (*p & CMDTXT_OFFSETMASK) >> 1)]); - } else { - const char *pf = ((const char *) n) - + ((int) (*p & CMDTXT_OFFSETMASK)); - - if (*p & CMDTXT_CHARPTR) { /* output dynamic string */ - cmdputs(*((const char **) pf)); - } else { /* output field */ - cmdtxt(*((const union node **) pf)); - } - } - } while (!(*p++ & CMDTXT_NOMORE)); - } else if (n->type == NCMD) { - union node *np; - - for (np = n->ncmd.args; np; np = np->narg.next) { - cmdtxt(np); - if (np->narg.next) - cmdputs(spcstr); - } - for (np = n->ncmd.redirect; np; np = np->nfile.next) { - cmdputs(spcstr); - cmdtxt(np); - } - } else if (n->type == NPIPE) { - struct nodelist *lp; - - for (lp = n->npipe.cmdlist; lp; lp = lp->next) { - cmdtxt(lp->n); - if (lp->next) - cmdputs(" | "); - } - } else if (n->type == NCASE) { - cmdputs(cmdtxt_strings[14]); - cmdputs(n->ncase.expr->narg.text); - cmdputs(cmdtxt_strings[13]); - } else { -#if (NTO != 16) || (NFROM != 17) || (NFROMTO != 18) || (NAPPEND != 19) || (NTOOV != 20) || (NTOFD != 21) || (NFROMFD != 22) -#error Assumption violated regarding range and ordering of NTO ... NFROMFD! -#endif - char s[2]; - -#ifdef DEBUG - assert((n->type >= NTO) && (n->type <= NFROMFD)); -#endif - - p = redir_strings[n->type - NTO]; - if (n->nfile.fd != ('>' == *p)) { - s[0] = n->nfile.fd + '0'; - s[1] = '\0'; - cmdputs(s); - } - cmdputs(p); - if (n->type >= NTOFD) { - s[0] = n->ndup.dupfd + '0'; - s[1] = '\0'; - cmdputs(s); - } else { - cmdtxt(n->nfile.fname); - } - } -} -#else /* CMDTXT_TABLE */ -static void cmdtxt(const union node *n) +static void +cmdtxt(union node *n) { union node *np; struct nodelist *lp; const char *p; - int i; char s[2]; - if (n == NULL) - return; switch (n->type) { - case NSEMI: - cmdtxt(n->nbinary.ch1); - cmdputs("; "); - cmdtxt(n->nbinary.ch2); - break; - case NAND: - cmdtxt(n->nbinary.ch1); - cmdputs(" && "); - cmdtxt(n->nbinary.ch2); - break; - case NOR: - cmdtxt(n->nbinary.ch1); - cmdputs(" || "); - cmdtxt(n->nbinary.ch2); - break; + default: +#if DEBUG + abort(); +#endif case NPIPE: - for (lp = n->npipe.cmdlist; lp; lp = lp->next) { + lp = n->npipe.cmdlist; + for (;;) { cmdtxt(lp->n); - if (lp->next) - cmdputs(" | "); + lp = lp->next; + if (!lp) + break; + cmdputs(" | "); } break; - case NSUBSHELL: - cmdputs("("); - cmdtxt(n->nredir.n); - cmdputs(")"); - break; + case NSEMI: + p = "; "; + goto binop; + case NAND: + p = " && "; + goto binop; + case NOR: + p = " || "; +binop: + cmdtxt(n->nbinary.ch1); + cmdputs(p); + n = n->nbinary.ch2; + goto donode; case NREDIR: case NBACKGND: - cmdtxt(n->nredir.n); + n = n->nredir.n; + goto donode; + case NNOT: + cmdputs("!"); + n = n->nnot.com; +donode: + cmdtxt(n); break; case NIF: cmdputs("if "); cmdtxt(n->nif.test); cmdputs("; then "); - cmdtxt(n->nif.ifpart); - cmdputs("..."); - break; + n = n->nif.ifpart; + if (n->nif.elsepart) { + cmdtxt(n); + cmdputs("; else "); + n = n->nif.elsepart; + } + p = "; fi"; + goto dotail; + case NSUBSHELL: + cmdputs("("); + n = n->nredir.n; + p = ")"; + goto dotail; case NWHILE: - cmdputs("while "); + p = "while "; goto until; case NUNTIL: - cmdputs("until "); - until: + p = "until "; +until: + cmdputs(p); cmdtxt(n->nbinary.ch1); + n = n->nbinary.ch2; + p = "; done"; +dodo: cmdputs("; do "); - cmdtxt(n->nbinary.ch2); - cmdputs("; done"); - break; +dotail: + cmdtxt(n); + goto dotail2; case NFOR: cmdputs("for "); cmdputs(n->nfor.var); - cmdputs(" in ..."); - break; - case NCASE: - cmdputs("case "); - cmdputs(n->ncase.expr->narg.text); - cmdputs(" in ..."); - break; + cmdputs(" in "); + cmdlist(n->nfor.args, 1); + n = n->nfor.body; + p = "; done"; + goto dodo; case NDEFUN: cmdputs(n->narg.text); - cmdputs("() ..."); - break; + p = "() { ... }"; + goto dotail2; case NCMD: - for (np = n->ncmd.args; np; np = np->narg.next) { - cmdtxt(np); - if (np->narg.next) - cmdputs(spcstr); - } - for (np = n->ncmd.redirect; np; np = np->nfile.next) { - cmdputs(spcstr); - cmdtxt(np); - } + cmdlist(n->ncmd.args, 1); + cmdlist(n->ncmd.redirect, 0); break; case NARG: - cmdputs(n->narg.text); + p = n->narg.text; +dotail2: + cmdputs(p); break; + case NHERE: + case NXHERE: + p = "<<..."; + goto dotail2; + case NCASE: + cmdputs("case "); + cmdputs(n->ncase.expr->narg.text); + cmdputs(" in "); + for (np = n->ncase.cases; np; np = np->nclist.next) { + cmdtxt(np->nclist.pattern); + cmdputs(") "); + cmdtxt(np->nclist.body); + cmdputs(";; "); + } + p = "esac"; + goto dotail2; case NTO: p = ">"; - i = 1; + goto redir; + case NCLOBBER: + p = ">|"; goto redir; case NAPPEND: 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: p = "<&"; - i = 0; goto redir; case NFROMTO: p = "<>"; - i = 0; - goto redir; - redir: - if (n->nfile.fd != i) { - s[0] = n->nfile.fd + '0'; - s[1] = '\0'; - cmdputs(s); - } +redir: + s[0] = n->nfile.fd + '0'; + s[1] = '\0'; + cmdputs(s); cmdputs(p); if (n->type == NTOFD || n->type == NFROMFD) { s[0] = n->ndup.dupfd + '0'; - s[1] = '\0'; - cmdputs(s); + p = s; + goto dotail2; } else { - cmdtxt(n->nfile.fname); + n = n->nfile.fname; + goto donode; } - break; - case NHERE: - case NXHERE: - cmdputs("<<..."); - break; - default: - cmdputs("???"); - break; } } -#endif /* CMDTXT_TABLE */ -static char *commandtext(const union node *n) +static void +cmdlist(union node *np, int sep) { - char *name; + for (; np; np = np->narg.next) { + if (!sep) + cmdputs(spcstr); + cmdtxt(np); + if (sep && np->narg.next) + cmdputs(spcstr); + } +} - cmdnextc = name = xmalloc(MAXCMDTEXT); - cmdnleft = MAXCMDTEXT - 4; - cmdtxt(n); - *cmdnextc = '\0'; - return name; + +static void +cmdputs(const char *s) +{ + const char *p, *str; + char c, cc[2] = " "; + char *nextc; + int subtype = 0; + int quoted = 0; + static const char *const vstype[16] = { + nullstr, "}", "-", "+", "?", "=", + "#", "##", "%", "%%" + }; + + nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc); + p = s; + while ((c = *p++) != 0) { + str = 0; + switch (c) { + case CTLESC: + c = *p++; + break; + case CTLVAR: + subtype = *p++; + if ((subtype & VSTYPE) == VSLENGTH) + str = "${#"; + else + str = "${"; + if (!(subtype & VSQUOTE) != !(quoted & 1)) { + quoted ^= 1; + c = '"'; + } else + goto dostr; + break; + case CTLENDVAR: + quoted >>= 1; + subtype = 0; + if (quoted & 1) { + str = "\"}"; + goto dostr; + } + c = '}'; + break; + case CTLBACKQ: + str = "$(...)"; + goto dostr; + case CTLBACKQ+CTLQUOTE: + str = "\"$(...)\""; + goto dostr; +#ifdef CONFIG_ASH_MATH_SUPPORT + case CTLARI: + str = "$(("; + goto dostr; + case CTLENDARI: + str = "))"; + goto dostr; +#endif + case CTLQUOTEMARK: + quoted ^= 1; + c = '"'; + break; + case '=': + if (subtype == 0) + break; + str = vstype[subtype & VSTYPE]; + if (subtype & VSNUL) + c = ':'; + else + c = *str++; + if (c != '}') + quoted <<= 1; + break; + case '\'': + case '\\': + case '"': + case '$': + /* These can only happen inside quotes */ + cc[0] = c; + str = cc; + c = '\\'; + break; + default: + break; + } + USTPUTC(c, nextc); + if (!str) + continue; +dostr: + while ((c = *str++)) { + USTPUTC(c, nextc); + } + } + if (quoted & 1) { + USTPUTC('"', nextc); + } + *nextc = 0; + cmdnextc = nextc; } +static void +showpipe(struct job *jp, FILE *out) +{ + struct procstat *sp; + struct procstat *spend; + + spend = jp->ps + jp->nprocs; + for (sp = jp->ps + 1; sp < spend; sp++) + fprintf(out, " | %s", sp->cmd); + outcslow('\n', out); + flushall(); +} + +static void +xtcsetpgrp(int fd, pid_t pgrp) +{ + if (tcsetpgrp(fd, pgrp)) + error("Cannot set tty process group (%m)"); +} +#endif /* JOBS */ + +static int +getstatus(struct job *job) { + int status; + int retval; + + status = job->ps[job->nprocs - 1].status; + retval = WEXITSTATUS(status); + if (!WIFEXITED(status)) { +#if JOBS + retval = WSTOPSIG(status); + if (!WIFSTOPPED(status)) +#endif + { + /* XXX: limits number of signals */ + retval = WTERMSIG(status); +#if JOBS + if (retval == SIGINT) + job->sigint = 1; +#endif + } + retval += 128; + } + TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n", + jobno(job), job->nprocs, status, retval)); + return retval; +} + #ifdef CONFIG_ASH_MAIL +/* $NetBSD: mail.c,v 1.15 2002/11/24 22:35:40 christos Exp $ */ /* - * Routines to check for mail. + * Routines to check for mail. (Perhaps make part of main.c?) */ - #define MAXMBOXES 10 - -static int nmboxes; /* number of mailboxes */ -static time_t mailtime[MAXMBOXES]; /* times of mailboxes */ +/* times of mailboxes */ +static time_t mailtime[MAXMBOXES]; +/* Set if MAIL or MAILPATH is changed. */ +static int mail_var_path_changed; /* - * Print appropriate message(s) if mail has arrived. If the argument is - * nozero, then the value of MAIL has changed, so we just update the - * values. + * Print appropriate message(s) if mail has arrived. + * If mail_var_path_changed is set, + * then the value of MAIL has mail_var_path_changed, + * so we just update the values. */ -static void chkmail(int silent) +static void +chkmail(void) { - int i; const char *mpath; char *p; char *q; + time_t *mtp; struct stackmark smark; struct stat statb; - if (silent) - nmboxes = 10; - if (nmboxes == 0) - return; setstackmark(&smark); - mpath = mpathset()? mpathval() : mailval(); - for (i = 0; i < nmboxes; i++) { + mpath = mpathset() ? mpathval() : mailval(); + for (mtp = mailtime; mtp < mailtime + MAXMBOXES; mtp++) { p = padvance(&mpath, nullstr); if (p == NULL) break; if (*p == '\0') continue; - for (q = p; *q; q++); + for (q = p ; *q ; q++); #ifdef DEBUG if (q[-1] != '/') abort(); #endif - q[-1] = '\0'; /* delete trailing '/' */ - if (stat(p, &statb) < 0) - statb.st_size = 0; - if (statb.st_size > mailtime[i] && !silent) { - out2fmt(snlfmt, pathopt ? pathopt : "you have mail"); + q[-1] = '\0'; /* delete trailing '/' */ + if (stat(p, &statb) < 0) { + *mtp = 0; + continue; + } + if (!mail_var_path_changed && statb.st_mtime != *mtp) { + fprintf( + stderr, snlfmt, + pathopt ? pathopt : "you have mail" + ); } - mailtime[i] = statb.st_size; + *mtp = statb.st_mtime; } - nmboxes = i; + mail_var_path_changed = 0; popstackmark(&smark); } -#endif /* CONFIG_ASH_MAIL */ -#define PROFILE 0 +static void +changemail(const char *val) +{ + mail_var_path_changed++; +} + +#endif /* CONFIG_ASH_MAIL */ + +/* $NetBSD: main.c,v 1.46 2002/12/11 19:12:18 christos Exp $ */ + #if PROFILE static short profile_buf[16384]; extern int etext(); #endif -static int isloginsh = 0; +static int isloginsh; static void read_profile(const char *); -static void cmdloop(int); -static void options(int); -static void setoption(int, int); -static void procargs(int, char **); - /* * Main routine. We initialize things, parse the arguments, execute @@ -7262,56 +7704,52 @@ static void procargs(int, char **); * is used to figure out how far we had gotten. */ -int ash_main(int argc, char **argv) +int +ash_main(int argc, char **argv) { + char *shinit; + volatile int state; struct jmploc jmploc; struct stackmark smark; - volatile int state; - const char *shinit; - BLTINCMD = find_builtin("builtin"); - EXECCMD = find_builtin("exec"); - EVALCMD = find_builtin("eval"); - -#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT - unsetenv("PS1"); - unsetenv("PS2"); +#ifdef __GLIBC__ + dash_errno = __errno_location(); #endif #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)) { - INTOFF; - /* - * When a shell procedure is executed, we raise the - * exception EXSHELLPROC to clean up before executing - * the shell procedure. - */ - if (exception == EXSHELLPROC) { - rootpid = getpid(); - rootshell = 1; - minusc = NULL; - state = 3; - } else { - if (exception == EXEXEC) { - exitstatus = exerrno; - } else if (exception == EXERROR) { - exitstatus = 2; - } - if (state == 0 || iflag == 0 || !rootshell) - exitshell(exitstatus); - } + int status; + int e; + reset(); - if (exception == EXINT) { - out2c('\n'); + + e = exception; + switch (exception) { + case EXEXEC: + status = exerrno; + break; + + case EXERROR: + status = 2; + break; + + default: + status = exitstatus; + break; + } + exitstatus = status; + + if (e == EXEXIT || state == 0 || iflag == 0 || ! rootshell) + exitshell(); + + if (e == EXINT ) { + outcslow('\n', stderr); } popstackmark(&smark); - FORCEINTON; /* enable interrupts */ + FORCEINTON; /* enable interrupts */ if (state == 1) goto state1; else if (state == 2) @@ -7324,8 +7762,7 @@ int ash_main(int argc, char **argv) handler = &jmploc; #ifdef DEBUG opentrace(); - trputs("Shell args: "); - trargs(argv); + trputs("Shell args: "); trargs(argv); #endif rootpid = getpid(); rootshell = 1; @@ -7351,45 +7788,29 @@ int ash_main(int argc, char **argv) if (isloginsh) { state = 1; read_profile("/etc/profile"); - state1: +state1: state = 2; read_profile(".profile"); } - state2: +state2: state = 3; + if ( #ifndef linux - if (getuid() == geteuid() && getgid() == getegid()) { + getuid() == geteuid() && getgid() == getegid() && #endif + iflag + ) { if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') { - state = 3; read_profile(shinit); } -#ifndef linux } -#endif - state3: +state3: state = 4; - if (sflag == 0 || minusc) { - static const char sigs[] = { - SIGINT, SIGQUIT, SIGHUP, -#ifdef SIGTSTP - SIGTSTP, -#endif - SIGPIPE - }; - -#define SIGSSIZE ((sizeof(sigs)/sizeof(sigs[0]))) - int i; - - for (i = 0; i < SIGSSIZE; i++) - setsignal(sigs[i]); - } - if (minusc) evalstring(minusc, 0); if (sflag || minusc == NULL) { - state4: /* XXX ??? - why isn't this before the "if" statement */ +state4: /* XXX ??? - why isn't this before the "if" statement */ #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY if ( iflag ) { const char *hp = lookupvar("HISTFILE"); @@ -7403,7 +7824,13 @@ int ash_main(int argc, char **argv) #if PROFILE monitor(0); #endif - exitshell(exitstatus); +#if GPROF + { + extern void _mcleanup(void); + _mcleanup(); + } +#endif + exitshell(); /* NOTREACHED */ } @@ -7413,7 +7840,8 @@ int ash_main(int argc, char **argv) * loop; it turns on prompting if the shell is interactive. */ -static void cmdloop(int top) +static void +cmdloop(int top) { union node *n; struct stackmark smark; @@ -7425,14 +7853,16 @@ static void cmdloop(int top) for (;;) { if (pendingsigs) dotrap(); +#if JOBS + if (jobctl) + showjobs(stderr, SHOW_CHANGED); +#endif inter = 0; if (iflag && top) { inter++; - showjobs(1); #ifdef CONFIG_ASH_MAIL - chkmail(0); + chkmail(); #endif - flushall(); } n = parsecmd(inter); /* showtree(n); DEBUG */ @@ -7466,11 +7896,12 @@ static void cmdloop(int top) * Read /etc/profile or .profile. Return on error. */ -static void read_profile(const char *name) +static void +read_profile(const char *name) { int fd; - int xflag_save; - int vflag_save; + int xflag_set = 0; + int vflag_set = 0; INTOFF; if ((fd = open(name, O_RDONLY)) >= 0) @@ -7479,15 +7910,19 @@ static void read_profile(const char *name) if (fd < 0) return; /* -q turns off -x and -v just when executing init files */ - /* Note: Might do a little redundant work, but reduces code size. */ - xflag_save = xflag; - vflag_save = vflag; - if (qflag) { - vflag = xflag = 0; + if (qflag) { + if (xflag) + xflag = 0, xflag_set = 1; + if (vflag) + vflag = 0, vflag_set = 1; } cmdloop(0); - xflag = xflag_save; - vflag = vflag_save; + if (qflag) { + if (xflag_set) + xflag = 1; + if (vflag_set) + vflag = 1; + } popfile(); } @@ -7497,7 +7932,8 @@ static void read_profile(const char *name) * Read a file containing shell functions. */ -static void readcmdfile(const char *name) +static void +readcmdfile(char *name) { int fd; @@ -7512,23 +7948,23 @@ static void readcmdfile(const char *name) } - /* - * Take commands from a file. To be compatable we should do a path + * Take commands from a file. To be compatible we should do a path * search for the file, which is necessary to find sub-commands. */ -static inline char *find_dot_file(char *mybasename) +static inline char * +find_dot_file(char *name) { char *fullname; const char *path = pathval(); struct stat statb; /* don't try this for absolute or relative paths */ - if (strchr(mybasename, '/')) - return mybasename; + if (strchr(name, '/')) + return name; - while ((fullname = padvance(&path, mybasename)) != NULL) { + while ((fullname = padvance(&path, name)) != NULL) { if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) { /* * Don't bother freeing here, since it will @@ -7540,107 +7976,149 @@ static inline char *find_dot_file(char *mybasename) } /* not found in the PATH */ - error("%s: not found", mybasename); + error(not_found_msg, name); /* NOTREACHED */ } -static int dotcmd(int argc, char **argv) +int +dotcmd(int argc, char **argv) { - struct strlist *sp; - volatile struct shparam saveparam; - exitstatus = 0; - for (sp = cmdenviron; sp; sp = sp->next) - setvareq(bb_xstrdup(sp->text), VSTRFIXED | VTEXTFIXED); - - if (argc >= 2) { /* That's what SVR2 does */ + if (argc >= 2) { /* That's what SVR2 does */ char *fullname; struct stackmark smark; setstackmark(&smark); fullname = find_dot_file(argv[1]); - - if (argc > 2) { - saveparam = shellparam; - shellparam.malloc = 0; - shellparam.nparam = argc - 2; - shellparam.p = argv + 2; - }; - setinputfile(fullname, 1); commandname = fullname; cmdloop(0); popfile(); - - if (argc > 2) { - freeparam(&shellparam); - shellparam = saveparam; - }; - popstackmark(&smark); } return exitstatus; } -static int exitcmd(int argc, char **argv) +static int +exitcmd(int argc, char **argv) { if (stoppedjobs()) return 0; - if (argc > 1) exitstatus = number(argv[1]); - else - exitstatus = oexitstatus; - exitshell(exitstatus); + exraise(EXEXIT); /* NOTREACHED */ } -static pointer stalloc(int nbytes) +/* $NetBSD: memalloc.c,v 1.27 2003/01/22 20:36:04 dsl Exp $ */ + +/* + * Like malloc, but returns an error when out of space. + */ + +static pointer +ckmalloc(size_t nbytes) +{ + pointer p; + + p = malloc(nbytes); + if (p == NULL) + error(bb_msg_memory_exhausted); + return p; +} + + +/* + * Same for realloc. + */ + +static pointer +ckrealloc(pointer p, size_t nbytes) +{ + p = realloc(p, nbytes); + if (p == NULL) + error(bb_msg_memory_exhausted); + return p; +} + + +/* + * Make a copy of a string in safe storage. + */ + +static char * +savestr(const char *s) +{ + char *p = strdup(s); + if (!p) + error(bb_msg_memory_exhausted); + return p; +} + + +/* + * Parse trees for commands are allocated in lifo order, so we use a stack + * to make this more efficient, and also to avoid all sorts of exception + * handling code to handle interrupts in the middle of a parse. + * + * The size 504 was chosen because the Ultrix malloc handles that size + * well. + */ + + +static pointer +stalloc(size_t nbytes) { char *p; + size_t aligned; - nbytes = ALIGN(nbytes); - if (nbytes > stacknleft) { - int blocksize; + aligned = SHELL_ALIGN(nbytes); + if (aligned > stacknleft) { + size_t len; + size_t blocksize; struct stack_block *sp; - blocksize = nbytes; + blocksize = aligned; if (blocksize < MINSIZE) blocksize = MINSIZE; + len = sizeof(struct stack_block) - MINSIZE + blocksize; + if (len < blocksize) + error(bb_msg_memory_exhausted); INTOFF; - sp = xmalloc(sizeof(struct stack_block) - MINSIZE + blocksize); + sp = ckmalloc(len); sp->prev = stackp; stacknxt = sp->space; stacknleft = blocksize; + sstrend = stacknxt + blocksize; stackp = sp; INTON; } p = stacknxt; - stacknxt += nbytes; - stacknleft -= nbytes; + stacknxt += aligned; + stacknleft -= aligned; return p; } -static void stunalloc(pointer p) +void +stunalloc(pointer p) { #ifdef DEBUG - if (p == NULL) { /*DEBUG */ + if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) { write(2, "stunalloc\n", 10); abort(); } #endif - if (!(stacknxt >= (char *) p && (char *) p >= stackp->space)) { - p = stackp->space; - } - stacknleft += stacknxt - (char *) p; + stacknleft += stacknxt - (char *)p; stacknxt = p; } -static void setstackmark(struct stackmark *mark) + +void +setstackmark(struct stackmark *mark) { mark->stackp = stackp; mark->stacknxt = stacknxt; @@ -7650,7 +8128,8 @@ static void setstackmark(struct stackmark *mark) } -static void popstackmark(struct stackmark *mark) +void +popstackmark(struct stackmark *mark) { struct stack_block *sp; @@ -7659,10 +8138,11 @@ static void popstackmark(struct stackmark *mark) while (stackp != mark->stackp) { sp = stackp; stackp = sp->prev; - free(sp); + ckfree(sp); } stacknxt = mark->stacknxt; stacknleft = mark->stacknleft; + sstrend = mark->stacknxt + mark->stacknleft; INTON; } @@ -7677,62 +8157,69 @@ static void popstackmark(struct stackmark *mark) * part of the block that has been used. */ -static void growstackblock(void) +void +growstackblock(void) { - char *p; - int newlen = ALIGN(stacknleft * 2 + 100); - char *oldspace = stacknxt; - int oldlen = stacknleft; - struct stack_block *sp; - struct stack_block *oldstackp; + size_t newlen; + + newlen = stacknleft * 2; + if (newlen < stacknleft) + error(bb_msg_memory_exhausted); + if (newlen < 128) + newlen += 128; if (stacknxt == stackp->space && stackp != &stackbase) { + struct stack_block *oldstackp; + struct stackmark *xmark; + struct stack_block *sp; + struct stack_block *prevstackp; + size_t grosslen; + INTOFF; oldstackp = stackp; sp = stackp; - stackp = sp->prev; - sp = xrealloc((pointer) sp, - sizeof(struct stack_block) - MINSIZE + newlen); - sp->prev = stackp; + prevstackp = sp->prev; + grosslen = newlen + sizeof(struct stack_block) - MINSIZE; + sp = ckrealloc((pointer)sp, grosslen); + sp->prev = prevstackp; stackp = sp; stacknxt = sp->space; stacknleft = newlen; - { - /* Stack marks pointing to the start of the old block - * must be relocated to point to the new block - */ - struct stackmark *xmark; - - xmark = markp; - while (xmark != NULL && xmark->stackp == oldstackp) { - xmark->stackp = stackp; - xmark->stacknxt = stacknxt; - xmark->stacknleft = stacknleft; - xmark = xmark->marknext; - } + sstrend = sp->space + newlen; + + /* + * Stack marks pointing to the start of the old block + * must be relocated to point to the new block + */ + xmark = markp; + while (xmark != NULL && xmark->stackp == oldstackp) { + xmark->stackp = stackp; + xmark->stacknxt = stacknxt; + xmark->stacknleft = stacknleft; + xmark = xmark->marknext; } INTON; } else { - p = stalloc(newlen); - memcpy(p, oldspace, oldlen); - stacknxt = p; /* free the space */ - stacknleft += newlen; /* we just allocated */ + char *oldspace = stacknxt; + int oldlen = stacknleft; + char *p = stalloc(newlen); + + /* free the space we just allocated */ + stacknxt = memcpy(p, oldspace, oldlen); + stacknleft += newlen; } } - - -static inline void grabstackblock(int len) +static inline void +grabstackblock(size_t len) { - len = ALIGN(len); + len = SHELL_ALIGN(len); stacknxt += len; stacknleft -= len; } - - /* - * The following routines are somewhat easier to use that the above. + * The following routines are somewhat easier to use than the above. * The user declares a variable of type STACKSTR, which may be declared * to be a register. The macro STARTSTACKSTR initializes things. Then * the user uses the macro STPUTC to add characters to the string. In @@ -7749,853 +8236,349 @@ static inline void grabstackblock(int len) * is space for at least one character. */ - -static char *growstackstr(void) +void * +growstackstr(void) { - int len = stackblocksize(); - + size_t len = stackblocksize(); if (herefd >= 0 && len >= 1024) { xwrite(herefd, stackblock(), len); - sstrnleft = len - 1; return stackblock(); } growstackblock(); - sstrnleft = stackblocksize() - len - 1; return stackblock() + len; } - /* * Called from CHECKSTRSPACE. */ -static char *makestrspace(size_t newlen) +char * +makestrspace(size_t newlen, char *p) { - int len = stackblocksize() - sstrnleft; + size_t len = p - stacknxt; + size_t size = stackblocksize(); - do { + for (;;) { + size_t nleft; + + size = stackblocksize(); + nleft = size - len; + if (nleft >= newlen) + break; growstackblock(); - sstrnleft = stackblocksize() - len; - } while (sstrnleft < newlen); + } return stackblock() + len; } - - -static void ungrabstackstr(char *s, char *p) +char * +stnputs(const char *s, size_t n, char *p) { - stacknleft += stacknxt - s; - stacknxt = s; - sstrnleft = stacknleft - (p - s); + p = makestrspace(n, p); + p = mempcpy(p, s, n); + return p; } -/* - * Miscelaneous builtins. - */ - - -#undef rflag - -#if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1 -typedef long rlim_t; -#endif - - - -/* - * The read builtin. The -e option causes backslashes to escape the - * following character. - * - * This uses unbuffered input, which may be avoidable in some cases. - */ - -static int readcmd(int argc, char **argv) +char * +stputs(const char *s, char *p) { - char **ap; - int backslash; - char c; - int rflag; - char *prompt; - const char *ifs; - char *p; - int startword; - int status; - int i; - - rflag = 0; - prompt = NULL; - while ((i = nextopt("p:r")) != '\0') { - if (i == 'p') - prompt = optionarg; - else - rflag = 1; - } - if (prompt && isatty(0)) { - out2str(prompt); /* read without cmdedit */ - flushall(); - } - if (*(ap = argptr) == NULL) - error("arg count"); - if ((ifs = bltinlookup("IFS")) == NULL) - ifs = defifs; - status = 0; - startword = 1; - backslash = 0; - STARTSTACKSTR(p); - for (;;) { - if (read(0, &c, 1) != 1) { - status = 1; - break; - } - if (c == '\0') - continue; - if (backslash) { - backslash = 0; - if (c != '\n') - STPUTC(c, p); - continue; - } - if (!rflag && c == '\\') { - backslash++; - continue; - } - if (c == '\n') - break; - if (startword && *ifs == ' ' && strchr(ifs, c)) { - continue; - } - startword = 0; - if (backslash && c == '\\') { - if (read(0, &c, 1) != 1) { - status = 1; - break; - } - STPUTC(c, p); - } else if (ap[1] != NULL && strchr(ifs, c) != NULL) { - STACKSTRNUL(p); - setvar(*ap, stackblock(), 0); - ap++; - startword = 1; - STARTSTACKSTR(p); - } else { - STPUTC(c, p); - } - } - STACKSTRNUL(p); - /* Remove trailing blanks */ - while (stackblock() <= --p && strchr(ifs, *p) != NULL) - *p = '\0'; - setvar(*ap, stackblock(), 0); - while (*++ap != NULL) - setvar(*ap, nullstr, 0); - return status; + return stnputs(s, strlen(s), p); } - - -static int umaskcmd(int argc, char **argv) -{ - static const char permuser[3] = "ugo"; - static const char permmode[3] = "rwx"; - static const short int permmask[] = { - S_IRUSR, S_IWUSR, S_IXUSR, - S_IRGRP, S_IWGRP, S_IXGRP, - S_IROTH, S_IWOTH, S_IXOTH - }; - - char *ap; - mode_t mask; - int i; - int symbolic_mode = 0; - - while (nextopt("S") != '\0') { - symbolic_mode = 1; - } - - INTOFF; - mask = umask(0); - umask(mask); - INTON; - - if ((ap = *argptr) == NULL) { - if (symbolic_mode) { - char buf[18]; - char *p = buf; - - for (i = 0; i < 3; i++) { - int j; - - *p++ = permuser[i]; - *p++ = '='; - for (j = 0; j < 3; j++) { - if ((mask & permmask[3 * i + j]) == 0) { - *p++ = permmode[j]; - } - } - *p++ = ','; - } - *--p = 0; - puts(buf); - } else { - printf("%.4o\n", mask); - } - } else { - if (is_digit((unsigned char) *ap)) { - mask = 0; - do { - if (*ap >= '8' || *ap < '0') - error("Illegal number: %s", argv[1]); - mask = (mask << 3) + (*ap - '0'); - } while (*++ap != '\0'); - umask(mask); - } else { - mask = ~mask & 0777; - if (!bb_parse_mode(ap, &mask)) { - error("Illegal mode: %s", ap); - } - umask(~mask & 0777); - } - } - return 0; -} +/* $NetBSD: mystring.c,v 1.15 2002/11/24 22:35:42 christos Exp $ */ /* - * ulimit builtin + * String functions. * - * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and - * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with - * ash by J.T. Conklin. - * - * Public domain. + * number(s) Convert a string of digits to an integer. + * is_number(s) Return true if s is a string of digits. */ -struct limits { - const char *name; - short cmd; - short factor; /* multiply by to get rlim_{cur,max} values */ -}; - -static const struct limits limits[] = { -#ifdef RLIMIT_CPU - {"time(seconds)", RLIMIT_CPU, 1}, -#endif -#ifdef RLIMIT_FSIZE - {"file(blocks)", RLIMIT_FSIZE, 512}, -#endif -#ifdef RLIMIT_DATA - {"data(kbytes)", RLIMIT_DATA, 1024}, -#endif -#ifdef RLIMIT_STACK - {"stack(kbytes)", RLIMIT_STACK, 1024}, -#endif -#ifdef RLIMIT_CORE - {"coredump(blocks)", RLIMIT_CORE, 512}, -#endif -#ifdef RLIMIT_RSS - {"memory(kbytes)", RLIMIT_RSS, 1024}, -#endif -#ifdef RLIMIT_MEMLOCK - {"locked memory(kbytes)", RLIMIT_MEMLOCK, 1024}, -#endif -#ifdef RLIMIT_NPROC - {"process(processes)", RLIMIT_NPROC, 1}, -#endif -#ifdef RLIMIT_NOFILE - {"nofiles(descriptors)", RLIMIT_NOFILE, 1}, -#endif -#ifdef RLIMIT_VMEM - {"vmemory(kbytes)", RLIMIT_VMEM, 1024}, -#endif -#ifdef RLIMIT_SWAP - {"swap(kbytes)", RLIMIT_SWAP, 1024}, -#endif - {NULL, 0, 0} -}; - -static int ulimitcmd(int argc, char **argv) -{ - static const char unlimited_string[] = "unlimited"; - int c; - rlim_t val = 0; - enum { SOFT = 0x1, HARD = 0x2 } how = SOFT | HARD; - const struct limits *l; - int set, all = 0; - int optc, what; - struct rlimit limit; - - what = 'f'; - - while ((optc = nextopt("HSa" -#ifdef RLIMIT_CPU - "t" -#endif -#ifdef RLIMIT_FSIZE - "f" -#endif -#ifdef RLIMIT_DATA - "d" -#endif -#ifdef RLIMIT_STACK - "s" -#endif -#ifdef RLIMIT_CORE - "c" -#endif -#ifdef RLIMIT_RSS - "m" -#endif -#ifdef RLIMIT_MEMLOCK - "l" -#endif -#ifdef RLIMIT_NPROC - "p" -#endif -#ifdef RLIMIT_NOFILE - "n" -#endif -#ifdef RLIMIT_VMEM - "v" -#endif -#ifdef RLIMIT_SWAP - "w" -#endif - )) != '\0') { - if (optc == 'H') { - how = HARD; - } else if (optc == 'S') { - how = SOFT; - } else if (optc == 'a') { - all = 1; - } else { - what = optc; - } - } - - for (l = limits; l->name; l++) { - if (l->name[0] == what) - break; - if (l->name[1] == 'w' && what == 'w') - break; - } - - set = *argptr ? 1 : 0; - if (set) { - char *p = *argptr; - - if (all || argptr[1]) - error("too many arguments"); - if (strcmp(p, unlimited_string) == 0) - val = RLIM_INFINITY; - else { - val = (rlim_t) 0; - - while ((c = *p++) >= '0' && c <= '9') { - val = (val * 10) + (long) (c - '0'); - if (val < (rlim_t) 0) - break; - } - if (c) - error("bad number"); - val *= l->factor; - } - } - - if (all) { - for (l = limits; l->name; l++) { - printf("%-20s ", l->name); - getrlimit(l->cmd, &limit); - OUTPUT_LIMIT: - if (how & SOFT) - val = limit.rlim_cur; - else if (how & HARD) - val = limit.rlim_max; - - if (val == RLIM_INFINITY) - puts(unlimited_string); - else { - val /= l->factor; - printf("%lld\n", (long long) val); - } - if (!all) { - break; - } - } - return 0; - } - - if (!set) { - goto OUTPUT_LIMIT; - } - - getrlimit(l->cmd, &limit); - if (how & HARD) - limit.rlim_max = val; - if (how & SOFT) - limit.rlim_cur = val; - if (setrlimit(l->cmd, &limit) < 0) - error("error setting limit (%m)"); - return 0; -} - /* * prefix -- see if pfx is a prefix of string. */ -static int prefix(char const *pfx, char const *string) +char * +prefix(const char *string, const char *pfx) { while (*pfx) { if (*pfx++ != *string++) return 0; } - return 1; + return (char *) string; } + /* - * Return true if s is a string of digits, and save munber in intptr - * nagative is bad + * Convert a string of digits to an integer, printing an error message on + * failure. */ -static int is_number(const char *p, int *intptr) +int +number(const char *s) { - int ret = 0; - do { - if (!is_digit(*p)) - return 0; - ret *= 10; - ret += digit_val(*p); - p++; - } while (*p != '\0'); - - *intptr = ret; - return 1; + if (! is_number(s)) + error(illnum, s); + return atoi(s); } + + /* - * Convert a string of digits to an integer, printing an error message on - * failure. + * Check for a valid number. This should be elsewhere. */ -static int number(const char *s) +int +is_number(const char *p) { - int i; - - if (!is_number(s, &i)) - error("Illegal number: %s", s); - return i; + do { + if (! is_digit(*p)) + return 0; + } while (*++p != '\0'); + return 1; } + /* * Produce a possibly single quoted string suitable as input to the shell. * The return string is allocated on the stack. */ -static char *single_quote(const char *s) -{ +char * +single_quote(const char *s) { char *p; STARTSTACKSTR(p); do { - char *q = p; - size_t len1, len1p, len2, len2p; + char *q; + size_t len; - len1 = strcspn(s, "'"); - len2 = strspn(s + len1, "'"); + len = strchrnul(s, '\'') - s; - len1p = len1 ? len1 + 2 : len1; - len2p = len2 + ((len2 < 2) ? len2 : 2); + q = p = makestrspace(len + 3, p); - CHECKSTRSPACE(len1p + len2p + 1, p); + *q++ = '\''; + q = mempcpy(q, s, len); + *q++ = '\''; + s += len; - if (len1) { - *p = '\''; - q = p + 1 + len1; - memcpy(p + 1, s, len1); - *q++ = '\''; - s += len1; - } + STADJUST(q - p, p); - if (len2 > 1) { - *q = '"'; - q += 1 + len2; - memcpy(q + 1, s, len2); - *q = '"'; - s += len2; - } else if (len2 == 1) { - *q++ = '\\'; - *q = '\''; - s++; - } + len = strspn(s, "'"); + if (!len) + break; + + q = p = makestrspace(len + 3, p); + + *q++ = '"'; + q = mempcpy(q, s, len); + *q++ = '"'; + s += len; - STADJUST(len1p + len2p, p); + STADJUST(q - p, p); } while (*s); USTPUTC(0, p); - return grabstackstr(p); + return stackblock(); } /* - * Routine for dealing with parsed shell commands. + * Like strdup but works with the ash stack. */ - -static void sizenodelist(const struct nodelist *); -static struct nodelist *copynodelist(const struct nodelist *); -static char *nodesavestr(const char *); - -#define CALCSIZE_TABLE -#define COPYNODE_TABLE -#if defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) -/* - * To collect a lot of redundant code in case statements for copynode() - * and calcsize(), we implement a mini language here. Each type of node - * struct has an associated instruction sequence that operates on its - * members via their offsets. The instruction are pack in unsigned chars - * with format IIDDDDDE where the bits are - * I : part of the instruction opcode, which are - * 00 : member is a pointer to another node - * 40 : member is an integer - * 80 : member is a pointer to a nodelist - * CC : member is a pointer to a char string - * D : data - the actual offset of the member to operate on in the struct - * (since we assume bit 0 is set, it is not shifted) - * E : flag signaling end of instruction sequence - * - * WARNING: In order to handle larger offsets for 64bit archs, this code - * assumes that no offset can be an odd number and stores the - * end-of-instructions flag in bit 0. - */ - -#define NODE_INTEGER 0x40 -#define NODE_NODELIST 0x80 -#define NODE_CHARPTR 0xC0 -#define NODE_NOMORE 0x01 /* Note: no offset should be odd (aligned) */ -#define NODE_MBRMASK 0xC0 -#define NODE_OFFSETMASK 0x3E - -static const unsigned char copynode_ops[35] = { -#define COPYNODE_OPS0 0 - offsetof(union node, nbinary.ch2), - offsetof(union node, nbinary.ch1) | NODE_NOMORE, -#define COPYNODE_OPS1 (COPYNODE_OPS0 + 2) - offsetof(union node, ncmd.redirect), - offsetof(union node, ncmd.args), - offsetof(union node, ncmd.assign), - offsetof(union node, ncmd.backgnd) | NODE_INTEGER | NODE_NOMORE, -#define COPYNODE_OPS2 (COPYNODE_OPS1 + 4) - offsetof(union node, npipe.cmdlist) | NODE_NODELIST, - offsetof(union node, npipe.backgnd) | NODE_INTEGER | NODE_NOMORE, -#define COPYNODE_OPS3 (COPYNODE_OPS2 + 2) - offsetof(union node, nredir.redirect), - offsetof(union node, nredir.n) | NODE_NOMORE, -#define COPYNODE_OPS4 (COPYNODE_OPS3 + 2) - offsetof(union node, nif.elsepart), - offsetof(union node, nif.ifpart), - offsetof(union node, nif.test) | NODE_NOMORE, -#define COPYNODE_OPS5 (COPYNODE_OPS4 + 3) - offsetof(union node, nfor.var) | NODE_CHARPTR, - offsetof(union node, nfor.body), - offsetof(union node, nfor.args) | NODE_NOMORE, -#define COPYNODE_OPS6 (COPYNODE_OPS5 + 3) - offsetof(union node, ncase.cases), - offsetof(union node, ncase.expr) | NODE_NOMORE, -#define COPYNODE_OPS7 (COPYNODE_OPS6 + 2) - offsetof(union node, nclist.body), - offsetof(union node, nclist.pattern), - offsetof(union node, nclist.next) | NODE_NOMORE, -#define COPYNODE_OPS8 (COPYNODE_OPS7 + 3) - offsetof(union node, narg.backquote) | NODE_NODELIST, - offsetof(union node, narg.text) | NODE_CHARPTR, - offsetof(union node, narg.next) | NODE_NOMORE, -#define COPYNODE_OPS9 (COPYNODE_OPS8 + 3) - offsetof(union node, nfile.fname), - offsetof(union node, nfile.fd) | NODE_INTEGER, - offsetof(union node, nfile.next) | NODE_NOMORE, -#define COPYNODE_OPS10 (COPYNODE_OPS9 + 3) - offsetof(union node, ndup.vname), - offsetof(union node, ndup.dupfd) | NODE_INTEGER, - offsetof(union node, ndup.fd) | NODE_INTEGER, - offsetof(union node, ndup.next) | NODE_NOMORE, -#define COPYNODE_OPS11 (COPYNODE_OPS10 + 4) - offsetof(union node, nhere.doc), - offsetof(union node, nhere.fd) | NODE_INTEGER, - offsetof(union node, nhere.next) | NODE_NOMORE, -#define COPYNODE_OPS12 (COPYNODE_OPS11 + 3) - offsetof(union node, nnot.com) | NODE_NOMORE, -}; - -#if COPYNODE_OPS12 != 34 -#error COPYNODE_OPS12 is incorrect -#endif - -static const unsigned char copynode_ops_index[26] = { - COPYNODE_OPS0, /* NSEMI */ - COPYNODE_OPS1, /* NCMD */ - COPYNODE_OPS2, /* NPIPE */ - COPYNODE_OPS3, /* NREDIR */ - COPYNODE_OPS3, /* NBACKGND */ - COPYNODE_OPS3, /* NSUBSHELL */ - COPYNODE_OPS0, /* NAND */ - COPYNODE_OPS0, /* NOR */ - COPYNODE_OPS4, /* NIF */ - COPYNODE_OPS0, /* NWHILE */ - COPYNODE_OPS0, /* NUNTIL */ - COPYNODE_OPS5, /* NFOR */ - COPYNODE_OPS6, /* NCASE */ - COPYNODE_OPS7, /* NCLIST */ - COPYNODE_OPS8, /* NDEFUN */ - COPYNODE_OPS8, /* NARG */ - COPYNODE_OPS9, /* NTO */ - COPYNODE_OPS9, /* NFROM */ - COPYNODE_OPS9, /* NFROMTO */ - COPYNODE_OPS9, /* NAPPEND */ - COPYNODE_OPS9, /* NTOOV */ - COPYNODE_OPS10, /* NTOFD */ - COPYNODE_OPS10, /* NFROMFD */ - COPYNODE_OPS11, /* NHERE */ - COPYNODE_OPS11, /* NXHERE */ - COPYNODE_OPS12, /* NNOT */ -}; - -#if NODE_CHARPTR != NODE_MBRMASK -#error NODE_CHARPTR != NODE_MBRMASK!!! -#endif -#endif /* defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) */ - -#ifdef COPYNODE_TABLE -static union node *copynode(const union node *n) +char * +sstrdup(const char *p) { - union node *new; - const unsigned char *p; - - if (n == NULL) { - return NULL; - } - new = funcblock; - new->type = n->type; - funcblock = (char *) funcblock + (int) nodesize[n->type]; - p = copynode_ops + (int) copynode_ops_index[n->type]; - do { - char *nn = ((char *) new) + ((int) (*p & NODE_OFFSETMASK)); - const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK)); - - if (!(*p & NODE_MBRMASK)) { /* standard node */ - *((union node **) nn) = copynode(*((const union node **) no)); - } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */ - *((const char **) nn) = nodesavestr(*((const char **) no)); - } else if (*p & NODE_NODELIST) { /* nodelist */ - *((struct nodelist **) nn) - = copynodelist(*((const struct nodelist **) no)); - } else { /* integer */ - *((int *) nn) = *((int *) no); - } - } while (!(*p++ & NODE_NOMORE)); - return new; + size_t len = strlen(p) + 1; + return memcpy(stalloc(len), p, len); } -#else /* COPYNODE_TABLE */ -static union node *copynode(const union node *n) -{ - union node *new; - if (n == NULL) - return NULL; - new = funcblock; - funcblock = (char *) funcblock + nodesize[n->type]; - switch (n->type) { - case NSEMI: - case NAND: - case NOR: - case NWHILE: - case NUNTIL: - new->nbinary.ch2 = copynode(n->nbinary.ch2); - new->nbinary.ch1 = copynode(n->nbinary.ch1); - break; - case NCMD: - new->ncmd.redirect = copynode(n->ncmd.redirect); - new->ncmd.args = copynode(n->ncmd.args); - new->ncmd.assign = copynode(n->ncmd.assign); - new->ncmd.backgnd = n->ncmd.backgnd; - break; - case NPIPE: - new->npipe.cmdlist = copynodelist(n->npipe.cmdlist); - new->npipe.backgnd = n->npipe.backgnd; - break; - case NREDIR: - case NBACKGND: - case NSUBSHELL: - new->nredir.redirect = copynode(n->nredir.redirect); - new->nredir.n = copynode(n->nredir.n); - break; - case NIF: - new->nif.elsepart = copynode(n->nif.elsepart); - new->nif.ifpart = copynode(n->nif.ifpart); - new->nif.test = copynode(n->nif.test); - break; - case NFOR: - new->nfor.var = nodesavestr(n->nfor.var); - new->nfor.body = copynode(n->nfor.body); - new->nfor.args = copynode(n->nfor.args); - break; - case NCASE: - new->ncase.cases = copynode(n->ncase.cases); - new->ncase.expr = copynode(n->ncase.expr); - break; - case NCLIST: - new->nclist.body = copynode(n->nclist.body); - new->nclist.pattern = copynode(n->nclist.pattern); - new->nclist.next = copynode(n->nclist.next); - break; - case NDEFUN: - case NARG: - new->narg.backquote = copynodelist(n->narg.backquote); - new->narg.text = nodesavestr(n->narg.text); - new->narg.next = copynode(n->narg.next); - break; - case NTO: - case NFROM: - case NFROMTO: - case NAPPEND: - case NTOOV: - new->nfile.fname = copynode(n->nfile.fname); - new->nfile.fd = n->nfile.fd; - new->nfile.next = copynode(n->nfile.next); - break; - case NTOFD: - case NFROMFD: - new->ndup.vname = copynode(n->ndup.vname); - new->ndup.dupfd = n->ndup.dupfd; - new->ndup.fd = n->ndup.fd; - new->ndup.next = copynode(n->ndup.next); - break; - case NHERE: - case NXHERE: - new->nhere.doc = copynode(n->nhere.doc); - new->nhere.fd = n->nhere.fd; - new->nhere.next = copynode(n->nhere.next); - break; - case NNOT: - new->nnot.com = copynode(n->nnot.com); - break; - }; - new->type = n->type; - return new; -} -#endif /* COPYNODE_TABLE */ -#ifdef CALCSIZE_TABLE -static void calcsize(const union node *n) -{ - const unsigned char *p; +static void +calcsize(union node *n) +{ + if (n == NULL) + return; + funcblocksize += nodesize[n->type]; + switch (n->type) { + case NCMD: + calcsize(n->ncmd.redirect); + calcsize(n->ncmd.args); + calcsize(n->ncmd.assign); + break; + case NPIPE: + sizenodelist(n->npipe.cmdlist); + break; + case NREDIR: + case NBACKGND: + case NSUBSHELL: + calcsize(n->nredir.redirect); + calcsize(n->nredir.n); + break; + case NAND: + case NOR: + case NSEMI: + case NWHILE: + case NUNTIL: + calcsize(n->nbinary.ch2); + calcsize(n->nbinary.ch1); + break; + case NIF: + calcsize(n->nif.elsepart); + calcsize(n->nif.ifpart); + calcsize(n->nif.test); + break; + case NFOR: + funcstringsize += strlen(n->nfor.var) + 1; + calcsize(n->nfor.body); + calcsize(n->nfor.args); + break; + case NCASE: + calcsize(n->ncase.cases); + calcsize(n->ncase.expr); + break; + case NCLIST: + calcsize(n->nclist.body); + calcsize(n->nclist.pattern); + calcsize(n->nclist.next); + break; + case NDEFUN: + case NARG: + sizenodelist(n->narg.backquote); + funcstringsize += strlen(n->narg.text) + 1; + calcsize(n->narg.next); + break; + case NTO: + case NCLOBBER: + case NFROM: + case NFROMTO: + case NAPPEND: + calcsize(n->nfile.fname); + calcsize(n->nfile.next); + break; + case NTOFD: + case NFROMFD: + calcsize(n->ndup.vname); + calcsize(n->ndup.next); + break; + case NHERE: + case NXHERE: + calcsize(n->nhere.doc); + calcsize(n->nhere.next); + break; + case NNOT: + calcsize(n->nnot.com); + break; + }; +} - if (n == NULL) - return; - funcblocksize += (int) nodesize[n->type]; - p = copynode_ops + (int) copynode_ops_index[n->type]; - do { - const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK)); - if (!(*p & NODE_MBRMASK)) { /* standard node */ - calcsize(*((const union node **) no)); - } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */ - funcstringsize += strlen(*((const char **) no)) + 1; - } else if (*p & NODE_NODELIST) { /* nodelist */ - sizenodelist(*((const struct nodelist **) no)); - } /* else integer -- ignore */ - } while (!(*p++ & NODE_NOMORE)); -} -#else /* CALCSIZE_TABLE */ -static void calcsize(const union node *n) -{ - if (n == NULL) - return; - funcblocksize += nodesize[n->type]; - switch (n->type) { - case NSEMI: - case NAND: - case NOR: - case NWHILE: - case NUNTIL: - calcsize(n->nbinary.ch2); - calcsize(n->nbinary.ch1); - break; - case NCMD: - calcsize(n->ncmd.redirect); - calcsize(n->ncmd.args); - calcsize(n->ncmd.assign); - break; - case NPIPE: - sizenodelist(n->npipe.cmdlist); - break; - case NREDIR: - case NBACKGND: - case NSUBSHELL: - calcsize(n->nredir.redirect); - calcsize(n->nredir.n); - break; - case NIF: - calcsize(n->nif.elsepart); - calcsize(n->nif.ifpart); - calcsize(n->nif.test); - break; - case NFOR: - funcstringsize += strlen(n->nfor.var) + 1; - calcsize(n->nfor.body); - calcsize(n->nfor.args); - break; - case NCASE: - calcsize(n->ncase.cases); - calcsize(n->ncase.expr); - break; - case NCLIST: - calcsize(n->nclist.body); - calcsize(n->nclist.pattern); - calcsize(n->nclist.next); - break; - case NDEFUN: - case NARG: - sizenodelist(n->narg.backquote); - funcstringsize += strlen(n->narg.text) + 1; - calcsize(n->narg.next); - break; - case NTO: - case NFROM: - case NFROMTO: - case NAPPEND: - case NTOOV: - calcsize(n->nfile.fname); - calcsize(n->nfile.next); - break; - case NTOFD: - case NFROMFD: - calcsize(n->ndup.vname); - calcsize(n->ndup.next); - break; - case NHERE: - case NXHERE: - calcsize(n->nhere.doc); - calcsize(n->nhere.next); - break; - case NNOT: - calcsize(n->nnot.com); - break; - }; -} -#endif /* CALCSIZE_TABLE */ - -static void sizenodelist(const struct nodelist *lp) +static void +sizenodelist(struct nodelist *lp) { while (lp) { - funcblocksize += ALIGN(sizeof(struct nodelist)); + funcblocksize += SHELL_ALIGN(sizeof(struct nodelist)); calcsize(lp->n); lp = lp->next; } } -static struct nodelist *copynodelist(const struct nodelist *lp) + +static union node * +copynode(union node *n) +{ + union node *new; + + if (n == NULL) + return NULL; + new = funcblock; + funcblock = (char *) funcblock + nodesize[n->type]; + switch (n->type) { + case NCMD: + new->ncmd.redirect = copynode(n->ncmd.redirect); + new->ncmd.args = copynode(n->ncmd.args); + new->ncmd.assign = copynode(n->ncmd.assign); + break; + case NPIPE: + new->npipe.cmdlist = copynodelist(n->npipe.cmdlist); + new->npipe.backgnd = n->npipe.backgnd; + break; + case NREDIR: + case NBACKGND: + case NSUBSHELL: + new->nredir.redirect = copynode(n->nredir.redirect); + new->nredir.n = copynode(n->nredir.n); + break; + case NAND: + case NOR: + case NSEMI: + case NWHILE: + case NUNTIL: + new->nbinary.ch2 = copynode(n->nbinary.ch2); + new->nbinary.ch1 = copynode(n->nbinary.ch1); + break; + case NIF: + new->nif.elsepart = copynode(n->nif.elsepart); + new->nif.ifpart = copynode(n->nif.ifpart); + new->nif.test = copynode(n->nif.test); + break; + case NFOR: + new->nfor.var = nodesavestr(n->nfor.var); + new->nfor.body = copynode(n->nfor.body); + new->nfor.args = copynode(n->nfor.args); + break; + case NCASE: + new->ncase.cases = copynode(n->ncase.cases); + new->ncase.expr = copynode(n->ncase.expr); + break; + case NCLIST: + new->nclist.body = copynode(n->nclist.body); + new->nclist.pattern = copynode(n->nclist.pattern); + new->nclist.next = copynode(n->nclist.next); + break; + case NDEFUN: + case NARG: + new->narg.backquote = copynodelist(n->narg.backquote); + new->narg.text = nodesavestr(n->narg.text); + new->narg.next = copynode(n->narg.next); + break; + case NTO: + case NCLOBBER: + case NFROM: + case NFROMTO: + case NAPPEND: + new->nfile.fname = copynode(n->nfile.fname); + new->nfile.fd = n->nfile.fd; + new->nfile.next = copynode(n->nfile.next); + break; + case NTOFD: + case NFROMFD: + new->ndup.vname = copynode(n->ndup.vname); + new->ndup.dupfd = n->ndup.dupfd; + new->ndup.fd = n->ndup.fd; + new->ndup.next = copynode(n->ndup.next); + break; + case NHERE: + case NXHERE: + new->nhere.doc = copynode(n->nhere.doc); + new->nhere.fd = n->nhere.fd; + new->nhere.next = copynode(n->nhere.next); + break; + case NNOT: + new->nnot.com = copynode(n->nnot.com); + break; + }; + new->type = n->type; + return new; +} + + +static struct nodelist * +copynodelist(struct nodelist *lp) { struct nodelist *start; struct nodelist **lpp; @@ -8603,7 +8586,8 @@ static struct nodelist *copynodelist(const struct nodelist *lp) lpp = &start; while (lp) { *lpp = funcblock; - funcblock = (char *) funcblock + ALIGN(sizeof(struct nodelist)); + funcblock = (char *) funcblock + + SHELL_ALIGN(sizeof(struct nodelist)); (*lpp)->n = copynode(lp->n); lp = lp->next; lpp = &(*lpp)->next; @@ -8613,95 +8597,133 @@ static struct nodelist *copynodelist(const struct nodelist *lp) } -static char *nodesavestr(const char *s) + +static char * +nodesavestr(char *s) { - const char *p = s; - char *q = funcstring; - char *rtn = funcstring; + char *rtn = funcstring; - while ((*q++ = *p++) != '\0') - continue; - funcstring = q; + funcstring = stpcpy(funcstring, s) + 1; return rtn; } -#ifdef CONFIG_ASH_GETOPTS -static int getopts(char *, char *, char **, int *, int *); -#endif + + +/* + * Free a parse tree. + */ + +static void +freefunc(struct funcnode *f) +{ + if (f && --f->count < 0) + ckfree(f); +} + + +static void options(int); +static void setoption(int, int); + /* * Process the shell command line arguments. */ -static void procargs(int argc, char **argv) +void +procargs(int argc, char **argv) { int i; + const char *xminusc; + char **xargv; - argptr = argv; + xargv = argv; + arg0 = xargv[0]; if (argc > 0) - argptr++; + xargv++; for (i = 0; i < NOPTS; i++) - optent_val(i) = 2; + optlist[i] = 2; + argptr = xargv; options(1); - if (*argptr == NULL && minusc == NULL) + xargv = argptr; + xminusc = minusc; + if (*xargv == NULL) { + if (xminusc) + error("-c requires an argument"); sflag = 1; + } if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1)) iflag = 1; if (mflag == 2) mflag = iflag; for (i = 0; i < NOPTS; i++) - if (optent_val(i) == 2) - optent_val(i) = 0; - arg0 = argv[0]; - if (sflag == 0 && minusc == NULL) { - commandname = argv[0]; - arg0 = *argptr++; - setinputfile(arg0, 0); + if (optlist[i] == 2) + optlist[i] = 0; +#if DEBUG == 2 + debug = 1; +#endif + /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */ + if (xminusc) { + minusc = *xargv++; + if (*xargv) + goto setarg0; + } else if (!sflag) { + setinputfile(*xargv, 0); +setarg0: + arg0 = *xargv++; commandname = arg0; } - /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */ - if (argptr && minusc && *argptr) - arg0 = *argptr++; - shellparam.p = argptr; + shellparam.p = xargv; +#ifdef CONFIG_ASH_GETOPTS shellparam.optind = 1; shellparam.optoff = -1; +#endif /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */ - while (*argptr) { + while (*xargv) { shellparam.nparam++; - argptr++; + xargv++; } optschanged(); } +void +optschanged(void) +{ +#ifdef DEBUG + opentrace(); +#endif + setinteractive(iflag); + setjobctl(mflag); +} -/* - * Process shell options. The global variable argptr contains a pointer - * to the argument list; we advance it past the options. - */ - -static inline void minus_o(const char *name, int val) +static inline void +minus_o(char *name, int val) { int i; if (name == NULL) { out1str("Current option settings\n"); for (i = 0; i < NOPTS; i++) - printf("%-16s%s\n", optent_name(optlist[i]), - optent_val(i) ? "on" : "off"); + out1fmt("%-16s%s\n", optnames(i), + optlist[i] ? "on" : "off"); } else { for (i = 0; i < NOPTS; i++) - if (equal(name, optent_name(optlist[i]))) { - setoption(optent_letter(optlist[i]), val); + if (equal(name, optnames(i))) { + optlist[i] = val; return; } error("Illegal option -o %s", name); } } +/* + * Process shell options. The global variable argptr contains a pointer + * to the argument list; we advance it past the options. + */ -static void options(int cmdline) +static void +options(int cmdline) { char *p; int val; @@ -8722,7 +8744,7 @@ static void options(int cmdline) else if (*argptr == NULL) setparam(argptr); } - break; /* "-" or "--" terminates options */ + break; /* "-" or "--" terminates options */ } } else if (c == '+') { val = 0; @@ -8732,23 +8754,12 @@ static void options(int cmdline) } while ((c = *p++) != '\0') { if (c == 'c' && cmdline) { - char *q; - -#ifdef NOHACK /* removing this code allows sh -ce 'foo' for compat */ - if (*p == '\0') -#endif - q = *argptr++; - if (q == NULL || minusc != NULL) - error("Bad -c option"); - minusc = q; -#ifdef NOHACK - break; -#endif + minusc = p; /* command is after shell args*/ } else if (c == 'o') { minus_o(*argptr, val); if (*argptr) argptr++; - } else if (cmdline && (c == '-')) { // long options + } else if (cmdline && (c == '-')) { // long options if (strcmp(p, "login") == 0) isloginsh = 1; break; @@ -8760,20 +8771,15 @@ static void options(int cmdline) } -static void setoption(int flag, int val) + +static void +setoption(int flag, int val) { int i; for (i = 0; i < NOPTS; i++) - if (optent_letter(optlist[i]) == flag) { - optent_val(i) = val; - if (val) { - /* #%$ hack for ksh semantics */ - if (flag == 'V') - Eflag = 0; - else if (flag == 'E') - Vflag = 0; - } + if (optletters(i) == flag) { + optlist[i] = val; return; } error("Illegal option -%c", flag); @@ -8786,24 +8792,27 @@ static void setoption(int flag, int val) * Set the shell parameters. */ -static void setparam(char **argv) +void +setparam(char **argv) { char **newparam; char **ap; int nparam; - for (nparam = 0; argv[nparam]; nparam++); - ap = newparam = xmalloc((nparam + 1) * sizeof *ap); + for (nparam = 0 ; argv[nparam] ; nparam++); + ap = newparam = ckmalloc((nparam + 1) * sizeof *ap); while (*argv) { - *ap++ = bb_xstrdup(*argv++); + *ap++ = savestr(*argv++); } *ap = NULL; freeparam(&shellparam); shellparam.malloc = 1; shellparam.nparam = nparam; shellparam.p = newparam; +#ifdef CONFIG_ASH_GETOPTS shellparam.optind = 1; shellparam.optoff = -1; +#endif } @@ -8811,14 +8820,15 @@ static void setparam(char **argv) * Free the list of positional parameters. */ -static void freeparam(volatile struct shparam *param) +void +freeparam(volatile struct shparam *param) { char **ap; if (param->malloc) { - for (ap = param->p; *ap; ap++) - free(*ap); - free(param->p); + for (ap = param->p ; *ap ; ap++) + ckfree(*ap); + ckfree(param->p); } } @@ -8828,7 +8838,8 @@ static void freeparam(volatile struct shparam *param) * The shift builtin command. */ -static int shiftcmd(int argc, char **argv) +int +shiftcmd(int argc, char **argv) { int n; char **ap1, **ap2; @@ -8840,14 +8851,16 @@ static int shiftcmd(int argc, char **argv) error("can't shift that many"); INTOFF; shellparam.nparam -= n; - for (ap1 = shellparam.p; --n >= 0; ap1++) { + for (ap1 = shellparam.p ; --n >= 0 ; ap1++) { if (shellparam.malloc) - free(*ap1); + ckfree(*ap1); } ap2 = shellparam.p; while ((*ap2++ = *ap1++) != NULL); +#ifdef CONFIG_ASH_GETOPTS shellparam.optind = 1; shellparam.optoff = -1; +#endif INTON; return 0; } @@ -8858,10 +8871,11 @@ static int shiftcmd(int argc, char **argv) * The set command builtin. */ -static int setcmd(int argc, char **argv) +int +setcmd(int argc, char **argv) { if (argc == 1) - return showvarscmd(argc, argv); + return showvars(nullstr, 0, VUNSET); INTOFF; options(0); optschanged(); @@ -8873,11 +8887,15 @@ static int setcmd(int argc, char **argv) } -static void getoptsreset(const char *value) +#ifdef CONFIG_ASH_GETOPTS +static void +getoptsreset(value) + const char *value; { shellparam.optind = number(value); shellparam.optoff = -1; } +#endif #ifdef CONFIG_LOCALE_SUPPORT static void change_lc_all(const char *value) @@ -8895,74 +8913,18 @@ static void change_lc_ctype(const char *value) #endif #ifdef CONFIG_ASH_GETOPTS -/* - * The getopts builtin. Shellparam.optnext points to the next argument - * to be processed. Shellparam.optptr points to the next character to - * be processed in the current argument. If shellparam.optnext is NULL, - * then it's the first time getopts has been called. - */ - -static int getoptscmd(int argc, char **argv) -{ - char **optbase; - - if (argc < 3) - error("Usage: getopts optstring var [arg]"); - else if (argc == 3) { - optbase = shellparam.p; - if (shellparam.optind > shellparam.nparam + 1) { - shellparam.optind = 1; - shellparam.optoff = -1; - } - } else { - optbase = &argv[3]; - if (shellparam.optind > argc - 2) { - shellparam.optind = 1; - shellparam.optoff = -1; - } - } - - return getopts(argv[1], argv[2], optbase, &shellparam.optind, - &shellparam.optoff); -} - -/* - * Safe version of setvar, returns 1 on success 0 on failure. - */ - -static int setvarsafe(const char *name, const char *val, int flags) -{ - struct jmploc jmploc; - struct jmploc *volatile savehandler = handler; - int err = 0; - -#ifdef __GNUC__ - (void) &err; -#endif - - if (setjmp(jmploc.loc)) - err = 1; - else { - handler = &jmploc; - setvar(name, val, flags); - } - handler = savehandler; - return err; -} - static int -getopts(char *optstr, char *optvar, char **optfirst, int *myoptind, - int *optoff) +getopts(char *optstr, char *optvar, char **optfirst, int *param_optind, int *optoff) { char *p, *q; char c = '?'; int done = 0; int err = 0; char s[10]; - char **optnext = optfirst + *myoptind - 1; + char **optnext = optfirst + *param_optind - 1; - if (*myoptind <= 1 || *optoff < 0 || !(*(optnext - 1)) || - strlen(*(optnext - 1)) < *optoff) + if (*param_optind <= 1 || *optoff < 0 || !(*(optnext - 1)) || + strlen(*(optnext - 1)) < *optoff) p = NULL; else p = *(optnext - 1) + *optoff; @@ -8972,30 +8934,29 @@ getopts(char *optstr, char *optvar, char **optfirst, int *myoptind, return 1; p = *optnext; if (p == NULL || *p != '-' || *++p == '\0') { - atend: - *myoptind = optnext - optfirst + 1; +atend: p = NULL; done = 1; goto out; } optnext++; - if (p[0] == '-' && p[1] == '\0') /* check for "--" */ + if (p[0] == '-' && p[1] == '\0') /* check for "--" */ goto atend; } c = *p++; - for (q = optstr; *q != c;) { + for (q = optstr; *q != c; ) { if (*q == '\0') { if (optstr[0] == ':') { s[0] = c; s[1] = '\0'; err |= setvarsafe("OPTARG", s, 0); } else { - out2fmt("Illegal option -%c\n", c); + fprintf(stderr, "Illegal option -%c\n", c); (void) unsetvar("OPTARG"); } c = '?'; - goto bad; + goto out; } if (*++q == ':') q++; @@ -9009,40 +8970,70 @@ getopts(char *optstr, char *optvar, char **optfirst, int *myoptind, err |= setvarsafe("OPTARG", s, 0); c = ':'; } else { - out2fmt("No arg for -%c option\n", c); + fprintf(stderr, "No arg for -%c option\n", c); (void) unsetvar("OPTARG"); c = '?'; } - goto bad; + goto out; } if (p == *optnext) optnext++; - setvarsafe("OPTARG", p, 0); + err |= setvarsafe("OPTARG", p, 0); p = NULL; } else - setvarsafe("OPTARG", "", 0); - *myoptind = optnext - optfirst + 1; - goto out; + err |= setvarsafe("OPTARG", nullstr, 0); - bad: - *myoptind = 1; - p = NULL; - out: +out: *optoff = p ? p - *(optnext - 1) : -1; - snprintf(s, sizeof(s), "%d", *myoptind); + *param_optind = optnext - optfirst + 1; + fmtstr(s, sizeof(s), "%d", *param_optind); err |= setvarsafe("OPTIND", s, VNOFUNC); s[0] = c; s[1] = '\0'; err |= setvarsafe(optvar, s, 0); if (err) { - *myoptind = 1; + *param_optind = 1; *optoff = -1; + flushall(); exraise(EXERROR); } return done; } -#endif + +/* + * The getopts builtin. Shellparam.optnext points to the next argument + * to be processed. Shellparam.optptr points to the next character to + * be processed in the current argument. If shellparam.optnext is NULL, + * then it's the first time getopts has been called. + */ + +int +getoptscmd(int argc, char **argv) +{ + char **optbase; + + if (argc < 3) + error("Usage: getopts optstring var [arg]"); + else if (argc == 3) { + optbase = shellparam.p; + if (shellparam.optind > shellparam.nparam + 1) { + shellparam.optind = 1; + shellparam.optoff = -1; + } + } + else { + optbase = &argv[3]; + if (shellparam.optind > argc - 2) { + shellparam.optind = 1; + shellparam.optoff = -1; + } + } + + return getopts(argv[1], argv[2], optbase, &shellparam.optind, + &shellparam.optoff); +} +#endif /* CONFIG_ASH_GETOPTS */ /* * XXX - should get rid of. have all builtins use getopt(3). the @@ -9055,7 +9046,8 @@ getopts(char *optstr, char *optvar, char **optfirst, int *myoptind, * end of input. */ -static int nextopt(const char *optstring) +static int +nextopt(const char *optstring) { char *p; const char *q; @@ -9066,11 +9058,11 @@ static int nextopt(const char *optstring) if (p == NULL || *p != '-' || *++p == '\0') return '\0'; argptr++; - if (p[0] == '-' && p[1] == '\0') /* check for "--" */ + if (p[0] == '-' && p[1] == '\0') /* check for "--" */ return '\0'; } c = *p++; - for (q = optstring; *q != c;) { + for (q = optstring ; *q != c ; ) { if (*q == '\0') error("Illegal option -%c", c); if (*++q == ':') @@ -9086,52 +9078,94 @@ static int nextopt(const char *optstring) return c; } -static void flushall() +/* $NetBSD: output.c,v 1.27 2002/11/24 22:35:42 christos Exp $ */ + + + +void +outstr(const char *p, FILE *file) +{ + INTOFF; + fputs(p, file); + INTON; +} + +void +flushall(void) { INTOFF; fflush(stdout); + fflush(stderr); + INTON; +} + + +void +flushout(FILE *dest) +{ + INTOFF; + fflush(dest); + INTON; +} + +static void +outcslow(int c, FILE *dest) +{ + INTOFF; + putc(c, dest); + fflush(dest); INTON; } -static void out2fmt(const char *fmt, ...) +static int +out1fmt(const char *fmt, ...) { va_list ap; + int r; + INTOFF; va_start(ap, fmt); - vfprintf(stderr, fmt, ap); + r = vprintf(fmt, ap); va_end(ap); + INTON; + return r; } + +int +fmtstr(char *outbuf, size_t length, const char *fmt, ...) +{ + va_list ap; + int ret; + + va_start(ap, fmt); + INTOFF; + ret = vsnprintf(outbuf, length, fmt, ap); + va_end(ap); + INTON; + return ret; +} + + /* * Version of write which resumes after a signal is caught. */ -static int xwrite(int fd, const char *buf, int nbytes) +static void +xwrite(int fd, const void *p, size_t n) { - int ntry; - int i; - int n; + ssize_t i; - n = nbytes; - ntry = 0; - for (;;) { - i = write(fd, buf, n); - if (i > 0) { - if ((n -= i) <= 0) - return nbytes; - buf += i; - ntry = 0; - } else if (i == 0) { - if (++ntry > 10) - return nbytes - n; - } else if (errno != EINTR) { - return -1; - } - } + do { + i = bb_full_write(fd, p, n); + } while (i < 0 && errno == EINTR); } +/* $NetBSD: parser.c,v 1.54 2002/11/24 22:35:42 christos Exp $ */ + + /* * Shell command parser. */ @@ -9139,61 +9173,66 @@ static int xwrite(int fd, const char *buf, int nbytes) #define EOFMARKLEN 79 - struct heredoc { - struct heredoc *next; /* next here document in list */ - union node *here; /* redirection node */ - char *eofmark; /* string indicating end of input */ - int striptabs; /* if set, strip leading tabs */ + struct heredoc *next; /* next here document in list */ + union node *here; /* redirection node */ + char *eofmark; /* string indicating end of input */ + int striptabs; /* if set, strip leading tabs */ }; -static struct heredoc *heredoclist; /* list of here documents to read */ -static int parsebackquote; /* nonzero if we are inside backquotes */ -static int doprompt; /* if set, prompt the user */ -static int needprompt; /* true if interactive and at start of line */ -static int lasttoken; /* last token read */ -static char *wordtext; /* text of last word returned by readtoken */ -static struct nodelist *backquotelist; -static union node *redirnode; -static struct heredoc *heredoc; -static int quoteflag; /* set if (part of) last token was quoted */ -static int startlinno; /* line # where last token started */ +static struct heredoc *heredoclist; /* list of here documents to read */ static union node *list(int); static union node *andor(void); static union node *pipeline(void); static union node *command(void); -static union node *simplecmd(union node **rpp, union node *redir); +static union node *simplecmd(void); +static union node *makename(void); static void parsefname(void); static void parseheredoc(void); static char peektoken(void); static int readtoken(void); static int xxreadtoken(void); -static int readtoken1(int, int, const char *, int); +static int readtoken1(int firstc, int syntax, char *eofmark, int striptabs); static int noexpand(char *); -static void synexpect(int) __attribute__ ((noreturn)); -static void synerror(const char *) __attribute__ ((noreturn)); +static void synexpect(int) __attribute__((__noreturn__)); +static void synerror(const char *) __attribute__((__noreturn__)); static void setprompt(int); +static inline int +goodname(const char *p) +{ + return !*endofname(p); +} + +static inline int +isassignment(const char *p) +{ + const char *q = endofname(p); + if (p == q) + return 0; + return *q == '='; +} + + /* * Read and parse a command. Returns NEOF on end of file. (NULL is a * valid parse tree indicating a blank line.) */ -static union node *parsecmd(int interact) +union node * +parsecmd(int interact) { int t; tokpushback = 0; doprompt = interact; if (doprompt) - setprompt(1); - else - setprompt(0); + setprompt(doprompt); needprompt = 0; t = readtoken(); if (t == TEOF) @@ -9205,35 +9244,37 @@ static union node *parsecmd(int interact) } -static union node *list(int nlflag) +static union node * +list(int nlflag) { union node *n1, *n2, *n3; int tok; - checkkwd = 2; - if (nlflag == 0 && peektoken()) + checkkwd = CHKNL | CHKKWD | CHKALIAS; + if (nlflag == 2 && peektoken()) return NULL; n1 = NULL; for (;;) { n2 = andor(); tok = readtoken(); if (tok == TBACKGND) { - if (n2->type == NCMD || n2->type == NPIPE) { - n2->ncmd.backgnd = 1; - } else if (n2->type == NREDIR) { - n2->type = NBACKGND; + if (n2->type == NPIPE) { + n2->npipe.backgnd = 1; } else { - n3 = (union node *) stalloc(sizeof(struct nredir)); - n3->type = NBACKGND; - n3->nredir.n = n2; - n3->nredir.redirect = NULL; - n2 = n3; + if (n2->type != NREDIR) { + n3 = stalloc(sizeof(struct nredir)); + n3->nredir.n = n2; + n3->nredir.redirect = NULL; + n2 = n3; + } + n2->type = NBACKGND; } } if (n1 == NULL) { n1 = n2; - } else { - n3 = (union node *) stalloc(sizeof(struct nbinary)); + } + else { + n3 = (union node *)stalloc(sizeof (struct nbinary)); n3->type = NSEMI; n3->nbinary.ch1 = n1; n3->nbinary.ch2 = n2; @@ -9247,12 +9288,12 @@ static union node *list(int nlflag) case TNL: if (tok == TNL) { parseheredoc(); - if (nlflag) + if (nlflag == 1) return n1; } else { tokpushback++; } - checkkwd = 2; + checkkwd = CHKNL | CHKKWD | CHKALIAS; if (peektoken()) return n1; break; @@ -9260,10 +9301,10 @@ static union node *list(int nlflag) if (heredoclist) parseheredoc(); else - pungetc(); /* push back EOF on input */ + pungetc(); /* push back EOF on input */ return n1; default: - if (nlflag) + if (nlflag == 1) synexpect(-1); tokpushback++; return n1; @@ -9273,12 +9314,12 @@ static union node *list(int nlflag) -static union node *andor() +static union node * +andor(void) { union node *n1, *n2, *n3; int t; - checkkwd = 1; n1 = pipeline(); for (;;) { if ((t = readtoken()) == TAND) { @@ -9289,9 +9330,9 @@ static union node *andor() tokpushback++; return n1; } - checkkwd = 2; + checkkwd = CHKNL | CHKKWD | CHKALIAS; n2 = pipeline(); - n3 = (union node *) stalloc(sizeof(struct nbinary)); + n3 = (union node *)stalloc(sizeof (struct nbinary)); n3->type = t; n3->nbinary.ch1 = n1; n3->nbinary.ch2 = n2; @@ -9301,7 +9342,8 @@ static union node *andor() -static union node *pipeline() +static union node * +pipeline(void) { union node *n1, *n2, *pipenode; struct nodelist *lp, *prev; @@ -9311,21 +9353,21 @@ static union node *pipeline() TRACE(("pipeline: entered\n")); if (readtoken() == TNOT) { negate = !negate; - checkkwd = 1; + checkkwd = CHKKWD | CHKALIAS; } else tokpushback++; n1 = command(); if (readtoken() == TPIPE) { - pipenode = (union node *) stalloc(sizeof(struct npipe)); + pipenode = (union node *)stalloc(sizeof (struct npipe)); pipenode->type = NPIPE; pipenode->npipe.backgnd = 0; - lp = (struct nodelist *) stalloc(sizeof(struct nodelist)); + lp = (struct nodelist *)stalloc(sizeof (struct nodelist)); pipenode->npipe.cmdlist = lp; lp->n = n1; do { prev = lp; - lp = (struct nodelist *) stalloc(sizeof(struct nodelist)); - checkkwd = 2; + lp = (struct nodelist *)stalloc(sizeof (struct nodelist)); + checkkwd = CHKNL | CHKKWD | CHKALIAS; lp->n = command(); prev->next = lp; } while (readtoken() == TPIPE); @@ -9334,7 +9376,7 @@ static union node *pipeline() } tokpushback++; if (negate) { - n2 = (union node *) stalloc(sizeof(struct nnot)); + n2 = (union node *)stalloc(sizeof (struct nnot)); n2->type = NNOT; n2->nnot.com = n1; return n2; @@ -9344,29 +9386,25 @@ static union node *pipeline() -static union node *command(void) +static union node * +command(void) { union node *n1, *n2; union node *ap, **app; union node *cp, **cpp; union node *redir, **rpp; + union node **rpp2; int t; redir = NULL; - n1 = NULL; - rpp = &redir; - - /* Check for redirection which may precede command */ - while (readtoken() == TREDIR) { - *rpp = n2 = redirnode; - rpp = &n2->nfile.next; - parsefname(); - } - tokpushback++; + rpp2 = &redir; switch (readtoken()) { + default: + synexpect(-1); + /* NOTREACHED */ case TIF: - n1 = (union node *) stalloc(sizeof(struct nif)); + n1 = (union node *)stalloc(sizeof (struct nif)); n1->type = NIF; n1->nif.test = list(0); if (readtoken() != TTHEN) @@ -9374,7 +9412,7 @@ static union node *command(void) n1->nif.ifpart = list(0); n2 = n1; while (readtoken() == TELIF) { - n2->nif.elsepart = (union node *) stalloc(sizeof(struct nif)); + n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif)); n2 = n2->nif.elsepart; n2->type = NIF; n2->nif.test = list(0); @@ -9388,38 +9426,33 @@ static union node *command(void) n2->nif.elsepart = NULL; tokpushback++; } - if (readtoken() != TFI) - synexpect(TFI); - checkkwd = 1; + t = TFI; break; case TWHILE: - case TUNTIL:{ + case TUNTIL: { int got; - n1 = (union node *) stalloc(sizeof(struct nbinary)); - n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL; + n1 = (union node *)stalloc(sizeof (struct nbinary)); + n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL; n1->nbinary.ch1 = list(0); - if ((got = readtoken()) != TDO) { - TRACE(("expecting DO got %s %s\n", tokname(got), - got == TWORD ? wordtext : "")); + if ((got=readtoken()) != TDO) { +TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : "")); synexpect(TDO); } n1->nbinary.ch2 = list(0); - if (readtoken() != TDONE) - synexpect(TDONE); - checkkwd = 1; + t = TDONE; break; } case TFOR: - if (readtoken() != TWORD || quoteflag || !goodname(wordtext)) + if (readtoken() != TWORD || quoteflag || ! goodname(wordtext)) synerror("Bad for loop variable"); - n1 = (union node *) stalloc(sizeof(struct nfor)); + n1 = (union node *)stalloc(sizeof (struct nfor)); n1->type = NFOR; n1->nfor.var = wordtext; - checkkwd = 1; + checkkwd = CHKKWD | CHKALIAS; if (readtoken() == TIN) { app = ≈ while (readtoken() == TWORD) { - n2 = (union node *) stalloc(sizeof(struct narg)); + n2 = (union node *)stalloc(sizeof (struct narg)); n2->type = NARG; n2->narg.text = wordtext; n2->narg.backquote = backquotelist; @@ -9431,12 +9464,9 @@ static union node *command(void) if (lasttoken != TNL && lasttoken != TSEMI) synexpect(-1); } else { - static char argvars[5] = { CTLVAR, VSNORMAL | VSQUOTE, - '@', '=', '\0' - }; - n2 = (union node *) stalloc(sizeof(struct narg)); + n2 = (union node *)stalloc(sizeof (struct narg)); n2->type = NARG; - n2->narg.text = argvars; + n2->narg.text = (char *)dolatstr; n2->narg.backquote = NULL; n2->narg.next = NULL; n1->nfor.args = n2; @@ -9447,43 +9477,43 @@ static union node *command(void) if (lasttoken != TNL && lasttoken != TSEMI) tokpushback++; } - checkkwd = 2; + checkkwd = CHKNL | CHKKWD | CHKALIAS; if (readtoken() != TDO) synexpect(TDO); n1->nfor.body = list(0); - if (readtoken() != TDONE) - synexpect(TDONE); - checkkwd = 1; + t = TDONE; break; case TCASE: - n1 = (union node *) stalloc(sizeof(struct ncase)); + n1 = (union node *)stalloc(sizeof (struct ncase)); n1->type = NCASE; if (readtoken() != TWORD) synexpect(TWORD); - n1->ncase.expr = n2 = (union node *) stalloc(sizeof(struct narg)); + n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg)); n2->type = NARG; n2->narg.text = wordtext; n2->narg.backquote = backquotelist; n2->narg.next = NULL; do { - checkkwd = 1; + checkkwd = CHKKWD | CHKALIAS; } while (readtoken() == TNL); if (lasttoken != TIN) - synerror("expecting \"in\""); + synexpect(TIN); cpp = &n1->ncase.cases; - checkkwd = 2, readtoken(); - do { +next_case: + checkkwd = CHKNL | CHKKWD; + t = readtoken(); + while(t != TESAC) { if (lasttoken == TLP) readtoken(); - *cpp = cp = (union node *) stalloc(sizeof(struct nclist)); + *cpp = cp = (union node *)stalloc(sizeof (struct nclist)); cp->type = NCLIST; app = &cp->nclist.pattern; for (;;) { - *app = ap = (union node *) stalloc(sizeof(struct narg)); + *app = ap = (union node *)stalloc(sizeof (struct narg)); ap->type = NARG; ap->narg.text = wordtext; ap->narg.backquote = backquotelist; - if (checkkwd = 2, readtoken() != TPIPE) + if (readtoken() != TPIPE) break; app = &ap->narg.next; readtoken(); @@ -9491,59 +9521,44 @@ static union node *command(void) ap->narg.next = NULL; if (lasttoken != TRP) synexpect(TRP); - cp->nclist.body = list(0); + cp->nclist.body = list(2); + + cpp = &cp->nclist.next; - checkkwd = 2; + checkkwd = CHKNL | CHKKWD; if ((t = readtoken()) != TESAC) { if (t != TENDCASE) synexpect(TENDCASE); else - checkkwd = 2, readtoken(); + goto next_case; } - cpp = &cp->nclist.next; - } while (lasttoken != TESAC); + } *cpp = NULL; - checkkwd = 1; - break; + goto redir; case TLP: - n1 = (union node *) stalloc(sizeof(struct nredir)); + n1 = (union node *)stalloc(sizeof (struct nredir)); n1->type = NSUBSHELL; n1->nredir.n = list(0); n1->nredir.redirect = NULL; - if (readtoken() != TRP) - synexpect(TRP); - checkkwd = 1; + t = TRP; break; case TBEGIN: n1 = list(0); - if (readtoken() != TEND) - synexpect(TEND); - checkkwd = 1; + t = TEND; 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 TWORD: + case TREDIR: tokpushback++; - n1 = simplecmd(rpp, redir); - return n1; - default: - synexpect(-1); - /* NOTREACHED */ + return simplecmd(); } + if (readtoken() != t) + synexpect(t); + +redir: /* Now check for redirection which may follow command */ + checkkwd = CHKKWD | CHKALIAS; + rpp = rpp2; while (readtoken() == TREDIR) { *rpp = n2 = redirnode; rpp = &n2->nfile.next; @@ -9553,7 +9568,7 @@ static union node *command(void) *rpp = NULL; if (redir) { if (n1->type != NSUBSHELL) { - n2 = (union node *) stalloc(sizeof(struct nredir)); + n2 = (union node *)stalloc(sizeof (struct nredir)); n2->type = NREDIR; n2->nredir.n = n1; n1 = n2; @@ -9565,56 +9580,65 @@ static union node *command(void) } -static union node *simplecmd(union node **rpp, union node *redir) -{ +static union node * +simplecmd(void) { union node *args, **app; union node *n = NULL; union node *vars, **vpp; - union node **orig_rpp; + union node **rpp, *redir; + int savecheckkwd; args = NULL; app = &args; vars = NULL; vpp = &vars; + redir = NULL; + rpp = &redir; - /* If we don't have any redirections already, then we must reset - rpp to be the address of the local redir variable. */ - if (redir == 0) - rpp = &redir; - /* We save the incoming value, because we need this for shell - functions. There can not be a redirect or an argument between - the function name and the open parenthesis. */ - orig_rpp = rpp; - - checkalias = 2; + savecheckkwd = CHKALIAS; for (;;) { + checkkwd = savecheckkwd; switch (readtoken()) { case TWORD: - case TASSIGN: - n = (union node *) stalloc(sizeof(struct narg)); + n = (union node *)stalloc(sizeof (struct narg)); n->type = NARG; n->narg.text = wordtext; n->narg.backquote = backquotelist; - if (lasttoken == TWORD) { - *app = n; - app = &n->narg.next; - } else { + if (savecheckkwd && isassignment(wordtext)) { *vpp = n; vpp = &n->narg.next; + } else { + *app = n; + app = &n->narg.next; + savecheckkwd = 0; } break; case TREDIR: *rpp = n = redirnode; rpp = &n->nfile.next; - parsefname(); /* read name of redirection file */ + parsefname(); /* read name of redirection file */ break; case TLP: - if (args && app == &args->narg.next && !vars && rpp == orig_rpp) { + if ( + args && app == &args->narg.next && + !vars && !redir + ) { + struct builtincmd *bcmd; + const char *name; + /* We have a function */ if (readtoken() != TRP) synexpect(TRP); + name = n->narg.text; + if ( + !goodname(name) || ( + (bcmd = find_builtin(name)) && + IS_BUILTIN_SPECIAL(bcmd) + ) + ) + synerror("Bad function name"); n->type = NDEFUN; - checkkwd = 2; + checkkwd = CHKNL | CHKKWD | CHKALIAS; n->narg.next = command(); return n; } @@ -9624,24 +9648,24 @@ static union node *simplecmd(union node **rpp, union node *redir) goto out; } } - out: +out: *app = NULL; *vpp = NULL; *rpp = NULL; - n = (union node *) stalloc(sizeof(struct ncmd)); + n = (union node *)stalloc(sizeof (struct ncmd)); n->type = NCMD; - n->ncmd.backgnd = 0; n->ncmd.args = args; n->ncmd.assign = vars; n->ncmd.redirect = redir; return n; } -static union node *makename(void) +static union node * +makename(void) { union node *n; - n = (union node *) stalloc(sizeof(struct narg)); + n = (union node *)stalloc(sizeof (struct narg)); n->type = NARG; n->narg.next = NULL; n->narg.text = wordtext; @@ -9649,7 +9673,7 @@ static union node *makename(void) return n; } -static void fixredir(union node *n, const char *text, int err) +void fixredir(union node *n, const char *text, int err) { TRACE(("Fix redir %s %d\n", text, err)); if (!err) @@ -9669,7 +9693,8 @@ static void fixredir(union node *n, const char *text, int err) } -static void parsefname(void) +static void +parsefname(void) { union node *n = redirnode; @@ -9683,12 +9708,7 @@ static void parsefname(void) if (quoteflag == 0) n->type = NXHERE; TRACE(("Here document %d\n", n->type)); - if (here->striptabs) { - while (*wordtext == '\t') - wordtext++; - } - if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0 - || i > EOFMARKLEN) + if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN) synerror("Illegal eof marker for << redirection"); rmescapes(wordtext); here->eofmark = wordtext; @@ -9696,7 +9716,7 @@ static void parsefname(void) if (heredoclist == NULL) heredoclist = here; else { - for (p = heredoclist; p->next; p = p->next); + for (p = heredoclist ; p->next ; p = p->next); p->next = here; } } else if (n->type == NTOFD || n->type == NFROMFD) { @@ -9711,30 +9731,33 @@ static void parsefname(void) * Input any here documents. */ -static void parseheredoc() +static void +parseheredoc(void) { struct heredoc *here; union node *n; - while (heredoclist) { - here = heredoclist; - heredoclist = here->next; + here = heredoclist; + heredoclist = 0; + + while (here) { if (needprompt) { setprompt(2); needprompt = 0; } - readtoken1(pgetc(), here->here->type == NHERE ? SQSYNTAX : DQSYNTAX, - here->eofmark, here->striptabs); - n = (union node *) stalloc(sizeof(struct narg)); + readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX, + here->eofmark, here->striptabs); + n = (union node *)stalloc(sizeof (struct narg)); n->narg.type = NARG; n->narg.next = NULL; n->narg.text = wordtext; n->narg.backquote = backquotelist; here->here->nhere.doc = n; + here = here->next; } } -static char peektoken() +static char peektoken(void) { int t; @@ -9743,83 +9766,65 @@ static char peektoken() return tokname_array[t][0]; } -static int readtoken() +static int +readtoken(void) { int t; - - int savecheckalias = checkalias; - -#ifdef CONFIG_ASH_ALIAS - int savecheckkwd = checkkwd; - struct alias *ap; -#endif - #ifdef DEBUG int alreadyseen = tokpushback; #endif #ifdef CONFIG_ASH_ALIAS - top: +top: #endif t = xxreadtoken(); - checkalias = savecheckalias; - - if (checkkwd) { - /* - * eat newlines - */ - if (checkkwd == 2) { - checkkwd = 0; - while (t == TNL) { - parseheredoc(); - t = xxreadtoken(); - } + /* + * eat newlines + */ + if (checkkwd & CHKNL) { + while (t == TNL) { + parseheredoc(); + t = xxreadtoken(); } - checkkwd = 0; - /* - * check for keywords - */ - if (t == TWORD && !quoteflag) { - const char *const *pp; + } - if ((pp = findkwd(wordtext))) { - lasttoken = t = pp - tokname_array; - TRACE(("keyword %s recognized\n", tokname(t))); - goto out; - } - } + if (t != TWORD || quoteflag) { + goto out; } + /* + * check for keywords + */ + if (checkkwd & CHKKWD) { + const char *const *pp; - if (t != TWORD) { - if (t != TREDIR) { - checkalias = 0; + if ((pp = findkwd(wordtext))) { + lasttoken = t = pp - tokname_array; + TRACE(("keyword %s recognized\n", tokname(t))); + goto out; } - } else if (checkalias == 2 && isassignment(wordtext)) { - lasttoken = t = TASSIGN; - } else if (checkalias) { + } + + if (checkkwd & CHKALIAS) { #ifdef CONFIG_ASH_ALIAS - if (!quoteflag && (ap = *__lookupalias(wordtext)) != NULL - && !(ap->flag & ALIASINUSE)) { + struct alias *ap; + if ((ap = lookupalias(wordtext, 1)) != NULL) { if (*ap->val) { - pushstring(ap->val, strlen(ap->val), ap); + pushstring(ap->val, ap); } - checkkwd = savecheckkwd; goto top; } #endif - checkalias = 0; } - out: +out: + checkkwd = 0; #ifdef DEBUG if (!alreadyseen) - TRACE(("token %s %s\n", tokname(t), t == TWORD - || t == TASSIGN ? wordtext : "")); + TRACE(("token %s %s\n", tokname(t), t == TWORD ? wordtext : "")); else - TRACE(("reread token %s %s\n", tokname(t), t == TWORD - || t == TASSIGN ? wordtext : "")); + TRACE(("reread token %s %s\n", tokname(t), t == TWORD ? wordtext : "")); #endif return (t); } @@ -9843,89 +9848,10 @@ static int readtoken() * have parseword (readtoken1?) handle both words and redirection.] */ -#define NEW_xxreadtoken -#ifdef NEW_xxreadtoken - -static const char xxreadtoken_chars[] = "\n()&|;"; /* singles must be first! */ -static const char xxreadtoken_tokens[] = { - TNL, TLP, TRP, /* only single occurrence allowed */ - TBACKGND, TPIPE, TSEMI, /* if single occurrence */ - TEOF, /* corresponds to trailing nul */ - TAND, TOR, TENDCASE, /* if double occurrence */ -}; - -#define xxreadtoken_doubles \ - (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars)) -#define xxreadtoken_singles \ - (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1) - -static int xxreadtoken() -{ - int c; - - if (tokpushback) { - tokpushback = 0; - return lasttoken; - } - if (needprompt) { - setprompt(2); - needprompt = 0; - } - startlinno = plinno; - for (;;) { /* until token or start of word found */ - c = pgetc_macro(); - - if ((c != ' ') && (c != '\t') -#ifdef CONFIG_ASH_ALIAS - && (c != PEOA) -#endif - ) { - if (c == '#') { - while ((c = pgetc()) != '\n' && c != PEOF); - pungetc(); - } else if (c == '\\') { - if (pgetc() != '\n') { - pungetc(); - goto READTOKEN1; - } - startlinno = ++plinno; - setprompt(doprompt ? 2 : 0); - } else { - const char *p - = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1; - - if (c != PEOF) { - if (c == '\n') { - plinno++; - needprompt = doprompt; - } - - p = strchr(xxreadtoken_chars, c); - if (p == NULL) { - READTOKEN1: - return readtoken1(c, BASESYNTAX, (char *) NULL, 0); - } - - if (p - xxreadtoken_chars >= xxreadtoken_singles) { - if (pgetc() == *p) { /* double occurrence? */ - p += xxreadtoken_doubles + 1; - } else { - pungetc(); - } - } - } - - return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars]; - } - } - } -} - - -#else #define RETURN(token) return lasttoken = token -static int xxreadtoken() +static int +xxreadtoken(void) { int c; @@ -9938,11 +9864,10 @@ static int xxreadtoken() needprompt = 0; } startlinno = plinno; - for (;;) { /* until token or start of word found */ + for (;;) { /* until token or start of word found */ c = pgetc_macro(); switch (c) { - case ' ': - case '\t': + case ' ': case '\t': #ifdef CONFIG_ASH_ALIAS case PEOA: #endif @@ -9956,8 +9881,6 @@ static int xxreadtoken() startlinno = ++plinno; if (doprompt) setprompt(2); - else - setprompt(0); continue; } pungetc(); @@ -9991,11 +9914,12 @@ static int xxreadtoken() goto breakloop; } } - breakloop: - return readtoken1(c, BASESYNTAX, (char *) NULL, 0); +breakloop: + return readtoken1(c, BASESYNTAX, (char *)NULL, 0); #undef RETURN } -#endif + + /* * If eofmark is NULL, read a word or a redirection symbol. If eofmark @@ -10017,7 +9941,7 @@ static int xxreadtoken() #define PARSEARITH() {goto parsearith; parsearith_return:;} static int -readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) +readtoken1(int firstc, int syntax, char *eofmark, int striptabs) { int c = firstc; char *out; @@ -10026,13 +9950,12 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) struct nodelist *bqlist; int quotef; int dblquote; - 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 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; - int prevsyntax; /* syntax before arithmetic */ - + int prevsyntax; /* syntax before arithmetic */ #if __GNUC__ /* Avoid longjmp clobbering */ (void) &out; @@ -10059,81 +9982,83 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) dqvarnest = 0; STARTSTACKSTR(out); - loop:{ /* for each line, until end of word */ - CHECKEND(); /* set c to PEOF if at end of here document */ - for (;;) { /* until end of line or end of word */ - CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */ - switch (SIT(c, syntax)) { - case CNL: /* '\n' */ + loop: { /* for each line, until end of word */ + CHECKEND(); /* set c to PEOF if at end of here document */ + for (;;) { /* until end of line or end of word */ + CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */ + switch(SIT(c, syntax)) { + case CNL: /* '\n' */ if (syntax == BASESYNTAX) - goto endword; /* exit outer loop */ + goto endword; /* exit outer loop */ USTPUTC(c, out); plinno++; if (doprompt) setprompt(2); - else - setprompt(0); c = pgetc(); - goto loop; /* continue outer loop */ + goto loop; /* continue outer loop */ case CWORD: USTPUTC(c, out); break; case CCTL: - if ((eofmark == NULL || dblquote) && dqvarnest == 0) + if (eofmark == NULL || dblquote) USTPUTC(CTLESC, out); USTPUTC(c, out); break; - case CBACK: /* backslash */ + case CBACK: /* backslash */ c = pgetc2(); if (c == PEOF) { + USTPUTC(CTLESC, out); USTPUTC('\\', out); pungetc(); } else if (c == '\n') { if (doprompt) setprompt(2); - else - setprompt(0); } else { - if (dblquote && c != '\\' && c != '`' && c != '$' - && (c != '"' || eofmark != NULL)) + if ( + dblquote && + c != '\\' && c != '`' && + c != '$' && ( + c != '"' || + eofmark != NULL + ) + ) { + USTPUTC(CTLESC, out); USTPUTC('\\', out); + } if (SIT(c, SQSYNTAX) == CCTL) USTPUTC(CTLESC, out); - else if (eofmark == NULL) - USTPUTC(CTLQUOTEMARK, out); USTPUTC(c, out); quotef++; } break; case CSQUOTE: - if (eofmark == NULL) - USTPUTC(CTLQUOTEMARK, out); syntax = SQSYNTAX; +quotemark: + if (eofmark == NULL) { + USTPUTC(CTLQUOTEMARK, out); + } break; case CDQUOTE: - if (eofmark == NULL) - USTPUTC(CTLQUOTEMARK, out); syntax = DQSYNTAX; dblquote = 1; - break; + goto quotemark; case CENDQUOTE: - if (eofmark != NULL && arinest == 0 && varnest == 0) { + if (eofmark != NULL && arinest == 0 && + varnest == 0) { USTPUTC(c, out); } else { - if (arinest) { - syntax = ARISYNTAX; - dblquote = 0; - } else if (eofmark == NULL && dqvarnest == 0) { + if (dqvarnest == 0) { syntax = BASESYNTAX; dblquote = 0; } quotef++; + goto quotemark; } break; - case CVAR: /* '$' */ - PARSESUB(); /* parse substitution */ + case CVAR: /* '$' */ + PARSESUB(); /* parse substitution */ break; - case CENDVAR: /* '}' */ + case CENDVAR: /* '}' */ if (varnest > 0) { varnest--; if (dqvarnest > 0) { @@ -10145,11 +10070,11 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) } break; #ifdef CONFIG_ASH_MATH_SUPPORT - case CLP: /* '(' in arithmetic */ + case CLP: /* '(' in arithmetic */ parenlevel++; USTPUTC(c, out); break; - case CRP: /* ')' in arithmetic */ + case CRP: /* ')' in arithmetic */ if (parenlevel > 0) { USTPUTC(c, out); --parenlevel; @@ -10175,16 +10100,16 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) } break; #endif - case CBQUOTE: /* '`' */ + case CBQUOTE: /* '`' */ PARSEBACKQOLD(); break; case CENDFILE: - goto endword; /* exit outer loop */ + goto endword; /* exit outer loop */ case CIGN: break; default: if (varnest == 0) - goto endword; /* exit outer loop */ + goto endword; /* exit outer loop */ #ifdef CONFIG_ASH_ALIAS if (c != PEOA) #endif @@ -10194,21 +10119,26 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) c = pgetc_macro(); } } - endword: +endword: +#ifdef CONFIG_ASH_MATH_SUPPORT if (syntax == ARISYNTAX) synerror("Missing '))'"); - if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL) +#endif + if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL) synerror("Unterminated quoted string"); if (varnest != 0) { startlinno = plinno; + /* { */ synerror("Missing '}'"); } USTPUTC('\0', out); - len = out - stackblock(); + len = out - (char *)stackblock(); out = stackblock(); if (eofmark == NULL) { if ((c == '>' || c == '<') - && quotef == 0 && len <= 2 && (*out == '\0' || is_digit(*out))) { + && quotef == 0 + && len <= 2 + && (*out == '\0' || is_digit(*out))) { PARSEREDIR(); return lasttoken = TREDIR; } else { @@ -10230,36 +10160,36 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) * we are at the end of the here document, this routine sets the c to PEOF. */ - checkend:{ - if (eofmark) { +checkend: { + if (eofmark) { #ifdef CONFIG_ASH_ALIAS - if (c == PEOA) { - c = pgetc2(); - } + if (c == PEOA) { + c = pgetc2(); + } #endif - if (striptabs) { - while (c == '\t') { - c = pgetc2(); - } + if (striptabs) { + while (c == '\t') { + c = pgetc2(); } - if (c == *eofmark) { - if (pfgets(line, sizeof line) != NULL) { - const char *p, *q; - - p = line; - for (q = eofmark + 1; *q && *p == *q; p++, q++); - if (*p == '\n' && *q == '\0') { - c = PEOF; - plinno++; - needprompt = doprompt; - } else { - pushstring(line, strlen(line), NULL); - } + } + if (c == *eofmark) { + if (pfgets(line, sizeof line) != NULL) { + char *p, *q; + + p = line; + for (q = eofmark + 1 ; *q && *p == *q ; p++, q++); + if (*p == '\n' && *q == '\0') { + c = PEOF; + plinno++; + needprompt = doprompt; + } else { + pushstring(line, NULL); } } } - goto checkend_return; } + goto checkend_return; +} /* @@ -10268,62 +10198,62 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) * first character of the redirection operator. */ - parseredir:{ - char fd = *out; - union node *np; +parseredir: { + char fd = *out; + union node *np; - np = (union node *) stalloc(sizeof(struct nfile)); - if (c == '>') { - np->nfile.fd = 1; - c = pgetc(); - if (c == '>') - np->type = NAPPEND; - else if (c == '&') - np->type = NTOFD; - else if (c == '|') - np->type = NTOOV; - else { - np->type = NTO; + np = (union node *)stalloc(sizeof (struct nfile)); + if (c == '>') { + np->nfile.fd = 1; + c = pgetc(); + if (c == '>') + np->type = NAPPEND; + else if (c == '|') + np->type = NCLOBBER; + else if (c == '&') + np->type = NTOFD; + else { + np->type = NTO; + pungetc(); + } + } else { /* c == '<' */ + np->nfile.fd = 0; + switch (c = pgetc()) { + case '<': + if (sizeof (struct nfile) != sizeof (struct nhere)) { + np = (union node *)stalloc(sizeof (struct nhere)); + np->nfile.fd = 0; + } + np->type = NHERE; + heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc)); + heredoc->here = np; + if ((c = pgetc()) == '-') { + heredoc->striptabs = 1; + } else { + heredoc->striptabs = 0; pungetc(); } - } else { /* c == '<' */ - np->nfile.fd = 0; - switch (c = pgetc()) { - case '<': - if (sizeof(struct nfile) != sizeof(struct nhere)) { - np = (union node *) stalloc(sizeof(struct nhere)); - np->nfile.fd = 0; - } - np->type = NHERE; - heredoc = (struct heredoc *) stalloc(sizeof(struct heredoc)); - heredoc->here = np; - if ((c = pgetc()) == '-') { - heredoc->striptabs = 1; - } else { - heredoc->striptabs = 0; - pungetc(); - } - break; + break; - case '&': - np->type = NFROMFD; - break; + case '&': + np->type = NFROMFD; + break; - case '>': - np->type = NFROMTO; - break; + case '>': + np->type = NFROMTO; + break; - default: - np->type = NFROM; - pungetc(); - break; - } + default: + np->type = NFROM; + pungetc(); + break; } - if (fd != '\0') - np->nfile.fd = digit_val(fd); - redirnode = np; - goto parseredir_return; } + if (fd != '\0') + np->nfile.fd = digit_val(fd); + redirnode = np; + goto parseredir_return; +} /* @@ -10331,76 +10261,85 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) * and nothing else. */ - parsesub:{ - int subtype; - int typeloc; - int flags; - char *p; - static const char types[] = "}-+?="; - - c = pgetc(); - if (c <= PEOA || - (c != '(' && c != '{' && !is_name(c) && !is_special(c)) - ) { - USTPUTC('$', out); +parsesub: { + int subtype; + int typeloc; + int flags; + char *p; + static const char types[] = "}-+?="; + + c = pgetc(); + if ( + c <= PEOA_OR_PEOF || + (c != '(' && c != '{' && !is_name(c) && !is_special(c)) + ) { + USTPUTC('$', out); + pungetc(); + } else if (c == '(') { /* $(command) or $((arith)) */ + if (pgetc() == '(') { +#ifdef CONFIG_ASH_MATH_SUPPORT + PARSEARITH(); +#else + synerror("We unsupport $((arith))"); +#endif + } else { pungetc(); - } else if (c == '(') { /* $(command) or $((arith)) */ - if (pgetc() == '(') { - PARSEARITH(); - } else { - pungetc(); - PARSEBACKQNEW(); + PARSEBACKQNEW(); + } + } else { + USTPUTC(CTLVAR, out); + typeloc = out - (char *)stackblock(); + USTPUTC(VSNORMAL, out); + subtype = VSNORMAL; + if (c == '{') { + c = pgetc(); + if (c == '#') { + if ((c = pgetc()) == '}') + c = '#'; + else + subtype = VSLENGTH; } - } else { - USTPUTC(CTLVAR, out); - typeloc = out - stackblock(); - USTPUTC(VSNORMAL, out); - subtype = VSNORMAL; - if (c == '{') { + else + subtype = 0; + } + if (c > PEOA_OR_PEOF && is_name(c)) { + do { + STPUTC(c, out); c = pgetc(); - if (c == '#') { - if ((c = pgetc()) == '}') - c = '#'; - else - subtype = VSLENGTH; - } else - subtype = 0; - } - if (c > PEOA && is_name(c)) { - do { - STPUTC(c, out); - c = pgetc(); - } while (c > PEOA && is_in_name(c)); - } else if (is_digit(c)) { - do { - USTPUTC(c, out); - c = pgetc(); - } while (is_digit(c)); - } else if (is_special(c)) { - USTPUTC(c, out); + } while (c > PEOA_OR_PEOF && is_in_name(c)); + } else if (is_digit(c)) { + do { + STPUTC(c, out); c = pgetc(); - } else - badsub:synerror("Bad substitution"); - - STPUTC('=', out); - flags = 0; - if (subtype == 0) { - switch (c) { - case ':': - flags = VSNUL; - c = pgetc(); - /*FALLTHROUGH*/ default: - p = strchr(types, c); - if (p == NULL) - goto badsub; - subtype = p - types + VSNORMAL; - break; - case '%': - case '#': + } while (is_digit(c)); + } + else if (is_special(c)) { + USTPUTC(c, out); + c = pgetc(); + } + else +badsub: synerror("Bad substitution"); + + STPUTC('=', out); + flags = 0; + if (subtype == 0) { + switch (c) { + case ':': + flags = VSNUL; + c = pgetc(); + /*FALLTHROUGH*/ + default: + p = strchr(types, c); + if (p == NULL) + goto badsub; + subtype = p - types + VSNORMAL; + break; + case '%': + case '#': { int cc = c; - - subtype = c == '#' ? VSTRIMLEFT : VSTRIMRIGHT; + subtype = c == '#' ? VSTRIMLEFT : + VSTRIMRIGHT; c = pgetc(); if (c == cc) subtype++; @@ -10408,22 +10347,22 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) pungetc(); break; } - } - } else { - pungetc(); } - if (dblquote || arinest) - flags |= VSQUOTE; - *(stackblock() + typeloc) = subtype | flags; - if (subtype != VSNORMAL) { - varnest++; - if (dblquote) { - dqvarnest++; - } + } else { + pungetc(); + } + if (dblquote || arinest) + flags |= VSQUOTE; + *((char *)stackblock() + typeloc) = subtype | flags; + if (subtype != VSNORMAL) { + varnest++; + if (dblquote || arinest) { + dqvarnest++; } } - goto parsesub_return; } + goto parsesub_return; +} /* @@ -10433,182 +10372,183 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) * characters on the top of the stack which must be preserved. */ - parsebackq:{ - struct nodelist **nlpp; - int savepbq; - union node *n; - char *volatile str; - struct jmploc jmploc; - struct jmploc *volatile savehandler; - int savelen; - int saveprompt; - +parsebackq: { + struct nodelist **nlpp; + int savepbq; + union node *n; + char *volatile str; + struct jmploc jmploc; + struct jmploc *volatile savehandler; + size_t savelen; + int saveprompt; #ifdef __GNUC__ - (void) &saveprompt; + (void) &saveprompt; #endif - savepbq = parsebackquote; - if (setjmp(jmploc.loc)) { - free(str); - parsebackquote = 0; - handler = savehandler; - longjmp(handler->loc, 1); - } - INTOFF; - str = NULL; - savelen = out - stackblock(); - if (savelen > 0) { - str = xmalloc(savelen); - memcpy(str, stackblock(), savelen); - } - savehandler = handler; - handler = &jmploc; - INTON; - if (oldstyle) { - /* We must read until the closing backquote, giving special - treatment to some slashes, and then push the string and - reread it as input, interpreting it normally. */ - char *pout; - int pc; - int psavelen; - char *pstr; + savepbq = parsebackquote; + if (setjmp(jmploc.loc)) { + if (str) + ckfree(str); + parsebackquote = 0; + handler = savehandler; + longjmp(handler->loc, 1); + } + INTOFF; + str = NULL; + savelen = out - (char *)stackblock(); + if (savelen > 0) { + str = ckmalloc(savelen); + memcpy(str, stackblock(), savelen); + } + savehandler = handler; + handler = &jmploc; + INTON; + if (oldstyle) { + /* We must read until the closing backquote, giving special + treatment to some slashes, and then push the string and + reread it as input, interpreting it normally. */ + char *pout; + int pc; + size_t psavelen; + char *pstr; - STARTSTACKSTR(pout); - for (;;) { - if (needprompt) { - setprompt(2); - needprompt = 0; + STARTSTACKSTR(pout); + for (;;) { + if (needprompt) { + setprompt(2); + needprompt = 0; + } + switch (pc = pgetc()) { + case '`': + goto done; + + case '\\': + if ((pc = pgetc()) == '\n') { + plinno++; + if (doprompt) + setprompt(2); + /* + * If eating a newline, avoid putting + * the newline into the new character + * stream (via the STPUTC after the + * switch). + */ + continue; } - switch (pc = pgetc()) { - case '`': - goto done; - - case '\\': - if ((pc = pgetc()) == '\n') { - plinno++; - if (doprompt) - setprompt(2); - else - setprompt(0); - /* - * If eating a newline, avoid putting - * the newline into the new character - * stream (via the STPUTC after the - * switch). - */ - continue; - } - if (pc != '\\' && pc != '`' && pc != '$' - && (!dblquote || pc != '"')) - STPUTC('\\', pout); - if (pc > PEOA) { - break; - } - /* fall through */ + if (pc != '\\' && pc != '`' && pc != '$' + && (!dblquote || pc != '"')) + STPUTC('\\', pout); + if (pc > PEOA_OR_PEOF) { + break; + } + /* fall through */ - case PEOF: + case PEOF: #ifdef CONFIG_ASH_ALIAS - case PEOA: + case PEOA: #endif - startlinno = plinno; - synerror("EOF in backquote substitution"); + startlinno = plinno; + synerror("EOF in backquote substitution"); - case '\n': - plinno++; - needprompt = doprompt; - break; + case '\n': + plinno++; + needprompt = doprompt; + break; - default: - break; - } - STPUTC(pc, pout); - } - done: - STPUTC('\0', pout); - psavelen = pout - stackblock(); - if (psavelen > 0) { - pstr = grabstackstr(pout); - setinputstring(pstr); + default: + break; } + STPUTC(pc, pout); } - nlpp = &bqlist; - while (*nlpp) - nlpp = &(*nlpp)->next; - *nlpp = (struct nodelist *) stalloc(sizeof(struct nodelist)); - (*nlpp)->next = NULL; - parsebackquote = oldstyle; - - if (oldstyle) { - saveprompt = doprompt; - doprompt = 0; +done: + STPUTC('\0', pout); + psavelen = pout - (char *)stackblock(); + if (psavelen > 0) { + pstr = grabstackstr(pout); + setinputstring(pstr); } + } + nlpp = &bqlist; + while (*nlpp) + nlpp = &(*nlpp)->next; + *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist)); + (*nlpp)->next = NULL; + parsebackquote = oldstyle; - n = list(0); + if (oldstyle) { + saveprompt = doprompt; + doprompt = 0; + } - if (oldstyle) - doprompt = saveprompt; - else { - if (readtoken() != TRP) - synexpect(TRP); - } + n = list(2); - (*nlpp)->n = n; - if (oldstyle) { - /* - * Start reading from old file again, ignoring any pushed back - * tokens left from the backquote parsing - */ - popfile(); - tokpushback = 0; - } - while (stackblocksize() <= savelen) - growstackblock(); - STARTSTACKSTR(out); - if (str) { - memcpy(out, str, savelen); - STADJUST(savelen, out); - INTOFF; - free(str); - str = NULL; - INTON; - } - parsebackquote = savepbq; - handler = savehandler; - if (arinest || dblquote) - USTPUTC(CTLBACKQ | CTLQUOTE, out); - else - USTPUTC(CTLBACKQ, out); - if (oldstyle) - goto parsebackq_oldreturn; - else - goto parsebackq_newreturn; + if (oldstyle) + doprompt = saveprompt; + else { + if (readtoken() != TRP) + synexpect(TRP); } + (*nlpp)->n = n; + if (oldstyle) { + /* + * Start reading from old file again, ignoring any pushed back + * tokens left from the backquote parsing + */ + popfile(); + tokpushback = 0; + } + while (stackblocksize() <= savelen) + growstackblock(); + STARTSTACKSTR(out); + if (str) { + memcpy(out, str, savelen); + STADJUST(savelen, out); + INTOFF; + ckfree(str); + str = NULL; + INTON; + } + parsebackquote = savepbq; + handler = savehandler; + if (arinest || dblquote) + USTPUTC(CTLBACKQ | CTLQUOTE, out); + else + USTPUTC(CTLBACKQ, out); + if (oldstyle) + goto parsebackq_oldreturn; + else + goto parsebackq_newreturn; +} + +#ifdef CONFIG_ASH_MATH_SUPPORT /* * Parse an arithmetic expansion (indicate start of one and set state) */ - parsearith:{ +parsearith: { - if (++arinest == 1) { - prevsyntax = syntax; - syntax = ARISYNTAX; - USTPUTC(CTLARI, out); - if (dblquote) - USTPUTC('"', out); - else - USTPUTC(' ', out); - } else { - /* - * we collapse embedded arithmetic expansion to - * parenthesis, which should be equivalent - */ - USTPUTC('(', out); - } - goto parsearith_return; + if (++arinest == 1) { + prevsyntax = syntax; + syntax = ARISYNTAX; + USTPUTC(CTLARI, out); + if (dblquote) + USTPUTC('"',out); + else + USTPUTC(' ',out); + } else { + /* + * we collapse embedded arithmetic expansion to + * parenthesis, which should be equivalent + */ + USTPUTC('(', out); } + goto parsearith_return; +} +#endif + +} /* end of readtoken */ -} /* end of readtoken */ /* @@ -10616,7 +10556,8 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs) * or backquotes). */ -static int noexpand(char *text) +static int +noexpand(char *text) { char *p; char c; @@ -10635,22 +10576,23 @@ static int noexpand(char *text) /* - * Return true if the argument is a legal variable name (a letter or - * underscore followed by zero or more letters, underscores, and digits). + * Return of a legal variable name (a letter or underscore followed by zero or + * more letters, underscores, and digits). */ -static int goodname(const char *name) -{ - const char *p; +char * +endofname(const char *name) + { + char *p; - p = name; - if (!is_name(*p)) - return 0; + p = (char *) name; + if (! is_name(*p)) + return p; while (*++p) { - if (!is_in_name(*p)) - return 0; + if (! is_in_name(*p)) + break; } - return 1; + return p; } @@ -10672,13 +10614,10 @@ static void synexpect(int token) /* NOTREACHED */ } - -static void synerror(const char *msg) +static void +synerror(const char *msg) { - if (commandname) - out2fmt("%s: %d: ", commandname, startlinno); - out2fmt("Syntax error: %s\n", msg); - error((char *) NULL); + error("Syntax error: %s", msg); /* NOTREACHED */ } @@ -10687,9 +10626,10 @@ static void synerror(const char *msg) * called by editline -- any expansions to the prompt * should be added here. */ + static void setprompt(int whichprompt) { - char *prompt; + const char *prompt; switch (whichprompt) { case 1: @@ -10698,30 +10638,39 @@ static void setprompt(int whichprompt) case 2: prompt = ps2val(); break; - default: /* 0 */ - prompt = ""; + default: /* 0 */ + prompt = nullstr; } putprompt(prompt); } +static const char *const *findkwd(const char *s) +{ + return bsearch(s, tokname_array + KWDOFFSET, + (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET, + sizeof(const char *), pstrcmp); +} + +/* $NetBSD: redir.c,v 1.27 2002/11/24 22:35:42 christos Exp $ */ + /* * Code for dealing with input/output redirection. */ -#define EMPTY -2 /* marks an unused slot in redirtab */ +#define EMPTY -2 /* marks an unused slot in redirtab */ #ifndef PIPE_BUF -# define PIPESIZE 4096 /* amount of buffering in a pipe */ +# define PIPESIZE 4096 /* amount of buffering in a pipe */ #else # define PIPESIZE PIPE_BUF #endif - /* * Open a file in noclobber mode. * The code was copied from bash. */ -static inline int noclobberopen(const char *fname) +static inline int +noclobberopen(const char *fname) { int r, fd; struct stat finfo, finfo2; @@ -10744,8 +10693,8 @@ static inline int noclobberopen(const char *fname) * 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); + 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) @@ -10764,8 +10713,8 @@ static inline int noclobberopen(const char *fname) * 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) + 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. */ @@ -10780,10 +10729,11 @@ static inline int noclobberopen(const char *fname) * the pipe without forking. */ -static inline int openhere(const union node *redir) +static inline int +openhere(union node *redir) { int pip[2]; - int len = 0; + size_t len = 0; if (pipe(pip) < 0) error("Pipe call failed"); @@ -10794,7 +10744,7 @@ static inline int openhere(const union node *redir) goto out; } } - if (forkshell((struct job *) NULL, (union node *) NULL, FORK_NOJOB) == 0) { + if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) { close(pip[0]); signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_IGN); @@ -10809,13 +10759,13 @@ static inline int openhere(const union node *redir) expandhere(redir->nhere.doc, pip[1]); _exit(0); } - out: +out: close(pip[1]); return pip[0]; } - -static inline int openredirect(const union node *redir) +static int +openredirect(union node *redir) { char *fname; int f; @@ -10828,7 +10778,7 @@ static inline int openredirect(const union node *redir) break; case NFROMTO: fname = redir->nfile.expfname; - if ((f = open(fname, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0) + if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) goto ecreate; break; case NTO: @@ -10839,26 +10789,16 @@ static inline int openredirect(const union node *redir) goto ecreate; break; } - case NTOOV: + /* FALLTHROUGH */ + case NCLOBBER: fname = redir->nfile.expfname; -#ifdef O_CREAT - if ((f = open(fname, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0) + if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0) goto ecreate; -#else - if ((f = creat(fname, 0666)) < 0) - goto ecreate; -#endif break; case NAPPEND: fname = redir->nfile.expfname; -#ifdef O_APPEND - if ((f = open(fname, O_WRONLY | O_CREAT | O_APPEND, 0666)) < 0) - goto ecreate; -#else - if ((f = open(fname, O_WRONLY)) < 0 && (f = creat(fname, 0666)) < 0) + if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0) goto ecreate; - lseek(f, (off_t) 0, 2); -#endif break; default: #ifdef DEBUG @@ -10876,109 +10816,100 @@ static inline int openredirect(const union node *redir) } return f; - ecreate: +ecreate: error("cannot create %s: %s", fname, errmsg(errno, E_CREAT)); - eopen: +eopen: error("cannot open %s: %s", fname, errmsg(errno, E_OPEN)); } +static inline void +dupredirect(union node *redir, int f) +{ + int fd = redir->nfile.fd; + + if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) { + if (redir->ndup.dupfd >= 0) { /* if not ">&-" */ + copyfd(redir->ndup.dupfd, fd); + } + return; + } + + if (f != fd) { + copyfd(f, fd); + close(f); + } + return; +} /* * Process a list of redirection commands. If the REDIR_PUSH flag is set, * old file descriptors are stashed away so that the redirection can be * undone by calling popredir. If the REDIR_BACKQ flag is set, then the * standard output, and the standard error if it becomes a duplicate of - * stdout. + * stdout, is saved in memory. */ -static void redirect(union node *redir, int flags) +static void +redirect(union node *redir, int flags) { union node *n; - struct redirtab *sv = NULL; + struct redirtab *sv; int i; int fd; int newfd; - int try; - int fd1dup = flags & REDIR_BACKQ;; /* stdout `cmd` redir to pipe */ - - TRACE(("redirect(%s) called\n", - flags & REDIR_PUSH ? "REDIR_PUSH" : "NO_REDIR_PUSH")); - if (flags & REDIR_PUSH) { - sv = xmalloc(sizeof(struct redirtab)); - for (i = 0; i < 10; i++) - sv->renamed[i] = EMPTY; - sv->next = redirlist; - redirlist = sv; + int *p; + nullredirs++; + if (!redir) { + return; } - for (n = redir; n; n = n->nfile.next) { + sv = NULL; + INTOFF; + if (flags & REDIR_PUSH) { + struct redirtab *q; + q = ckmalloc(sizeof (struct redirtab)); + q->next = redirlist; + redirlist = q; + q->nullredirs = nullredirs - 1; + for (i = 0 ; i < 10 ; i++) + q->renamed[i] = EMPTY; + nullredirs = 0; + sv = q; + } + n = redir; + do { fd = n->nfile.fd; - try = 0; if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) && - n->ndup.dupfd == fd) - continue; /* redirect from/to same file descriptor */ + n->ndup.dupfd == fd) + continue; /* redirect from/to same file descriptor */ - INTOFF; newfd = openredirect(n); - if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) { - i = fd; - if (newfd == fd) { - try++; - } else if ((i = fcntl(fd, F_DUPFD, 10)) == -1) { - switch (errno) { - case EBADF: - if (!try) { - dupredirect(n, newfd, fd1dup); - try++; - break; - } - /* FALLTHROUGH */ - default: - if (newfd >= 0) { - close(newfd); - } - INTON; + if (fd == newfd) + continue; + if (sv && *(p = &sv->renamed[fd]) == EMPTY) { + i = fcntl(fd, F_DUPFD, 10); + + if (i == -1) { + i = errno; + if (i != EBADF) { + close(newfd); + errno = i; error("%d: %m", fd); /* NOTREACHED */ } - } - if (!try) { + } else { + *p = i; close(fd); - if (flags & REDIR_PUSH) { - sv->renamed[fd] = i; - } } - } else if (fd != newfd) { + } else { close(fd); } - if (fd == 0) - fd0_redirected++; - if (!try) - dupredirect(n, newfd, fd1dup); - INTON; - } + dupredirect(n, newfd); + } while ((n = n->nfile.next)); + INTON; } -static void dupredirect(const union node *redir, int f, int fd1dup) -{ - int fd = redir->nfile.fd; - if (fd == 1) - fd1dup = 0; - if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) { - if (redir->ndup.dupfd >= 0) { /* if not ">&-" */ - if (redir->ndup.dupfd != 1 || fd1dup != 1) - dup_as_newfd(redir->ndup.dupfd, fd); - } - return; - } - - if (f != fd) { - dup_as_newfd(f, fd); - close(f); - } - return; -} @@ -10986,55 +10917,60 @@ static void dupredirect(const union node *redir, int f, int fd1dup) * Undo the effects of the last redirection. */ -static void popredir(void) +void +popredir(int drop) { - struct redirtab *rp = redirlist; + struct redirtab *rp; int i; + if (--nullredirs >= 0) + return; INTOFF; - for (i = 0; i < 10; i++) { + rp = redirlist; + for (i = 0 ; i < 10 ; i++) { if (rp->renamed[i] != EMPTY) { - if (i == 0) - fd0_redirected--; - close(i); - if (rp->renamed[i] >= 0) { - dup_as_newfd(rp->renamed[i], i); - close(rp->renamed[i]); + if (!drop) { + close(i); + copyfd(rp->renamed[i], i); } + close(rp->renamed[i]); } } redirlist = rp->next; - free(rp); + nullredirs = rp->nullredirs; + ckfree(rp); INTON; } /* + * Undo all redirections. Called on error or interrupt. + */ + +/* * Discard all saved file descriptors. */ -static void clearredir(void) +void +clearredir(int drop) { - struct redirtab *rp; - int i; - - for (rp = redirlist; rp; rp = rp->next) { - for (i = 0; i < 10; i++) { - if (rp->renamed[i] >= 0) { - close(rp->renamed[i]); - } - rp->renamed[i] = EMPTY; - } + for (;;) { + nullredirs = 0; + if (!redirlist) + break; + popredir(drop); } } + /* * Copy a file descriptor to be >= to. Returns -1 * if the source file descriptor is closed, EMPTY if there are no unused * file descriptors left. */ -static int dup_as_newfd(int from, int to) +int +copyfd(int from, int to) { int newfd; @@ -11048,27 +10984,47 @@ static int dup_as_newfd(int from, int to) return newfd; } -#ifdef DEBUG -/* - * Debugging stuff. - */ -static void shtree(union node *, int, char *, FILE *); +int +redirectsafe(union node *redir, int flags) +{ + int err; + volatile int saveint; + struct jmploc *volatile savehandler = handler; + struct jmploc jmploc; + + SAVEINT(saveint); + if (!(err = setjmp(jmploc.loc) * 2)) { + handler = &jmploc; + redirect(redir, flags); + } + handler = savehandler; + if (err && exception != EXERROR) + longjmp(handler->loc, 1); + RESTOREINT(saveint); + return err; +} + +/* $NetBSD: show.c,v 1.24 2003/01/22 20:36:04 dsl Exp $ */ + +#ifdef DEBUG +static void shtree(union node *, int, char *, FILE*); static void shcmd(union node *, FILE *); static void sharg(union node *, FILE *); static void indent(int, char *, FILE *); static void trstring(char *); -#if 0 -static void showtree(node * n) +void +showtree(union node *n) { trputs("showtree called\n"); shtree(n, 1, NULL, stdout); } -#endif -static void shtree(union node *n, int ind, char *pfx, FILE * fp) + +static void +shtree(union node *n, int ind, char *pfx, FILE *fp) { struct nodelist *lp; const char *s; @@ -11077,7 +11033,7 @@ static void shtree(union node *n, int ind, char *pfx, FILE * fp) return; indent(ind, pfx, fp); - switch (n->type) { + switch(n->type) { case NSEMI: s = "; "; goto binop; @@ -11086,10 +11042,10 @@ static void shtree(union node *n, int ind, char *pfx, FILE * fp) goto binop; case NOR: s = " || "; - binop: +binop: shtree(n->nbinary.ch1, ind, NULL, fp); - /* if (ind < 0) */ - fputs(s, fp); + /* if (ind < 0) */ + fputs(s, fp); shtree(n->nbinary.ch2, ind, NULL, fp); break; case NCMD: @@ -11098,7 +11054,7 @@ static void shtree(union node *n, int ind, char *pfx, FILE * fp) putc('\n', fp); break; case NPIPE: - for (lp = n->npipe.cmdlist; lp; lp = lp->next) { + for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) { shcmd(lp->n, fp); if (lp->next) fputs(" | ", fp); @@ -11117,7 +11073,9 @@ static void shtree(union node *n, int ind, char *pfx, FILE * fp) } -static void shcmd(union node *cmd, FILE * fp) + +static void +shcmd(union node *cmd, FILE *fp) { union node *np; int first; @@ -11125,60 +11083,25 @@ static void shcmd(union node *cmd, FILE * fp) int dftfd; first = 1; - for (np = cmd->ncmd.args; np; np = np->narg.next) { - if (!first) + for (np = cmd->ncmd.args ; np ; np = np->narg.next) { + if (! first) putchar(' '); sharg(np, fp); first = 0; } - for (np = cmd->ncmd.redirect; np; np = np->nfile.next) { - if (!first) + for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) { + if (! first) putchar(' '); -#if 1 - s = "*error*"; - dftfd = 0; - if ((np->nfile.type <= NFROMFD) && (np->nfile.type >= NTO)) { - s = redir_strings[np->nfile.type - NTO]; - if (*s == '>') { - dftfd = 1; - } - } -#else switch (np->nfile.type) { - 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; - default: - s = "*error*"; - dftfd = 0; - break; + case NTO: s = ">"; dftfd = 1; break; + case NCLOBBER: s = ">|"; dftfd = 1; break; + case NAPPEND: s = ">>"; dftfd = 1; break; + case NTOFD: s = ">&"; dftfd = 1; break; + case NFROM: s = "<"; dftfd = 0; break; + case NFROMFD: s = "<&"; dftfd = 0; break; + case NFROMTO: s = "<>"; dftfd = 0; break; + default: s = "*error*"; dftfd = 0; break; } -#endif if (np->nfile.fd != dftfd) fprintf(fp, "%d", np->nfile.fd); fputs(s, fp); @@ -11192,19 +11115,20 @@ static void shcmd(union node *cmd, FILE * fp) } -static void sharg(union node *arg, FILE * fp) + +static void +sharg(union node *arg, FILE *fp) { char *p; struct nodelist *bqlist; int subtype; if (arg->type != NARG) { - printf("<node type %d>\n", arg->type); - fflush(stdout); + out1fmt("<node type %d>\n", arg->type); abort(); } bqlist = arg->narg.backquote; - for (p = arg->narg.text; *p; p++) { + for (p = arg->narg.text ; *p ; p++) { switch (*p) { case CTLESC: putc(*++p, fp); @@ -11255,14 +11179,14 @@ static void sharg(union node *arg, FILE * fp) case VSLENGTH: break; default: - printf("<subtype %d>", subtype); + out1fmt("<subtype %d>", subtype); } break; case CTLENDVAR: - putc('}', fp); - break; + putc('}', fp); + break; case CTLBACKQ: - case CTLBACKQ | CTLQUOTE: + case CTLBACKQ|CTLQUOTE: putc('$', fp); putc('(', fp); shtree(bqlist->n, -1, NULL, fp); @@ -11276,100 +11200,88 @@ static void sharg(union node *arg, FILE * fp) } -static void indent(int amount, char *pfx, FILE * fp) +static void +indent(int amount, char *pfx, FILE *fp) { int i; - for (i = 0; i < amount; i++) { + for (i = 0 ; i < amount ; i++) { if (pfx && i == amount - 1) fputs(pfx, fp); putc('\t', fp); } } -FILE *tracefile; -#if DEBUG == 2 -static int debug = 1; -#else -static int debug = 0; -#endif + +/* + * Debugging stuff. + */ + + +FILE *tracefile; -static void trputc(int c) +void +trputc(int c) { - if (tracefile == NULL) + if (debug != 1) return; putc(c, tracefile); - if (c == '\n') - fflush(tracefile); } -static void trace(const char *fmt, ...) +void +trace(const char *fmt, ...) { va_list va; + if (debug != 1) + return; va_start(va, fmt); - if (tracefile != NULL) { - (void) vfprintf(tracefile, fmt, va); - if (strchr(fmt, '\n')) - (void) fflush(tracefile); - } + (void) vfprintf(tracefile, fmt, va); va_end(va); } +void +tracev(const char *fmt, va_list va) +{ + if (debug != 1) + return; + (void) vfprintf(tracefile, fmt, va); +} + -static void trputs(const char *s) +void +trputs(const char *s) { - if (tracefile == NULL) + if (debug != 1) return; fputs(s, tracefile); - if (strchr(s, '\n')) - fflush(tracefile); } -static void trstring(char *s) +static void +trstring(char *s) { char *p; char c; - if (tracefile == NULL) + if (debug != 1) return; putc('"', tracefile); - for (p = s; *p; p++) { + for (p = s ; *p ; p++) { switch (*p) { - case '\n': - c = 'n'; - goto backslash; - case '\t': - c = 't'; - goto backslash; - case '\r': - c = 'r'; - goto backslash; - case '"': - c = '"'; - goto backslash; - case '\\': - c = '\\'; - goto backslash; - case CTLESC: - c = 'e'; - goto backslash; - case CTLVAR: - c = 'v'; - goto backslash; - case CTLVAR + CTLQUOTE: - c = 'V'; - goto backslash; - case CTLBACKQ: - c = 'q'; - goto backslash; - case CTLBACKQ + CTLQUOTE: - c = 'Q'; - goto backslash; - backslash:putc('\\', tracefile); + case '\n': c = 'n'; goto backslash; + case '\t': c = 't'; goto backslash; + case '\r': c = 'r'; goto backslash; + case '"': c = '"'; goto backslash; + case '\\': c = '\\'; goto backslash; + case CTLESC: c = 'e'; goto backslash; + case CTLVAR: c = 'v'; goto backslash; + case CTLVAR+CTLQUOTE: c = 'V'; goto backslash; + case CTLBACKQ: c = 'q'; goto backslash; + case CTLBACKQ+CTLQUOTE: c = 'Q'; goto backslash; +backslash: putc('\\', tracefile); putc(c, tracefile); break; default: @@ -11388,9 +11300,10 @@ static void trstring(char *s) } -static void trargs(char **ap) +void +trargs(char **ap) { - if (tracefile == NULL) + if (debug != 1) return; while (*ap) { trstring(*ap++); @@ -11399,78 +11312,91 @@ static void trargs(char **ap) else putc('\n', tracefile); } - fflush(tracefile); } -static void opentrace() +void +opentrace(void) { char s[100]; - #ifdef O_APPEND int flags; #endif - if (!debug) + if (debug != 1) { + if (tracefile) + fflush(tracefile); + /* leave open because libedit might be using it */ return; -#ifdef not_this_way - { - char *p; - - if ((p = getenv("HOME")) == NULL) { - if (geteuid() == 0) - p = "/"; - else - p = "/tmp"; + } + scopy("./trace", s); + if (tracefile) { + if (!freopen(s, "a", tracefile)) { + fprintf(stderr, "Can't re-open %s\n", s); + debug = 0; + return; + } + } else { + if ((tracefile = fopen(s, "a")) == NULL) { + fprintf(stderr, "Can't open %s\n", s); + debug = 0; + return; } - strcpy(s, p); - strcat(s, "/trace"); } -#else - strcpy(s, "./trace"); -#endif /* not_this_way */ - if ((tracefile = bb_wfopen(s, "a")) == NULL) - return; #ifdef O_APPEND if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0) fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND); #endif + setlinebuf(tracefile); fputs("\nTracing started.\n", tracefile); - fflush(tracefile); } -#endif /* DEBUG */ +#endif /* DEBUG */ + + +/* $NetBSD: trap.c,v 1.28 2002/11/24 22:35:43 christos Exp $ */ + +/* + * Sigmode records the current value of the signal handlers for the various + * modes. A value of zero means that the current handler is not known. + * S_HARD_IGN indicates that the signal was ignored on entry to the shell, + */ + +#define S_DFL 1 /* default signal handling (SIG_DFL) */ +#define S_CATCH 2 /* signal is caught */ +#define S_IGN 3 /* signal is ignored (SIG_IGN) */ +#define S_HARD_IGN 4 /* signal is ignored permenantly */ +#define S_RESET 5 /* temporary - to reset a hard ignored sig */ + /* * The trap builtin. */ -static int trapcmd(int argc, char **argv) +int +trapcmd(int argc, char **argv) { char *action; char **ap; int signo; - if (argc <= 1) { - for (signo = 0; signo < NSIG; signo++) { + nextopt(nullstr); + ap = argptr; + if (!*ap) { + for (signo = 0 ; signo < NSIG ; signo++) { if (trap[signo] != NULL) { - char *p; const char *sn; - p = single_quote(trap[signo]); - sn = sys_siglist[signo]; - if (sn == NULL) - sn = u_signal_names(0, &signo, 0); + sn = u_signal_names(0, &signo, 0); if (sn == NULL) sn = "???"; - printf("trap -- %s %s\n", p, sn); - stunalloc(p); + out1fmt("trap -- %s %s\n", + single_quote(trap[signo]), sn); } } return 0; } - ap = argv + 1; - if (argc == 2) + if (!ap[1]) action = NULL; else action = *ap++; @@ -11482,9 +11408,10 @@ static int trapcmd(int argc, char **argv) if (action[0] == '-' && action[1] == '\0') action = NULL; else - action = bb_xstrdup(action); + action = savestr(action); } - free(trap[signo]); + if (trap[signo]) + ckfree(trap[signo]); trap[signo] = action; if (signo != 0) setsignal(signo); @@ -11495,15 +11422,40 @@ static int trapcmd(int argc, char **argv) } + +/* + * Clear traps on a fork. + */ + +void +clear_traps(void) +{ + char **tp; + + for (tp = trap ; tp < &trap[NSIG] ; tp++) { + if (*tp && **tp) { /* trap not NULL or SIG_IGN */ + INTOFF; + ckfree(*tp); + *tp = NULL; + if (tp != &trap[0]) + setsignal(tp - trap); + INTON; + } + } +} + + + /* * Set the signal handler for the specified signal. The routine figures * out what it should be set to. */ -static void setsignal(int signo) +void +setsignal(int signo) { int action; - char *t; + char *t, tsig; struct sigaction act; if ((t = trap[signo]) == NULL) @@ -11520,18 +11472,15 @@ static void setsignal(int signo) break; case SIGQUIT: #ifdef DEBUG - { - if (debug) break; - } #endif /* FALLTHROUGH */ case SIGTERM: if (iflag) action = S_IGN; break; -#ifdef CONFIG_ASH_JOB_CONTROL +#if JOBS case SIGTSTP: case SIGTTOU: if (mflag) @@ -11542,7 +11491,8 @@ static void setsignal(int signo) } t = &sigmode[signo - 1]; - if (*t == 0) { + tsig = *t; + if (tsig == 0) { /* * current setting unknown */ @@ -11556,21 +11506,29 @@ static void setsignal(int signo) } if (act.sa_handler == SIG_IGN) { if (mflag && (signo == SIGTSTP || - signo == SIGTTIN || signo == SIGTTOU)) { - *t = S_IGN; /* don't hard ignore these */ + signo == SIGTTIN || signo == SIGTTOU)) { + tsig = S_IGN; /* don't hard ignore these */ } else - *t = S_HARD_IGN; + tsig = S_HARD_IGN; } else { - *t = S_RESET; /* force to be set */ + tsig = S_RESET; /* force to be set */ } } - if (*t == S_HARD_IGN || *t == action) + if (tsig == S_HARD_IGN || tsig == action) return; - act.sa_handler = ((action == S_CATCH) ? onsig - : ((action == S_IGN) ? SIG_IGN : SIG_DFL)); + switch (action) { + 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; act.sa_flags = 0; - sigemptyset(&act.sa_mask); + sigfillset(&act.sa_mask); sigaction(signo, &act, 0); } @@ -11578,7 +11536,8 @@ static void setsignal(int signo) * Ignore a signal. */ -static void ignoresig(int signo) +void +ignoresig(int signo) { if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) { signal(signo, SIG_IGN); @@ -11587,74 +11546,142 @@ static void ignoresig(int signo) } + /* * Signal handler. */ -static void onsig(int signo) +void +onsig(int signo) { - if (signo == SIGINT && trap[SIGINT] == NULL) { - onint(); - return; - } gotsig[signo - 1] = 1; - pendingsigs++; + pendingsigs = signo; + + if (exsig || (signo == SIGINT && !trap[SIGINT])) { + if (!suppressint) + onint(); + intpending = 1; + } } + /* * Called to execute a trap. Perhaps we should avoid entering new trap * handlers while we are executing a trap handler. */ -static void dotrap(void) +void +dotrap(void) { - int i; + char *p; + char *q; int savestatus; - for (;;) { - for (i = 1;; i++) { - if (gotsig[i - 1]) - break; - if (i >= NSIG - 1) - goto done; - } - gotsig[i - 1] = 0; - savestatus = exitstatus; - evalstring(trap[i], 0); + savestatus = exitstatus; + q = gotsig; + while (pendingsigs = 0, barrier(), (p = memchr(q, 1, NSIG - 1))) { + *p = 0; + p = trap[p - q + 1]; + if (!p) + continue; + evalstring(p, 0); exitstatus = savestatus; } - done: - pendingsigs = 0; } + + +/* + * Controls whether the shell is interactive or not. + */ + + +void +setinteractive(int on) +{ + static int is_interactive; + + if (++on == is_interactive) + return; + is_interactive = on; + setsignal(SIGINT); + setsignal(SIGQUIT); + setsignal(SIGTERM); +#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET + if(is_interactive > 1) { + /* Looks like they want an interactive shell */ + static int do_banner; + + if(!do_banner) { + out1fmt( + "\n\n" BB_BANNER " Built-in shell (ash)\n" + "Enter 'help' for a list of built-in commands.\n\n"); + do_banner++; + } + } +#endif +} + + +#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET +/*** List the available builtins ***/ + +static int helpcmd(int argc, char **argv) +{ + int col, i; + + out1fmt("\nBuilt-in commands:\n-------------------\n"); + for (col = 0, i = 0; i < NUMBUILTINS; i++) { + col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), + builtincmd[i].name + 1); + if (col > 60) { + out1fmt("\n"); + col = 0; + } + } +#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL + { + extern const struct BB_applet applets[]; + extern const size_t NUM_APPLETS; + + for (i = 0; i < NUM_APPLETS; i++) { + + col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name); + if (col > 60) { + out1fmt("\n"); + col = 0; + } + } + } +#endif + out1fmt("\n\n"); + return EXIT_SUCCESS; +} +#endif /* CONFIG_FEATURE_SH_EXTRA_QUIET */ + /* * Called to exit the shell. */ -static void exitshell(int status) +void +exitshell(void) { - struct jmploc loc1, loc2; + struct jmploc loc; char *p; + int status; - TRACE(("exitshell(%d) pid=%d\n", status, getpid())); - if (setjmp(loc1.loc)) { - goto l1; - } - if (setjmp(loc2.loc)) { - goto l2; + status = exitstatus; + TRACE(("pid %d, exitshell(%d)\n", getpid(), status)); + if (setjmp(loc.loc)) { + goto out; } - handler = &loc1; + handler = &loc; if ((p = trap[0]) != NULL && *p != '\0') { trap[0] = NULL; evalstring(p, 0); } -l1: - handler = &loc2; /* probably unnecessary */ flushall(); -#ifdef CONFIG_ASH_JOB_CONTROL - setjobctl(0); -#endif #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY if (iflag && rootshell) { const char *hp = lookupvar("HISTFILE"); @@ -11663,7 +11690,8 @@ l1: save_history ( hp ); } #endif -l2: +out: + out1c('\n'); _exit(status); /* NOTREACHED */ } @@ -11676,95 +11704,78 @@ static int decode_signal(const char *string, int minsig) return name ? signo : -1; } -static struct var **hashvar(const char *); -static void showvars(const char *, int, int); +/* $NetBSD: var.c,v 1.32 2003/01/22 20:36:04 dsl Exp $ */ + +static struct var *vartab[VTABSIZE]; + +static int vpcmp(const void *, const void *); static struct var **findvar(struct var **, const char *); /* * Initialize the varable symbol tables and import the environment */ + +#ifdef CONFIG_ASH_GETOPTS /* - * This routine initializes the builtin variables. It is called when the - * shell is initialized and again when a shell procedure is spawned. + * Safe version of setvar, returns 1 on success 0 on failure. */ -static void initvar() +int +setvarsafe(const char *name, const char *val, int flags) { - const struct varinit *ip; - struct var *vp; - struct var **vpp; + int err; + volatile int saveint; + struct jmploc *volatile savehandler = handler; + struct jmploc jmploc; - for (ip = varinit; (vp = ip->var) != NULL; ip++) { - if ((vp->flags & VEXPORT) == 0) { - vpp = hashvar(ip->text); - vp->next = *vpp; - *vpp = vp; - vp->text = bb_xstrdup(ip->text); - vp->flags = ip->flags; - vp->func = ip->func; - } - } -#if !defined(CONFIG_FEATURE_COMMAND_EDITING) || !defined(CONFIG_FEATURE_SH_FANCY_PROMPT) - /* - * PS1 depends on uid - */ - if ((vps1.flags & VEXPORT) == 0) { - vpp = hashvar("PS1=$ "); - vps1.next = *vpp; - *vpp = &vps1; - vps1.text = bb_xstrdup(geteuid()? "PS1=$ " : "PS1=# "); - vps1.flags = VSTRFIXED | VTEXTFIXED; + SAVEINT(saveint); + if (setjmp(jmploc.loc)) + err = 1; + else { + handler = &jmploc; + setvar(name, val, flags); + err = 0; } -#endif + handler = savehandler; + RESTOREINT(saveint); + return err; } +#endif /* * Set the value of a variable. The flags argument is ored with the * flags of the variable. If val is NULL, the variable is unset. */ -static void setvar(const char *name, const char *val, int flags) +static void +setvar(const char *name, const char *val, int flags) { - const char *p; - int len; - int namelen; + char *p, *q; + size_t namelen; char *nameeq; - int isbad; - int vallen = 0; + size_t vallen; - isbad = 0; - p = name; - if (!is_name(*p)) - isbad = 1; - p++; - for (;;) { - if (!is_in_name(*p)) { - if (*p == '\0' || *p == '=') - break; - isbad = 1; - } - p++; - } + q = endofname(name); + p = strchrnul(q, '='); namelen = p - name; - if (isbad) + if (!namelen || p != q) error("%.*s: bad variable name", namelen, name); - len = namelen + 2; /* 2 is space for '=' and '\0' */ + vallen = 0; if (val == NULL) { flags |= VUNSET; } else { - len += vallen = strlen(val); + vallen = strlen(val); } INTOFF; - nameeq = xmalloc(len); - memcpy(nameeq, name, namelen); - nameeq[namelen] = '='; - if (val) { - memcpy(nameeq + namelen + 1, val, vallen + 1); - } else { - nameeq[namelen + 1] = '\0'; + p = mempcpy(nameeq = ckmalloc(namelen + vallen + 2), name, namelen); + *p++ = '\0'; + if (vallen) { + p[-1] = '='; + p = mempcpy(p, val, vallen); } - setvareq(nameeq, flags); + *p = '\0'; + setvareq(nameeq, flags | VNOSAVE); INTON; } @@ -11775,50 +11786,47 @@ static void setvar(const char *name, const char *val, int flags) * the first argument as name=value. Since the first argument will * be actually stored in the table, it should not be a string that * will go away. + * Called with interrupts off. */ -static void setvareq(char *s, int flags) +void +setvareq(char *s, int flags) { struct var *vp, **vpp; vpp = hashvar(s); flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1)); - if ((vp = *findvar(vpp, s))) { + vp = *findvar(vpp, s); + if (vp) { if (vp->flags & VREADONLY) { - size_t len = strchr(s, '=') - s; - - error("%.*s: is read only", len, s); + if (flags & VNOSAVE) + free(s); + error("%.*s: is read only", strchrnul(s, '=') - s, s); } - INTOFF; - if (vp->func && (flags & VNOFUNC) == 0) - (*vp->func) (strchr(s, '=') + 1); + if (flags & VNOSET) + return; - if ((vp->flags & (VTEXTFIXED | VSTACK)) == 0) - free(vp->text); + if (vp->func && (flags & VNOFUNC) == 0) + (*vp->func)(strchrnul(s, '=') + 1); - vp->flags &= ~(VTEXTFIXED | VSTACK | VUNSET); - vp->flags |= flags; - vp->text = s; + if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0) + ckfree(vp->text); -#ifdef CONFIG_ASH_MAIL - /* - * We could roll this to a function, to handle it as - * a regular variable function callback, but why bother? - */ - if (iflag && (vp == &vmpath || (vp == &vmail && !mpathset()))) - chkmail(1); -#endif - INTON; - return; + flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET); + } else { + if (flags & VNOSET) + return; + /* not found */ + vp = ckmalloc(sizeof (*vp)); + vp->next = *vpp; + vp->func = NULL; + *vpp = vp; } - /* not found */ - vp = xmalloc(sizeof(*vp)); - vp->flags = flags; + if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE))) + s = savestr(s); vp->text = s; - vp->next = *vpp; - vp->func = NULL; - *vpp = vp; + vp->flags = flags; } @@ -11827,29 +11835,32 @@ static void setvareq(char *s, int flags) * Process a linked list of variable assignments. */ -static void listsetvar(struct strlist *mylist) +static void +listsetvar(struct strlist *list_set_var, int flags) { - struct strlist *lp; + struct strlist *lp = list_set_var; + if (!lp) + return; INTOFF; - for (lp = mylist; lp; lp = lp->next) { - setvareq(bb_xstrdup(lp->text), 0); - } + do { + setvareq(lp->text, flags); + } while ((lp = lp->next)); INTON; } - /* * Find the value of a variable. Returns NULL if not set. */ -static const char *lookupvar(const char *name) +static char * +lookupvar(const char *name) { struct var *v; if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) { - return strchr(v->text, '=') + 1; + return strchrnul(v->text, '=') + 1; } return NULL; } @@ -11860,13 +11871,14 @@ static const char *lookupvar(const char *name) * Search the environment of a builtin command. */ -static const char *bltinlookup(const char *name) +static char * +bltinlookup(const char *name) { - const struct strlist *sp; + struct strlist *sp; - for (sp = cmdenviron; sp; sp = sp->next) { + for (sp = cmdenviron ; sp ; sp = sp->next) { if (varequal(sp->text, name)) - return strchr(sp->text, '=') + 1; + return strchrnul(sp->text, '=') + 1; } return lookupvar(name); } @@ -11874,44 +11886,69 @@ static const char *bltinlookup(const char *name) /* - * Generate a list of exported variables. This routine is used to construct - * the third argument to execve when executing a program. + * Generate a list of variables satisfying the given conditions. */ -static char **environment() +static char ** +listvars(int on, int off, char ***end) { - int nenv; struct var **vpp; struct var *vp; - char **env; char **ep; + int mask; - nenv = 0; - for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) { - for (vp = *vpp; vp; vp = vp->next) - if (vp->flags & VEXPORT) - nenv++; - } - ep = env = stalloc((nenv + 1) * sizeof *env); - for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) { - for (vp = *vpp; vp; vp = vp->next) - if (vp->flags & VEXPORT) - *ep++ = vp->text; - } - *ep = NULL; - return env; + STARTSTACKSTR(ep); + vpp = vartab; + mask = on | off; + do { + for (vp = *vpp ; vp ; vp = vp->next) + if ((vp->flags & mask) == on) { + if (ep == stackstrend()) + ep = growstackstr(); + *ep++ = (char *) vp->text; + } + } while (++vpp < vartab + VTABSIZE); + if (ep == stackstrend()) + ep = growstackstr(); + if (end) + *end = ep; + *ep++ = NULL; + return grabstackstr(ep); } + /* - * Command to list all variables which are set. Currently this command - * is invoked from the set command when the set command is called without - * any variables. + * POSIX requires that 'set' (but not export or readonly) output the + * variables in lexicographic order - by the locale's collating order (sigh). + * Maybe we could keep them in an ordered balanced binary tree + * instead of hashed lists. + * For now just roll 'em through qsort for printing... */ -static int showvarscmd(int argc, char **argv) +static int +showvars(const char *sep_prefix, int on, int off) { - showvars(nullstr, VUNSET, VUNSET); + const char *sep; + char **ep, **epend; + + ep = listvars(on, off, &epend); + qsort(ep, epend - ep, sizeof(char *), vpcmp); + + sep = *sep_prefix ? spcstr : sep_prefix; + + for (; ep < epend; ep++) { + const char *p; + const char *q; + + p = strchrnul(*ep, '='); + q = nullstr; + if (*p) + q = single_quote(++p); + + out1fmt("%s%s%.*s%s\n", sep_prefix, sep, (int)(p - *ep), *ep, q); + } + return 0; } @@ -11921,29 +11958,29 @@ static int showvarscmd(int argc, char **argv) * The export and readonly commands. */ -static int exportcmd(int argc, char **argv) +static int +exportcmd(int argc, char **argv) { struct var *vp; char *name; const char *p; - int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT; - int pflag; + char **aptr; + int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT; + int notp; - listsetvar(cmdenviron); - pflag = (nextopt("p") == 'p'); - if (argc > 1 && !pflag) { - while ((name = *argptr++) != NULL) { + notp = nextopt("p") - 'p'; + if (notp && ((name = *(aptr = argptr)))) { + do { if ((p = strchr(name, '=')) != NULL) { p++; } else { if ((vp = *findvar(hashvar(name), name))) { vp->flags |= flag; - goto found; + continue; } } setvar(name, p, flag); - found:; - } + } while ((name = *++aptr) != NULL); } else { showvars(argv[0], flag, 0); } @@ -11952,62 +11989,45 @@ static int exportcmd(int argc, char **argv) /* - * The "local" command. - */ - -/* funcnest nonzero if we are currently evaluating a function */ - -static int localcmd(int argc, char **argv) -{ - char *name; - - if (!funcnest) - error("Not in a function"); - while ((name = *argptr++) != NULL) { - mklocal(name); - } - return 0; -} - - -/* * Make a variable a local variable. When a variable is made local, it's * value and flags are saved in a localvar structure. The saved values * will be restored when the shell function returns. We handle the name * "-" as a special case. */ -static void mklocal(char *name) +static inline void +mklocal(char *name) { struct localvar *lvp; struct var **vpp; struct var *vp; INTOFF; - lvp = xmalloc(sizeof(struct localvar)); + lvp = ckmalloc(sizeof (struct localvar)); if (name[0] == '-' && name[1] == '\0') { char *p; - - p = xmalloc(sizeof optet_vals); - lvp->text = memcpy(p, optet_vals, sizeof optet_vals); + p = ckmalloc(sizeof(optlist)); + lvp->text = memcpy(p, optlist, sizeof(optlist)); vp = NULL; } else { + char *eq; + vpp = hashvar(name); vp = *findvar(vpp, name); + eq = strchr(name, '='); if (vp == NULL) { - if (strchr(name, '=')) - setvareq(bb_xstrdup(name), VSTRFIXED); + if (eq) + setvareq(name, VSTRFIXED); else setvar(name, NULL, VSTRFIXED); - vp = *vpp; /* the new variable */ - lvp->text = NULL; + vp = *vpp; /* the new variable */ lvp->flags = VUNSET; } else { lvp->text = vp->text; lvp->flags = vp->flags; - vp->flags |= VSTRFIXED | VTEXTFIXED; - if (strchr(name, '=')) - setvareq(bb_xstrdup(name), 0); + vp->flags |= VSTRFIXED|VTEXTFIXED; + if (eq) + setvareq(name, 0); } } lvp->vp = vp; @@ -12016,12 +12036,32 @@ static void mklocal(char *name) INTON; } +/* + * The "local" command. + */ + +static int +localcmd(int argc, char **argv) +{ + char *name; + + argv = argptr; + while ((name = *argv++) != NULL) { + mklocal(name); + } + return 0; +} + + + /* * Called after a function returns. + * Interrupts must be off. */ -static void poplocalvars() +static void +poplocalvars(void) { struct localvar *lvp; struct var *vp; @@ -12029,64 +12069,55 @@ static void poplocalvars() while ((lvp = localvars) != NULL) { localvars = lvp->next; vp = lvp->vp; - if (vp == NULL) { /* $- saved */ - memcpy(optet_vals, lvp->text, sizeof optet_vals); - free(lvp->text); - } else if ((lvp->flags & (VUNSET | VSTRFIXED)) == VUNSET) { - (void) unsetvar(vp->text); + TRACE(("poplocalvar %s", vp ? vp->text : "-")); + if (vp == NULL) { /* $- saved */ + memcpy(optlist, lvp->text, sizeof(optlist)); + ckfree(lvp->text); + optschanged(); + } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) { + unsetvar(vp->text); } else { - if ((vp->flags & VTEXTFIXED) == 0) - free(vp->text); + if (vp->func) + (*vp->func)(strchrnul(lvp->text, '=') + 1); + if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0) + ckfree(vp->text); vp->flags = lvp->flags; vp->text = lvp->text; } - free(lvp); + ckfree(lvp); } } -static int setvarcmd(int argc, char **argv) -{ - if (argc <= 2) - return unsetcmd(argc, argv); - else if (argc == 3) - setvar(argv[1], argv[2], 0); - else - error("List assignment not implemented"); - return 0; -} - - /* * The unset builtin command. We unset the function before we unset the * variable to allow a function to be unset when there is a readonly variable * with the same name. */ -static int unsetcmd(int argc, char **argv) +int +unsetcmd(int argc, char **argv) { char **ap; int i; - int flg_func = 0; - int flg_var = 0; + int flag = 0; int ret = 0; while ((i = nextopt("vf")) != '\0') { - if (i == 'f') - flg_func = 1; - else - flg_var = 1; + flag = i; } - if (flg_func == 0 && flg_var == 0) - flg_var = 1; - for (ap = argptr; *ap; ap++) { - if (flg_func) + for (ap = argptr; *ap ; ap++) { + if (flag != 'f') { + i = unsetvar(*ap); + ret |= i; + if (!(i & 2)) + continue; + } + if (flag != 'v') unsetfunc(*ap); - if (flg_var) - ret |= unsetvar(*ap); } - return ret; + return ret & 1; } @@ -12094,32 +12125,41 @@ static int unsetcmd(int argc, char **argv) * Unset the specified variable. */ -static int unsetvar(const char *s) +int +unsetvar(const char *s) { struct var **vpp; struct var *vp; + int retval; vpp = findvar(hashvar(s), s); vp = *vpp; + retval = 2; if (vp) { - if (vp->flags & VREADONLY) - return (1); - INTOFF; - if (*(strchr(vp->text, '=') + 1) != '\0') - setvar(s, nullstr, 0); - vp->flags &= ~VEXPORT; - vp->flags |= VUNSET; - if ((vp->flags & VSTRFIXED) == 0) { - if ((vp->flags & VTEXTFIXED) == 0) - free(vp->text); + int flags = vp->flags; + + retval = 1; + if (flags & VREADONLY) + goto out; + if (flags & VUNSET) + goto ok; + if ((flags & VSTRFIXED) == 0) { + INTOFF; + if ((flags & (VTEXTFIXED|VSTACK)) == 0) + ckfree(vp->text); *vpp = vp->next; - free(vp); + ckfree(vp); + INTON; + } else { + setvar(s, 0, 0); + vp->flags &= ~VEXPORT; } - INTON; - return (0); +ok: + retval = 0; } - return (0); +out: + return retval; } @@ -12128,7 +12168,8 @@ static int unsetvar(const char *s) * Find the appropriate entry in the hash table from the name. */ -static struct var **hashvar(const char *p) +static struct var ** +hashvar(const char *p) { unsigned int hashval; @@ -12141,46 +12182,38 @@ static struct var **hashvar(const char *p) /* - * Returns true if the two strings specify the same varable. The first - * variable name is terminated by '='; the second may be terminated by + * Compares two strings up to the first = or '\0'. The first + * string must be terminated by '='; the second may be terminated by * either '=' or '\0'. */ -static int varequal(const char *p, const char *q) +int +varcmp(const char *p, const char *q) { - while (*p == *q++) { - if (*p++ == '=') - return 1; + int c, d; + + while ((c = *p) == (d = *q)) { + if (!c || c == '=') + goto out; + p++; + q++; } - if (*p == '=' && *(q - 1) == '\0') - return 1; - return 0; + if (c == '=') + c = 0; + if (d == '=') + d = 0; +out: + return c - d; } -static void showvars(const char *myprefix, int mask, int xor) +static int +vpcmp(const void *a, const void *b) { - struct var **vpp; - struct var *vp; - const char *sep = myprefix == nullstr ? myprefix : spcstr; - - for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) { - for (vp = *vpp; vp; vp = vp->next) { - if ((vp->flags & mask) ^ xor) { - char *p; - int len; - - p = strchr(vp->text, '=') + 1; - len = p - vp->text; - p = single_quote(p); - - printf("%s%s%.*s%s\n", myprefix, sep, len, vp->text, p); - stunalloc(p); - } - } - } + return varcmp(*(const char **)a, *(const char **)b); } -static struct var **findvar(struct var **vpp, const char *name) +static struct var ** +findvar(struct var **vpp, const char *name) { for (; *vpp; vpp = &(*vpp)->next) { if (varequal((*vpp)->text, name)) { @@ -12189,68 +12222,420 @@ static struct var **findvar(struct var **vpp, const char *name) } return vpp; } +/* $NetBSD: setmode.c,v 1.29 2003/01/15 23:58:03 kleink Exp $ */ /* * Copyright (c) 1999 Herbert Xu <herbert@debian.org> - * This file contains code for the times builtin. + * This code for the times builtin. */ -static int timescmd(int argc, char **argv) -{ + +#include <sys/times.h> + +int timescmd(int ac, char **av) { 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); + out1fmt("%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; } #ifdef CONFIG_ASH_MATH_SUPPORT -/* The let builtin. */ -int letcmd(int argc, char **argv) +static int +dash_arith(const char *s) { - int errcode; long result = 0; + int errcode = 0; - if (argc == 2) { - char *tmp, *expression, p[13]; + INTOFF; + result = arith(s, &errcode); + if (errcode < 0) { + if (errcode == -2) + error("divide by zero"); + else + synerror(s); + } + INTON; - expression = strchr(argv[1], '='); - if (!expression) { - /* Cannot use 'error()' here, or the return code - * will be incorrect */ - out2fmt("sh: let: syntax error: \"%s\"\n", argv[1]); - return 0; + return (result); +} + + +/* + * The exp(1) builtin. + */ +static int +expcmd(int argc, char **argv) +{ + const char *p; + char *concat; + char **ap; + long i; + + if (argc > 1) { + p = argv[1]; + if (argc > 2) { + /* + * concatenate arguments + */ + STARTSTACKSTR(concat); + ap = argv + 2; + for (;;) { + while (*p) + STPUTC(*p++, concat); + if ((p = *ap++) == NULL) + break; + STPUTC(' ', concat); + } + STPUTC('\0', concat); + p = grabstackstr(concat); } - *expression = '\0'; - tmp = ++expression; - result = arith(tmp, &errcode); - if (errcode < 0) { - /* Cannot use 'error()' here, or the return code - * will be incorrect */ - out2fmt("sh: let: "); - if (errcode == -2) - out2fmt("divide by zero"); - else - out2fmt("syntax error: \"%s=%s\"\n", argv[1], expression); - return 0; + } else + p = nullstr; + + i = dash_arith(p); + + out1fmt("%ld\n", i); + return (! i); +} +#endif /* CONFIG_ASH_MATH_SUPPORT */ + +/* $NetBSD: miscbltin.c,v 1.31 2002/11/24 22:35:41 christos Exp $ */ + +/* + * Miscelaneous builtins. + */ + +#undef rflag + +#ifdef __GLIBC__ +#if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1 +typedef enum __rlimit_resource rlim_t; +#endif +#endif + + +/* + * The read builtin. The -e option causes backslashes to escape the + * following character. + * + * This uses unbuffered input, which may be avoidable in some cases. + */ + +static int +readcmd(int argc, char **argv) +{ + char **ap; + int backslash; + char c; + int rflag; + char *prompt; + const char *ifs; + char *p; + int startword; + int status; + int i; + + rflag = 0; + prompt = NULL; + while ((i = nextopt("p:r")) != '\0') { + if (i == 'p') + prompt = optionarg; + else + rflag = 1; + } + if (prompt && isatty(0)) { + out2str(prompt); + flushall(); + } + if (*(ap = argptr) == NULL) + error("arg count"); + if ((ifs = bltinlookup("IFS")) == NULL) + ifs = defifs; + status = 0; + startword = 1; + backslash = 0; + STARTSTACKSTR(p); + for (;;) { + if (read(0, &c, 1) != 1) { + status = 1; + break; + } + if (c == '\0') + continue; + if (backslash) { + backslash = 0; + if (c != '\n') + goto put; + continue; + } + if (!rflag && c == '\\') { + backslash++; + continue; + } + if (c == '\n') + break; + if (startword && *ifs == ' ' && strchr(ifs, c)) { + continue; + } + startword = 0; + if (ap[1] != NULL && strchr(ifs, c) != NULL) { + STACKSTRNUL(p); + setvar(*ap, stackblock(), 0); + ap++; + startword = 1; + STARTSTACKSTR(p); + } else { +put: + STPUTC(c, p); + } + } + STACKSTRNUL(p); + /* Remove trailing blanks */ + while ((char *)stackblock() <= --p && strchr(ifs, *p) != NULL) + *p = '\0'; + setvar(*ap, stackblock(), 0); + while (*++ap != NULL) + setvar(*ap, nullstr, 0); + return status; +} + + +static int umaskcmd(int argc, char **argv) +{ + static const char permuser[3] = "ugo"; + static const char permmode[3] = "rwx"; + static const short int permmask[] = { + S_IRUSR, S_IWUSR, S_IXUSR, + S_IRGRP, S_IWGRP, S_IXGRP, + S_IROTH, S_IWOTH, S_IXOTH + }; + + char *ap; + mode_t mask; + int i; + int symbolic_mode = 0; + + while (nextopt("S") != '\0') { + symbolic_mode = 1; + } + + INTOFF; + mask = umask(0); + umask(mask); + INTON; + + if ((ap = *argptr) == NULL) { + if (symbolic_mode) { + char buf[18]; + char *p = buf; + + for (i = 0; i < 3; i++) { + int j; + + *p++ = permuser[i]; + *p++ = '='; + for (j = 0; j < 3; j++) { + if ((mask & permmask[3 * i + j]) == 0) { + *p++ = permmode[j]; + } + } + *p++ = ','; + } + *--p = 0; + puts(buf); + } else { + out1fmt("%.4o\n", mask); + } + } else { + if (is_digit((unsigned char) *ap)) { + mask = 0; + do { + if (*ap >= '8' || *ap < '0') + error(illnum, argv[1]); + mask = (mask << 3) + (*ap - '0'); + } while (*++ap != '\0'); + umask(mask); + } else { + mask = ~mask & 0777; + if (!bb_parse_mode(ap, &mask)) { + error("Illegal mode: %s", ap); + } + umask(~mask & 0777); } - snprintf(p, 12, "%ld", result); - setvar(argv[1], bb_xstrdup(p), 0); - } else if (argc >= 3) - synerror("invalid operand"); - return !result; + } + return 0; } + +/* + * ulimit builtin + * + * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and + * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with + * ash by J.T. Conklin. + * + * Public domain. + */ + +struct limits { + const char *name; + int cmd; + int factor; /* multiply by to get rlim_{cur,max} values */ + char option; +}; + +static const struct limits limits[] = { +#ifdef RLIMIT_CPU + { "time(seconds)", RLIMIT_CPU, 1, 't' }, +#endif +#ifdef RLIMIT_FSIZE + { "file(blocks)", RLIMIT_FSIZE, 512, 'f' }, +#endif +#ifdef RLIMIT_DATA + { "data(kbytes)", RLIMIT_DATA, 1024, 'd' }, +#endif +#ifdef RLIMIT_STACK + { "stack(kbytes)", RLIMIT_STACK, 1024, 's' }, +#endif +#ifdef RLIMIT_CORE + { "coredump(blocks)", RLIMIT_CORE, 512, 'c' }, +#endif +#ifdef RLIMIT_RSS + { "memory(kbytes)", RLIMIT_RSS, 1024, 'm' }, #endif +#ifdef RLIMIT_MEMLOCK + { "locked memory(kbytes)", RLIMIT_MEMLOCK, 1024, 'l' }, +#endif +#ifdef RLIMIT_NPROC + { "process(processes)", RLIMIT_NPROC, 1, 'p' }, +#endif +#ifdef RLIMIT_NOFILE + { "nofiles(descriptors)", RLIMIT_NOFILE, 1, 'n' }, +#endif +#ifdef RLIMIT_VMEM + { "vmemory(kbytes)", RLIMIT_VMEM, 1024, 'v' }, +#endif +#ifdef RLIMIT_SWAP + { "swap(kbytes)", RLIMIT_SWAP, 1024, 'w' }, +#endif + { (char *) 0, 0, 0, '\0' } +}; +int +ulimitcmd(int argc, char **argv) +{ + int c; + rlim_t val = 0; + enum { SOFT = 0x1, HARD = 0x2 } + how = SOFT | HARD; + const struct limits *l; + int set, all = 0; + int optc, what; + struct rlimit limit; + what = 'f'; + while ((optc = nextopt("HSatfdsmcnpl")) != '\0') + switch (optc) { + case 'H': + how = HARD; + break; + case 'S': + how = SOFT; + break; + case 'a': + all = 1; + break; + default: + what = optc; + } + + for (l = limits; l->name && l->option != what; l++) + ; + if (!l->name) + error("internal error (%c)", what); + + set = *argptr ? 1 : 0; + if (set) { + char *p = *argptr; + + if (all || argptr[1]) + error("too many arguments"); + if (strcmp(p, "unlimited") == 0) + val = RLIM_INFINITY; + else { + val = (rlim_t) 0; + + while ((c = *p++) >= '0' && c <= '9') + { + val = (val * 10) + (long)(c - '0'); + if (val < (rlim_t) 0) + break; + } + if (c) + error("bad number"); + val *= l->factor; + } + } + if (all) { + for (l = limits; l->name; l++) { + getrlimit(l->cmd, &limit); + if (how & SOFT) + val = limit.rlim_cur; + else if (how & HARD) + val = limit.rlim_max; + + out1fmt("%-20s ", l->name); + if (val == RLIM_INFINITY) + out1fmt("unlimited\n"); + else + { + val /= l->factor; + out1fmt("%lld\n", (long long) val); + } + } + return 0; + } + + getrlimit(l->cmd, &limit); + if (set) { + if (how & HARD) + limit.rlim_max = val; + if (how & SOFT) + limit.rlim_cur = val; + if (setrlimit(l->cmd, &limit) < 0) + error("error setting limit (%m)"); + } else { + if (how & SOFT) + val = limit.rlim_cur; + else if (how & HARD) + val = limit.rlim_max; + + if (val == RLIM_INFINITY) + out1fmt("unlimited\n"); + else + { + val /= l->factor; + out1fmt("%lld\n", (long long) val); + } + } + return 0; +} + +#ifdef DEBUG +const char *bb_applet_name = "debug stuff usage"; +int main(int argc, char **argv) +{ + return ash_main(argc, argv); +} +#endif /*- * Copyright (c) 1989, 1991, 1993, 1994 diff --git a/shell/cmdedit.c b/shell/cmdedit.c index 843f73f..7170672 100644 --- a/shell/cmdedit.c +++ b/shell/cmdedit.c @@ -9,7 +9,7 @@ * Adam Rogoyski <rogoyski@cs.utexas.edu> * Dave Cinege <dcinege@psychosis.com> * Jakub Jelinek (c) 1995 - * Erik Andersen <andersen@codepoet.org> (Majorly adjusted for busybox) + * Erik Andersen <andersee@debian.org> (Majorly adjusted for busybox) * * This code is 'as is' with no warranty. * @@ -63,7 +63,7 @@ #define D(x) x -#endif /* TEST */ +#endif /* TEST */ #ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION #include <dirent.h> @@ -86,7 +86,7 @@ # else # include <pwd.h> # endif /* TEST */ -#endif /* advanced FEATURES */ +#endif /* advanced FEATURES */ /* Maximum length of the linked list for the command line history */ @@ -115,30 +115,30 @@ static struct termios initial_settings, new_settings; static -volatile int cmdedit_termw = 80; /* actual terminal width */ +volatile int cmdedit_termw = 80; /* actual terminal width */ static -volatile int handlers_sets = 0; /* Set next bites: */ +volatile int handlers_sets = 0; /* Set next bites: */ enum { - SET_ATEXIT = 1, /* when atexit() has been called + SET_ATEXIT = 1, /* when atexit() has been called and get euid,uid,gid to fast compare */ SET_WCHG_HANDLERS = 2, /* winchg signal handler */ SET_RESET_TERM = 4, /* if the terminal needs to be reset upon exit */ }; -static int cmdedit_x; /* real x terminal position */ -static int cmdedit_y; /* pseudoreal y terminal position */ -static int cmdedit_prmt_len; /* lenght prompt without colores string */ +static int cmdedit_x; /* real x terminal position */ +static int cmdedit_y; /* pseudoreal y terminal position */ +static int cmdedit_prmt_len; /* lenght prompt without colores string */ -static int cursor; /* required global for signal handler */ -static int len; /* --- "" - - "" - -"- --""-- --""--- */ -static char *command_ps; /* --- "" - - "" - -"- --""-- --""--- */ +static int cursor; /* required global for signal handler */ +static int len; /* --- "" - - "" - -"- --""-- --""--- */ +static char *command_ps; /* --- "" - - "" - -"- --""-- --""--- */ static #ifndef CONFIG_FEATURE_SH_FANCY_PROMPT const #endif -char *cmdedit_prompt; /* --- "" - - "" - -"- --""-- --""--- */ +char *cmdedit_prompt; /* --- "" - - "" - -"- --""-- --""--- */ #ifdef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR static char *user_buf = ""; @@ -161,31 +161,36 @@ static int my_euid; static int my_uid; static int my_gid; -#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */ +#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */ + +/* It seems that libc5 doesn't know what a sighandler_t is... */ +#if (__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 1) +typedef void (*sighandler_t) (int); +#endif static void cmdedit_setwidth(int w, int redraw_flg); static void win_changed(int nsig) { struct winsize win = { 0, 0, 0, 0 }; - static sighandler_t previous_SIGWINCH_handler; /* for reset */ + static sighandler_t previous_SIGWINCH_handler; /* for reset */ /* emulate || signal call */ if (nsig == -SIGWINCH || nsig == SIGWINCH) { ioctl(0, TIOCGWINSZ, &win); if (win.ws_col > 0) { cmdedit_setwidth(win.ws_col, nsig == SIGWINCH); - } + } } /* Unix not all standart in recall signal */ - if (nsig == -SIGWINCH) /* save previous handler */ + if (nsig == -SIGWINCH) /* save previous handler */ previous_SIGWINCH_handler = signal(SIGWINCH, win_changed); - else if (nsig == SIGWINCH) /* signaled called handler */ - signal(SIGWINCH, win_changed); /* set for next call */ - else /* nsig == 0 */ + else if (nsig == SIGWINCH) /* signaled called handler */ + signal(SIGWINCH, win_changed); /* set for next call */ + else /* nsig == 0 */ /* set previous handler */ - signal(SIGWINCH, previous_SIGWINCH_handler); /* reset */ + signal(SIGWINCH, previous_SIGWINCH_handler); /* reset */ } static void cmdedit_reset_term(void) @@ -211,9 +216,9 @@ static void cmdedit_set_out_char(int next_char) int c = (int)((unsigned char) command_ps[cursor]); if (c == 0) - c = ' '; /* destroy end char? */ + c = ' '; /* destroy end char? */ #ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT - if (!Isprint(c)) { /* Inverse put non-printable characters */ + if (!Isprint(c)) { /* Inverse put non-printable characters */ if (c >= 128) c -= 128; if (c < ' ') @@ -270,9 +275,9 @@ static void input_backward(int num) { if (num > cursor) num = cursor; - cursor -= num; /* new cursor (in command, not terminal) */ + cursor -= num; /* new cursor (in command, not terminal) */ - if (cmdedit_x >= num) { /* no to up line */ + if (cmdedit_x >= num) { /* no to up line */ cmdedit_x -= num; if (num < 4) while (num-- > 0) @@ -284,22 +289,22 @@ static void input_backward(int num) int count_y; if (cmdedit_x) { - putchar('\r'); /* back to first terminal pos. */ - num -= cmdedit_x; /* set previous backward */ + putchar('\r'); /* back to first terminal pos. */ + num -= cmdedit_x; /* set previous backward */ } count_y = 1 + num / cmdedit_termw; printf("\033[%dA", count_y); cmdedit_y -= count_y; /* require forward after uping */ cmdedit_x = cmdedit_termw * count_y - num; - printf("\033[%dC", cmdedit_x); /* set term cursor */ + printf("\033[%dC", cmdedit_x); /* set term cursor */ } } static void put_prompt(void) { out1str(cmdedit_prompt); - cmdedit_x = cmdedit_prmt_len; /* count real x terminal position */ + cmdedit_x = cmdedit_prmt_len; /* count real x terminal position */ cursor = 0; cmdedit_y = 0; /* new quasireal y */ } @@ -335,7 +340,7 @@ static void parse_prompt(const char *prmt_ptr) if (c == '\\') { const char *cp = prmt_ptr; int l; - + c = bb_process_escape_sequence(&prmt_ptr); if(prmt_ptr==cp) { if (*cp == 0) @@ -346,7 +351,7 @@ static void parse_prompt(const char *prmt_ptr) case 'u': pbuf = user_buf; break; -#endif +#endif case 'h': pbuf = hostname_buf; if (pbuf == 0) { @@ -378,7 +383,7 @@ static void parse_prompt(const char *prmt_ptr) strcpy(pbuf+1, pwd_buf+l); } break; -#endif +#endif case 'W': pbuf = pwd_buf; cp = strrchr(pbuf,'/'); @@ -391,7 +396,7 @@ static void parse_prompt(const char *prmt_ptr) case 'e': case 'E': /* \e \E = \033 */ c = '\033'; break; - case 'x': case 'X': + case 'x': case 'X': for (l = 0; l < 3;) { int h; buf2[l++] = *prmt_ptr; @@ -416,7 +421,7 @@ static void parse_prompt(const char *prmt_ptr) } break; } - } + } } if(pbuf == buf) *pbuf = c; @@ -437,12 +442,12 @@ static void parse_prompt(const char *prmt_ptr) /* draw promt, editor line, and clear tail */ static void redraw(int y, int back_cursor) { - if (y > 0) /* up to start y */ + if (y > 0) /* up to start y */ printf("\033[%dA", y); putchar('\r'); put_prompt(); - input_end(); /* rewrite */ - printf("\033[J"); /* destroy tail after cursor */ + input_end(); /* rewrite */ + printf("\033[J"); /* destroy tail after cursor */ input_backward(back_cursor); } @@ -456,9 +461,9 @@ static void input_delete(void) strcpy(command_ps + j, command_ps + j + 1); len--; - input_end(); /* rewtite new line */ - cmdedit_set_out_char(0); /* destroy end char */ - input_backward(cursor - j); /* back to old pos cursor */ + input_end(); /* rewtite new line */ + cmdedit_set_out_char(0); /* destroy end char */ + input_backward(cursor - j); /* back to old pos cursor */ } /* Delete the char in back of the cursor */ @@ -496,7 +501,7 @@ static void cmdedit_setwidth(int w, int redraw_flg) redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), len - cursor); fflush(stdout); } - } + } } static void cmdedit_init(void) @@ -527,9 +532,9 @@ static void cmdedit_init(void) #endif my_uid = getuid(); my_gid = getgid(); -#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */ +#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */ handlers_sets |= SET_ATEXIT; - atexit(cmdedit_reset_term); /* be sure to do this only once */ + atexit(cmdedit_reset_term); /* be sure to do this only once */ } } @@ -553,35 +558,35 @@ static char **username_tab_completion(char *ud, int *num_matches) char *temp; - ud++; /* ~user/... to user/... */ + ud++; /* ~user/... to user/... */ userlen = strlen(ud); - if (num_matches == 0) { /* "~/..." or "~user/..." */ + if (num_matches == 0) { /* "~/..." or "~user/..." */ char *sav_ud = ud - 1; char *home = 0; - if (*ud == '/') { /* "~/..." */ + if (*ud == '/') { /* "~/..." */ home = home_pwd_buf; } else { /* "~user/..." */ temp = strchr(ud, '/'); - *temp = 0; /* ~user\0 */ + *temp = 0; /* ~user\0 */ entry = getpwnam(ud); - *temp = '/'; /* restore ~user/... */ + *temp = '/'; /* restore ~user/... */ ud = temp; if (entry) home = entry->pw_dir; } if (home) { if ((userlen + strlen(home) + 1) < BUFSIZ) { - char temp2[BUFSIZ]; /* argument size */ + char temp2[BUFSIZ]; /* argument size */ /* /home/user/... */ sprintf(temp2, "%s%s", home, ud); strcpy(sav_ud, temp2); } } - return 0; /* void, result save to argument :-) */ + return 0; /* void, result save to argument :-) */ } else { /* "~[^/]*" */ char **matches = (char **) NULL; @@ -593,7 +598,7 @@ static char **username_tab_completion(char *ud, int *num_matches) /* Null usernames should result in all users as possible completions. */ if ( /*!userlen || */ !strncmp(ud, entry->pw_name, userlen)) { - bb_xasprintf(&temp, "~%s/", entry->pw_name); + bb_xasprintf(&temp, "~%s/", entry->pw_name); matches = xrealloc(matches, (nm + 1) * sizeof(char *)); matches[nm++] = temp; @@ -605,7 +610,7 @@ static char **username_tab_completion(char *ud, int *num_matches) return (matches); } } -#endif /* CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION */ +#endif /* CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION */ enum { FIND_EXE_ONLY = 0, @@ -630,11 +635,11 @@ static int path_parse(char ***p, int flags) npth = 0; for (;;) { - npth++; /* count words is + 1 count ':' */ + npth++; /* count words is + 1 count ':' */ tmp = strchr(tmp, ':'); if (tmp) { if (*++tmp == 0) - break; /* :<empty> */ + break; /* :<empty> */ } else break; } @@ -643,17 +648,17 @@ static int path_parse(char ***p, int flags) tmp = pth; (*p)[0] = bb_xstrdup(tmp); - npth = 1; /* count words is + 1 count ':' */ + npth = 1; /* count words is + 1 count ':' */ for (;;) { tmp = strchr(tmp, ':'); if (tmp) { - (*p)[0][(tmp - pth)] = 0; /* ':' -> '\0' */ + (*p)[0][(tmp - pth)] = 0; /* ':' -> '\0' */ if (*++tmp == 0) - break; /* :<empty> */ + break; /* :<empty> */ } else break; - (*p)[npth++] = &(*p)[0][(tmp - pth)]; /* p[next]=p[0][&'\0'+1] */ + (*p)[npth++] = &(*p)[0][(tmp - pth)]; /* p[next]=p[0][&'\0'+1] */ } return npth; @@ -703,20 +708,20 @@ static char **exe_n_cwd_tab_completion(char *command, int *num_matches, /* set dir only */ dirbuf[(pfind - command) + 1] = 0; #ifdef CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION - if (dirbuf[0] == '~') /* ~/... or ~user/... */ + if (dirbuf[0] == '~') /* ~/... or ~user/... */ username_tab_completion(dirbuf, 0); #endif /* "strip" dirname in command */ pfind++; paths[0] = dirbuf; - npaths = 1; /* only 1 dir */ + npaths = 1; /* only 1 dir */ } for (i = 0; i < npaths; i++) { dir = opendir(paths[i]); - if (!dir) /* Don't print an error */ + if (!dir) /* Don't print an error */ continue; while ((next = readdir(dir)) != NULL) { @@ -728,17 +733,17 @@ static char **exe_n_cwd_tab_completion(char *command, int *num_matches, /* not see .name without .match */ if (*str_found == '.' && *pfind == 0) { if (*paths[i] == '/' && paths[i][1] == 0 - && str_found[1] == 0) str_found = ""; /* only "/" */ + && str_found[1] == 0) str_found = ""; /* only "/" */ else continue; } found = concat_path_file(paths[i], str_found); /* hmm, remover in progress? */ - if (stat(found, &st) < 0) + if (stat(found, &st) < 0) goto cont; /* find with dirs ? */ if (paths[i] != dirbuf) - strcpy(found, next->d_name); /* only name */ + strcpy(found, next->d_name); /* only name */ if (S_ISDIR(st.st_mode)) { /* name is directory */ str_found = found; @@ -747,7 +752,7 @@ static char **exe_n_cwd_tab_completion(char *command, int *num_matches, str_found = add_quote_for_spec_chars(found); } else { /* not put found file if search only dirs for cd */ - if (type == FIND_DIR_ONLY) + if (type == FIND_DIR_ONLY) goto cont; str_found = add_quote_for_spec_chars(found); if (type == FIND_FILE_ONLY || @@ -764,7 +769,7 @@ cont: closedir(dir); } if (paths != path1) { - free(paths[0]); /* allocated memory only in first member */ + free(paths[0]); /* allocated memory only in first member */ free(paths); } *num_matches = nm; @@ -796,7 +801,7 @@ static int find_match(char *matchBuf, int *len_with_quotes) for (i = 0;; i++) { int_buf[i] = (int) ((unsigned char) matchBuf[i]); if (int_buf[i] == 0) { - pos_buf[i] = -1; /* indicator end line */ + pos_buf[i] = -1; /* indicator end line */ break; } else pos_buf[i] = i; @@ -809,7 +814,7 @@ static int find_match(char *matchBuf, int *len_with_quotes) int_buf[j] |= QUOT; i++; #ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT - if (matchBuf[i] == '\t') /* algorithm equivalent */ + if (matchBuf[i] == '\t') /* algorithm equivalent */ int_buf[j] = ' ' | QUOT; #endif } @@ -852,7 +857,7 @@ static int find_match(char *matchBuf, int *len_with_quotes) } if (command_mode) { collapse_pos(0, i + command_mode); - i = -1; /* hack incremet */ + i = -1; /* hack incremet */ } } /* collapse `command...` */ @@ -869,11 +874,11 @@ static int find_match(char *matchBuf, int *len_with_quotes) collapse_pos(0, i + 1); break; } else - i--; /* hack incremet */ + i--; /* hack incremet */ } /* collapse (command...(command...)...) or {command...{command...}...} */ - c = 0; /* "recursive" level */ + c = 0; /* "recursive" level */ c2 = 0; for (i = 0; int_buf[i]; i++) if (int_buf[i] == '(' || int_buf[i] == '{') { @@ -882,7 +887,7 @@ static int find_match(char *matchBuf, int *len_with_quotes) else c2++; collapse_pos(0, i + 1); - i = -1; /* hack incremet */ + i = -1; /* hack incremet */ } for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++) if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) { @@ -891,7 +896,7 @@ static int find_match(char *matchBuf, int *len_with_quotes) else c2--; collapse_pos(0, i + 1); - i = -1; /* hack incremet */ + i = -1; /* hack incremet */ } /* skip first not quote space */ @@ -927,7 +932,7 @@ static int find_match(char *matchBuf, int *len_with_quotes) /* skip first not quoted '\'' or '"' */ for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++); /* collapse quote or unquote // or /~ */ - while ((int_buf[i] & ~QUOT) == '/' && + while ((int_buf[i] & ~QUOT) == '/' && ((int_buf[i + 1] & ~QUOT) == '/' || (int_buf[i + 1] & ~QUOT) == '~')) { i++; @@ -991,7 +996,7 @@ static void input_tab(int *lastWasTab) static int num_matches; static char **matches; - if (lastWasTab == 0) { /* free all memory */ + if (lastWasTab == 0) { /* free all memory */ if (matches) { while (num_matches > 0) free(matches[--num_matches]); @@ -1008,7 +1013,7 @@ static void input_tab(int *lastWasTab) int find_type; int recalc_pos; - *lastWasTab = TRUE; /* flop trigger */ + *lastWasTab = TRUE; /* flop trigger */ /* Make a local copy of the string -- up * to the position of the cursor */ @@ -1061,7 +1066,7 @@ static void input_tab(int *lastWasTab) beep(); if (!matches) - return; /* not found */ + return; /* not found */ /* sort */ qsort(matches, num_matches, sizeof(char *), match_compare); @@ -1073,11 +1078,11 @@ static void input_tab(int *lastWasTab) *tmp1 = 0; break; } - if (*tmp == 0) { /* have unique */ + if (*tmp == 0) { /* have unique */ free(tmp); return; } - } else { /* one match */ + } else { /* one match */ tmp = matches[0]; /* for next completion current found */ *lastWasTab = FALSE; @@ -1111,7 +1116,7 @@ static void input_tab(int *lastWasTab) * just hit TAB again, print a list of all the * available choices... */ if (matches && num_matches > 0) { - int sav_cursor = cursor; /* change goto_new_line() */ + int sav_cursor = cursor; /* change goto_new_line() */ /* Go to the next line */ goto_new_line(); @@ -1120,7 +1125,7 @@ static void input_tab(int *lastWasTab) } } } -#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */ +#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */ #if MAX_HISTORY >= 1 static void get_previous_history(void) @@ -1159,7 +1164,7 @@ extern void load_history ( const char *fromfile ) } if (( fp = fopen ( fromfile, "r" ))) { - + for ( hi = 0; hi < MAX_HISTORY; ) { char * hl = bb_get_chomped_line_from_file(fp); int l; @@ -1183,10 +1188,10 @@ extern void load_history ( const char *fromfile ) extern void save_history ( const char *tofile ) { FILE *fp = fopen ( tofile, "w" ); - + if ( fp ) { int i; - + for ( i = 0; i < n_history; i++ ) { fputs ( history [i], fp ); fputc ( '\n', fp ); @@ -1220,7 +1225,7 @@ enum { * Furthermore, the "vi" command editing keys are not implemented. * */ - + int cmdedit_read_input(char *prompt, char command[BUFSIZ]) { @@ -1230,7 +1235,7 @@ int cmdedit_read_input(char *prompt, char command[BUFSIZ]) unsigned char c = 0; /* prepare before init handlers */ - cmdedit_y = 0; /* quasireal y, not true work if line > xt*yt */ + cmdedit_y = 0; /* quasireal y, not true work if line > xt*yt */ len = 0; command_ps = command; @@ -1247,7 +1252,7 @@ int cmdedit_read_input(char *prompt, char command[BUFSIZ]) # ifndef _POSIX_VDISABLE # define _POSIX_VDISABLE '\0' # endif - new_settings.c_cc[VINTR] = _POSIX_VDISABLE; + new_settings.c_cc[VINTR] = _POSIX_VDISABLE; #endif command[0] = 0; @@ -1261,7 +1266,7 @@ int cmdedit_read_input(char *prompt, char command[BUFSIZ]) while (1) { - fflush(stdout); /* buffered out to fast */ + fflush(stdout); /* buffered out to fast */ if (safe_read(0, &c, 1) < 1) /* if we can't read input then exit */ @@ -1287,8 +1292,12 @@ int cmdedit_read_input(char *prompt, char command[BUFSIZ]) goto_new_line(); command[0] = 0; len = 0; +#if !defined(CONFIG_ASH) lastWasTab = FALSE; put_prompt(); +#else + break_out = 2; +#endif break; case 4: /* Control-d -- Delete one character, or exit @@ -1327,14 +1336,14 @@ prepare_to_die: #endif break; case 11: - /* Control-k -- clear to end of line */ + /* Control-k -- clear to end of line */ *(command + cursor) = 0; len = cursor; printf("\033[J"); break; - case 12: + case 12: /* Control-l -- clear screen */ - printf("\033[H"); + printf("\033[H"); redraw(0, len-cursor); break; #if MAX_HISTORY >= 1 @@ -1371,7 +1380,7 @@ prepare_to_die: } switch (c) { #ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION - case '\t': /* Alt-Tab */ + case '\t': /* Alt-Tab */ input_tab(&lastWasTab); break; @@ -1433,7 +1442,7 @@ rewrite_line: break; } - default: /* If it's regular input, do the normal thing */ + default: /* If it's regular input, do the normal thing */ #ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT /* Control-V -- Add non-printable symbol */ if (c == 22) { @@ -1445,19 +1454,19 @@ rewrite_line: } } else #endif - if (!Isprint(c)) /* Skip non-printable characters */ + if (!Isprint(c)) /* Skip non-printable characters */ break; - if (len >= (BUFSIZ - 2)) /* Need to leave space for enter */ + if (len >= (BUFSIZ - 2)) /* Need to leave space for enter */ break; len++; - if (cursor == (len - 1)) { /* Append if at the end of the line */ + if (cursor == (len - 1)) { /* Append if at the end of the line */ *(command + cursor) = c; *(command + cursor + 1) = 0; cmdedit_set_out_char(0); - } else { /* Insert otherwise */ + } else { /* Insert otherwise */ int sc = cursor; memmove(command + sc + 1, command + sc, len - sc); @@ -1471,7 +1480,7 @@ rewrite_line: break; } - if (break_out) /* Enter is the command terminator, no more input. */ + if (break_out) /* Enter is the command terminator, no more input. */ break; if (c != '\t') @@ -1486,7 +1495,7 @@ rewrite_line: /* cleanup may be saved current command line */ free(history[MAX_HISTORY]); history[MAX_HISTORY] = 0; - if (len) { /* no put empty line */ + if (len) { /* no put empty line */ int i = n_history; /* After max history, remove the oldest command */ if (i >= MAX_HISTORY) { @@ -1508,23 +1517,27 @@ rewrite_line: } #endif #endif /* MAX_HISTORY >= 1 */ - if(break_out>0) { - command[len++] = '\n'; /* set '\n' */ - command[len] = 0; + if(break_out == 1) { + command[len++] = '\n'; /* set '\n' */ + command[len] = 0; } #if defined(CONFIG_FEATURE_CLEAN_UP) && defined(CONFIG_FEATURE_COMMAND_TAB_COMPLETION) - input_tab(0); /* strong free */ + input_tab(0); /* strong free */ #endif #if defined(CONFIG_FEATURE_SH_FANCY_PROMPT) free(cmdedit_prompt); #endif cmdedit_reset_term(); +#if !defined(CONFIG_ASH) return len; +#else + return break_out < 0 ? break_out : len; +#endif } -#endif /* CONFIG_FEATURE_COMMAND_EDITING */ +#endif /* CONFIG_FEATURE_COMMAND_EDITING */ #ifdef TEST @@ -1565,4 +1578,4 @@ int main(int argc, char **argv) return 0; } -#endif /* TEST */ +#endif /* TEST */ |