diff options
Diffstat (limited to 'release/src/router/busybox/shell/ash.c')
| -rw-r--r-- | release/src/router/busybox/shell/ash.c | 19075 |
1 files changed, 9806 insertions, 9269 deletions
diff --git a/release/src/router/busybox/shell/ash.c b/release/src/router/busybox/shell/ash.c index 2b99a325..f753a5ba 100644 --- a/release/src/router/busybox/shell/ash.c +++ b/release/src/router/busybox/shell/ash.c @@ -5,36 +5,19 @@ * Copyright (c) 1989, 1991, 1993, 1994 * The Regents of the University of California. All rights reserved. * - * Copyright (c) 1997-2003 Herbert Xu <herbert@debian.org> + * Copyright (c) 1997-2005 Herbert Xu <herbert@gondor.apana.org.au> * was re-ported from NetBSD and debianized. * - * * This code is derived from software contributed to Berkeley by * Kenneth Almquist. * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * - * Modified by Vladimir Oleynik <dzo@simtreas.ru> to be used in busybox - * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. * * Original BSD copyright notice is retained at the end of this file. */ /* - * The follow should be set to reflect the type of system you have: + * The following 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) @@ -43,146 +26,135 @@ * When debugging is on, debugging info will be written to ./trace and * a quit signal will generate a core dump. */ +#define DEBUG 0 +/* Tweak debug output verbosity here */ +#define DEBUG_TIME 0 +#define DEBUG_PID 1 +#define DEBUG_SIG 1 - +#define PROFILE 0 #define IFS_BROKEN -#define PROFILE 0 +#define JOBS ENABLE_ASH_JOB_CONTROL + +#if DEBUG +# ifndef _GNU_SOURCE +# define _GNU_SOURCE +# endif +#endif -#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> -#include <fcntl.h> -#include <limits.h> +#include "busybox.h" /* for applet_names */ +//TODO: pull in some .h and find out do we have SINGLE_APPLET_MAIN? +//#include "applet_tables.h" doesn't work #include <paths.h> #include <setjmp.h> -#include <signal.h> -#include <stdint.h> -#include <sysexits.h> - #include <fnmatch.h> -#include <glob.h> - - - -#include "busybox.h" -#include "pwd_.h" - -#ifdef CONFIG_ASH_JOB_CONTROL -#define JOBS 1 -#else -#undef JOBS -#endif +#include "math.h" -#if JOBS -#include <termios.h> +#if defined SINGLE_APPLET_MAIN +/* STANDALONE does not make sense, and won't compile */ +#undef CONFIG_FEATURE_SH_STANDALONE +#undef ENABLE_FEATURE_SH_STANDALONE +#undef USE_FEATURE_SH_STANDALONE +#undef SKIP_FEATURE_SH_STANDALONE(...) +#define ENABLE_FEATURE_SH_STANDALONE 0 +#define USE_FEATURE_SH_STANDALONE(...) +#define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__ #endif -#include "cmdedit.h" - -#ifdef __GLIBC__ -/* glibc sucks */ -static int *dash_errno; -#undef errno -#define errno (*dash_errno) +#ifndef PIPE_BUF +# define PIPE_BUF 4096 /* amount of buffering in a pipe */ #endif #if defined(__uClinux__) -#error "Do not even bother, ash will not run on uClinux" +# error "Do not even bother, ash will not run on NOMMU machine" #endif -#ifdef DEBUG -#define _DIAGASSERT(assert_expr) assert(assert_expr) -#else -#define _DIAGASSERT(assert_expr) -#endif +/* ============ Hash table sizes. Configurable. */ -#ifdef CONFIG_ASH_ALIAS -/* $NetBSD: alias.h,v 1.5 2002/11/24 22:35:38 christos Exp $ */ +#define VTABSIZE 39 +#define ATABSIZE 39 +#define CMDTABLESIZE 31 /* should be prime */ -#define ALIASINUSE 1 -#define ALIASDEAD 2 -struct alias { - struct alias *next; - char *name; - char *val; - int flag; -}; +/* ============ Shell options */ -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 *); +static const char *const optletters_optnames[] = { + "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", + "\0" "vi" +#if DEBUG + ,"\0" "nolog" + ,"\0" "debug" #endif +}; -/* $NetBSD: cd.h,v 1.3 2002/11/24 22:35:39 christos Exp $ */ - - -static void setpwd(const char *, int); - -/* $NetBSD: error.h,v 1.15 2002/11/24 22:35:39 christos Exp $ */ - - -/* - * Types of operations (passed to the errmsg routine). - */ +#define optletters(n) optletters_optnames[(n)][0] +#define optnames(n) (&optletters_optnames[(n)][1]) +enum { NOPTS = ARRAY_SIZE(optletters_optnames) }; -static const char not_found_msg[] = "%s: not found"; +/* ============ Misc data */ -#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 */ +static const char homestr[] ALIGN1 = "HOME"; +static const char snlfmt[] ALIGN1 = "%s\n"; +static const char illnum[] ALIGN1 = "Illegal number: %s"; /* * 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 + * jump to when an exception occurs, and the global variable exception_type + * contains a code identifying the exception. 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; }; -static struct jmploc *handler; -static int exception; -static volatile int suppressint; -static volatile sig_atomic_t intpending; - -static int exerrno; /* Last exec error, error for EXEXEC */ - -/* exceptions */ +struct globals_misc { + /* pid of main shell */ + int rootpid; + /* shell level: 0 for the main shell, 1 for its children, and so on */ + int shlvl; +#define rootshell (!shlvl) + char *minusc; /* argument to -c option */ + + char *curdir; // = nullstr; /* current working directory */ + char *physdir; // = nullstr; /* physical working directory */ + + char *arg0; /* value of $0 */ + + struct jmploc *exception_handler; + +// disabled by vda: cannot understand how it was supposed to work - +// cannot fix bugs. That's why you have to explain your non-trivial designs! +// /* do we generate EXSIG events */ +// int exsig; /* counter */ + volatile int suppressint; /* counter */ +// TODO: rename +// pendingsig -> pending_sig +// intpending -> pending_int + volatile /*sig_atomic_t*/ smallint intpending; /* 1 = got SIGINT */ + /* last pending signal */ + volatile /*sig_atomic_t*/ smallint pendingsig; + smallint exception_type; /* kind of exception (0..5) */ + /* exceptions */ #define EXINT 0 /* SIGINT received */ #define EXERROR 1 /* a generic error */ #define EXSHELLPROC 2 /* execute a shell procedure */ @@ -190,628 +162,2524 @@ static int exerrno; /* Last exec error, error for EXEXEC */ #define EXEXIT 4 /* exit the shell */ #define EXSIG 5 /* trapped signal in wait(1) */ + smallint isloginsh; + char nullstr[1]; /* zero length string */ + + char optlist[NOPTS]; +#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 viflag optlist[13] +#if DEBUG +#define nolog optlist[14] +#define debug optlist[15] +#endif + + /* trap handler commands */ + /* + * 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. + */ + char sigmode[NSIG - 1]; +#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 */ + + /* indicates specified signal received */ + uint8_t gotsig[NSIG - 1]; /* offset by 1: "signal" 0 is meaningless */ + char *trap[NSIG]; + + /* Rarely referenced stuff */ +#if ENABLE_ASH_RANDOM_SUPPORT + /* Random number generators */ + int32_t random_galois_LFSR; /* Galois LFSR (fast but weak). signed! */ + uint32_t random_LCG; /* LCG (fast but weak) */ +#endif + pid_t backgndpid; /* pid of last background process */ + smallint job_warning; /* user was warned about stopped jobs (can be 2, 1 or 0). */ +}; +extern struct globals_misc *const ash_ptr_to_globals_misc; +#define G_misc (*ash_ptr_to_globals_misc) +#define rootpid (G_misc.rootpid ) +#define shlvl (G_misc.shlvl ) +#define minusc (G_misc.minusc ) +#define curdir (G_misc.curdir ) +#define physdir (G_misc.physdir ) +#define arg0 (G_misc.arg0 ) +#define exception_handler (G_misc.exception_handler) +#define exception_type (G_misc.exception_type ) +#define suppressint (G_misc.suppressint ) +#define intpending (G_misc.intpending ) +//#define exsig (G_misc.exsig ) +#define pendingsig (G_misc.pendingsig ) +#define isloginsh (G_misc.isloginsh ) +#define nullstr (G_misc.nullstr ) +#define optlist (G_misc.optlist ) +#define sigmode (G_misc.sigmode ) +#define gotsig (G_misc.gotsig ) +#define trap (G_misc.trap ) +#define random_galois_LFSR (G_misc.random_galois_LFSR) +#define random_LCG (G_misc.random_LCG ) +#define backgndpid (G_misc.backgndpid ) +#define job_warning (G_misc.job_warning) +#define INIT_G_misc() do { \ + (*(struct globals_misc**)&ash_ptr_to_globals_misc) = xzalloc(sizeof(G_misc)); \ + barrier(); \ + curdir = nullstr; \ + physdir = nullstr; \ +} while (0) + + +/* ============ DEBUG */ +#if DEBUG +static void trace_printf(const char *fmt, ...); +static void trace_vprintf(const char *fmt, va_list va); +# define TRACE(param) trace_printf param +# define TRACEV(param) trace_vprintf param +# define close(fd) do { \ + int dfd = (fd); \ + if (close(dfd) < 0) \ + bb_error_msg("bug on %d: closing %d(%x)", \ + __LINE__, dfd, dfd); \ +} while (0) +#else +# define TRACE(param) +# define TRACEV(param) +#endif + + +/* ============ Utility functions */ +#define xbarrier() do { __asm__ __volatile__ ("": : :"memory"); } while (0) + +/* C99 say: "char" declaration may be signed or unsigned by default */ +#define signed_char2int(sc) ((int)(signed char)(sc)) + +static int isdigit_str9(const char *str) +{ + int maxlen = 9 + 1; /* max 9 digits: 999999999 */ + while (--maxlen && isdigit(*str)) + str++; + return (*str == '\0'); +} -/* do we generate EXSIG events */ -static int exsig; -/* last pending signal */ -static volatile sig_atomic_t pendingsigs; +/* ============ Interrupts / exceptions */ /* * These macros allow the user to suspend the handling of interrupt signals - * over a period of time. This is similar to SIGHOLD to or sigblock, but + * over a period of time. This is similar to SIGHOLD or to sigblock, but * much more efficient and portable. (But hacking the kernel is so much * more fun than worrying about efficiency and portability. :-)) */ +#define INT_OFF do { \ + suppressint++; \ + xbarrier(); \ +} while (0) + +/* + * Called to raise an exception. Since C doesn't include exceptions, we + * just do a longjmp to the exception handler. The type of exception is + * stored in the global variable "exception_type". + */ +static void raise_exception(int) NORETURN; +static void +raise_exception(int e) +{ +#if DEBUG + if (exception_handler == NULL) + abort(); +#endif + INT_OFF; + exception_type = e; + longjmp(exception_handler->loc, 1); +} +#if DEBUG +#define raise_exception(e) do { \ + TRACE(("raising exception %d on line %d\n", (e), __LINE__)); \ + raise_exception(e); \ +} while (0) +#endif + +/* + * 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 INT_OFF macro. (The test for iflag is just + * defensive programming.) + */ +static void raise_interrupt(void) NORETURN; +static void +raise_interrupt(void) +{ + int ex_type; -#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 *, ...); - -#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE -static void -inton(void) { + intpending = 0; + /* Signal is not automatically unmasked after it is raised, + * do it ourself - unmask all signals */ + sigprocmask_allsigs(SIG_UNBLOCK); + /* pendingsig = 0; - now done in onsig() */ + + ex_type = EXSIG; + if (gotsig[SIGINT - 1] && !trap[SIGINT]) { + if (!(rootshell && iflag)) { + /* Kill ourself with SIGINT */ + signal(SIGINT, SIG_DFL); + raise(SIGINT); + } + ex_type = EXINT; + } + raise_exception(ex_type); + /* NOTREACHED */ +} +#if DEBUG +#define raise_interrupt() do { \ + TRACE(("raising interrupt on line %d\n", __LINE__)); \ + raise_interrupt(); \ +} while (0) +#endif + +static USE_ASH_OPTIMIZE_FOR_SIZE(inline) void +int_on(void) +{ + xbarrier(); if (--suppressint == 0 && intpending) { - onint(); + raise_interrupt(); } } -#define INTON inton() -static void forceinton(void) +#define INT_ON int_on() +static USE_ASH_OPTIMIZE_FOR_SIZE(inline) void +force_int_on(void) { + xbarrier(); suppressint = 0; if (intpending) - onint(); + raise_interrupt(); } -#define FORCEINTON forceinton() -#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 */ +#define FORCE_INT_ON force_int_on() -/* - * BSD setjmp saves the signal mask, which violates ANSI C and takes time, - * so we use _setjmp instead. - */ +#define SAVE_INT(v) ((v) = suppressint) -#if defined(BSD) && !defined(__SVR4) && !defined(__GLIBC__) -#define setjmp(jmploc) _setjmp(jmploc) -#define longjmp(jmploc, val) _longjmp(jmploc, val) -#endif +#define RESTORE_INT(v) do { \ + xbarrier(); \ + suppressint = (v); \ + if (suppressint == 0 && intpending) \ + raise_interrupt(); \ +} while (0) -/* $NetBSD: expand.h,v 1.13 2002/11/24 22:35:40 christos Exp $ */ -struct strlist { - struct strlist *next; - char *text; -}; +/* ============ Stdout/stderr output */ + +static void +outstr(const char *p, FILE *file) +{ + INT_OFF; + fputs(p, file); + INT_ON; +} +static void +flush_stdout_stderr(void) +{ + INT_OFF; + fflush(stdout); + fflush(stderr); + INT_ON; +} -struct arglist { - struct strlist *list; - struct strlist **lastp; -}; +static void +flush_stderr(void) +{ + INT_OFF; + fflush(stderr); + INT_ON; +} -/* - * 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 */ +static void +outcslow(int c, FILE *dest) +{ + INT_OFF; + putc(c, dest); + fflush(dest); + INT_ON; +} +static int out1fmt(const char *, ...) __attribute__((__format__(__printf__,1,2))); +static int +out1fmt(const char *fmt, ...) +{ + va_list ap; + int r; -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 *); + INT_OFF; + va_start(ap, fmt); + r = vprintf(fmt, ap); + va_end(ap); + INT_ON; + return r; +} -#ifdef CONFIG_ASH_MATH_SUPPORT -static void expari(int); -#endif +static int fmtstr(char *, size_t, const char *, ...) __attribute__((__format__(__printf__,3,4))); +static int +fmtstr(char *outbuf, size_t length, const char *fmt, ...) +{ + va_list ap; + int ret; -/* $NetBSD: eval.h,v 1.13 2002/11/24 22:35:39 christos Exp $ */ + va_start(ap, fmt); + INT_OFF; + ret = vsnprintf(outbuf, length, fmt, ap); + va_end(ap); + INT_ON; + return ret; +} -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 */ +static void +out1str(const char *p) +{ + outstr(p, stdout); +} +static void +out2str(const char *p) +{ + outstr(p, stderr); + flush_stderr(); +} -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 */ -}; -/* - * This file was generated by the mknodes program. - */ +/* ============ Parser structures */ -#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 -#define NFOR 11 -#define NCASE 12 -#define NCLIST 13 -#define NDEFUN 14 -#define NARG 15 -#define NTO 16 -#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 +/* control characters in argument strings */ +#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' + +/* 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 VSTRIMRIGHT 0x6 /* ${var%pattern} */ +#define VSTRIMRIGHTMAX 0x7 /* ${var%%pattern} */ +#define VSTRIMLEFT 0x8 /* ${var#pattern} */ +#define VSTRIMLEFTMAX 0x9 /* ${var##pattern} */ +#define VSLENGTH 0xa /* ${#var} */ +#if ENABLE_ASH_BASH_COMPAT +#define VSSUBSTR 0xc /* ${var:position:length} */ +#define VSREPLACE 0xd /* ${var/pattern/replacement} */ +#define VSREPLACEALL 0xe /* ${var//pattern/replacement} */ +#endif + +static const char dolatstr[] ALIGN1 = { + CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0' +}; +#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 +#define NFOR 11 +#define NCASE 12 +#define NCLIST 13 +#define NDEFUN 14 +#define NARG 15 +#define NTO 16 +#if ENABLE_ASH_BASH_COMPAT +#define NTO2 17 +#endif +#define NCLOBBER 18 +#define NFROM 19 +#define NFROMTO 20 +#define NAPPEND 21 +#define NTOFD 22 +#define NFROMFD 23 +#define NHERE 24 +#define NXHERE 25 +#define NNOT 26 +#define N_NUMBER 27 +union node; struct ncmd { - int type; - union node *assign; - union node *args; - union node *redirect; + smallint type; /* Nxxxx */ + union node *assign; + union node *args; + union node *redirect; }; - struct npipe { - int type; - int backgnd; - struct nodelist *cmdlist; + smallint type; + smallint pipe_backgnd; + struct nodelist *cmdlist; }; - struct nredir { - int type; - union node *n; - union node *redirect; + smallint type; + union node *n; + union node *redirect; }; - struct nbinary { - int type; - union node *ch1; - union node *ch2; + smallint type; + union node *ch1; + union node *ch2; }; - struct nif { - int type; - union node *test; - union node *ifpart; - union node *elsepart; + smallint type; + union node *test; + union node *ifpart; + union node *elsepart; }; - struct nfor { - int type; - union node *args; - union node *body; - char *var; + smallint type; + union node *args; + union node *body; + char *var; }; - struct ncase { - int type; - union node *expr; - union node *cases; + smallint type; + union node *expr; + union node *cases; }; - struct nclist { - int type; - union node *next; - union node *pattern; - union node *body; + smallint type; + union node *next; + union node *pattern; + union node *body; }; - struct narg { - int type; - union node *next; - char *text; - struct nodelist *backquote; + smallint type; + union node *next; + char *text; + struct nodelist *backquote; }; - +/* nfile and ndup layout must match! + * NTOFD (>&fdnum) uses ndup structure, but we may discover mid-flight + * that it is actually NTO2 (>&file), and change its type. + */ struct nfile { - int type; - union node *next; - int fd; - union node *fname; - char *expfname; + smallint type; + union node *next; + int fd; + int _unused_dupfd; + union node *fname; + char *expfname; }; - struct ndup { - int type; - union node *next; - int fd; - int dupfd; - union node *vname; + smallint type; + union node *next; + int fd; + int dupfd; + union node *vname; + char *_unused_expfname; }; - struct nhere { - int type; - union node *next; - int fd; - union node *doc; + smallint type; + union node *next; + int fd; + union node *doc; }; - struct nnot { - int type; - union node *com; + smallint type; + union node *com; }; - union node { - 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; + smallint 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; }; - struct nodelist { struct nodelist *next; union node *n; }; - struct funcnode { int count; union node n; }; +/* + * Free a parse tree. + */ +static void +freefunc(struct funcnode *f) +{ + if (f && --f->count < 0) + free(f); +} -static void freefunc(struct funcnode *); -/* $NetBSD: parser.h,v 1.15 2002/11/24 22:35:42 christos Exp $ */ -/* 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 */ +/* ============ Debugging output */ -/* 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 */ +#if DEBUG -/* 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} */ +static FILE *tracefile; -/* values of checkkwd variable */ -#define CHKALIAS 0x1 -#define CHKKWD 0x2 -#define CHKNL 0x4 +static void +trace_printf(const char *fmt, ...) +{ + va_list va; + + if (debug != 1) + return; + if (DEBUG_TIME) + fprintf(tracefile, "%u ", (int) time(NULL)); + if (DEBUG_PID) + fprintf(tracefile, "[%u] ", (int) getpid()); + if (DEBUG_SIG) + fprintf(tracefile, "pending s:%d i:%d(supp:%d) ", pendingsig, intpending, suppressint); + va_start(va, fmt); + vfprintf(tracefile, fmt, va); + va_end(va); +} + +static void +trace_vprintf(const char *fmt, va_list va) +{ + if (debug != 1) + return; + if (DEBUG_TIME) + fprintf(tracefile, "%u ", (int) time(NULL)); + if (DEBUG_PID) + fprintf(tracefile, "[%u] ", (int) getpid()); + if (DEBUG_SIG) + fprintf(tracefile, "pending s:%d i:%d(supp:%d) ", pendingsig, intpending, suppressint); + vfprintf(tracefile, fmt, va); +} + +static void +trace_puts(const char *s) +{ + if (debug != 1) + return; + fputs(s, tracefile); +} + +static void +trace_puts_quoted(char *s) +{ + char *p; + char c; + + if (debug != 1) + return; + putc('"', tracefile); + 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); + putc(c, tracefile); + break; + default: + if (*p >= ' ' && *p <= '~') + putc(*p, tracefile); + else { + putc('\\', tracefile); + putc(*p >> 6 & 03, tracefile); + putc(*p >> 3 & 07, tracefile); + putc(*p & 07, tracefile); + } + break; + } + } + putc('"', tracefile); +} -#define IBUFSIZ (BUFSIZ + 1) +static void +trace_puts_args(char **ap) +{ + if (debug != 1) + return; + if (!*ap) + return; + while (1) { + trace_puts_quoted(*ap); + if (!*++ap) { + putc('\n', tracefile); + break; + } + putc(' ', tracefile); + } +} + +static void +opentrace(void) +{ + char s[100]; +#ifdef O_APPEND + int flags; +#endif + + if (debug != 1) { + if (tracefile) + fflush(tracefile); + /* leave open because libedit might be using it */ + return; + } + strcpy(s, "./trace"); + if (tracefile) { + if (!freopen(s, "a", tracefile)) { + fprintf(stderr, "Can't re-open %s\n", s); + debug = 0; + return; + } + } else { + tracefile = fopen(s, "a"); + if (tracefile == NULL) { + fprintf(stderr, "Can't open %s\n", s); + debug = 0; + return; + } + } +#ifdef O_APPEND + flags = fcntl(fileno(tracefile), F_GETFL); + if (flags >= 0) + fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND); +#endif + setlinebuf(tracefile); + fputs("\nTracing started.\n", tracefile); +} + +static void +indent(int amount, char *pfx, FILE *fp) +{ + int i; + + for (i = 0; i < amount; i++) { + if (pfx && i == amount - 1) + fputs(pfx, fp); + putc('\t', fp); + } +} + +/* little circular references here... */ +static void shtree(union node *n, int ind, char *pfx, FILE *fp); + +static void +sharg(union node *arg, FILE *fp) +{ + char *p; + struct nodelist *bqlist; + int subtype; + + if (arg->type != NARG) { + out1fmt("<node type %d>\n", arg->type); + abort(); + } + bqlist = arg->narg.backquote; + for (p = arg->narg.text; *p; p++) { + switch (*p) { + case CTLESC: + putc(*++p, fp); + break; + case CTLVAR: + putc('$', fp); + putc('{', fp); + subtype = *++p; + if (subtype == VSLENGTH) + putc('#', fp); + + while (*p != '=') + putc(*p++, fp); + + if (subtype & VSNUL) + putc(':', fp); + + switch (subtype & VSTYPE) { + case VSNORMAL: + putc('}', fp); + break; + case VSMINUS: + putc('-', fp); + break; + case VSPLUS: + putc('+', fp); + break; + case VSQUESTION: + putc('?', fp); + break; + case VSASSIGN: + putc('=', fp); + break; + case VSTRIMLEFT: + putc('#', fp); + break; + case VSTRIMLEFTMAX: + putc('#', fp); + putc('#', fp); + break; + case VSTRIMRIGHT: + putc('%', fp); + break; + case VSTRIMRIGHTMAX: + putc('%', fp); + putc('%', fp); + break; + case VSLENGTH: + break; + default: + out1fmt("<subtype %d>", subtype); + } + break; + case CTLENDVAR: + putc('}', fp); + break; + case CTLBACKQ: + case CTLBACKQ|CTLQUOTE: + putc('$', fp); + putc('(', fp); + shtree(bqlist->n, -1, NULL, fp); + putc(')', fp); + break; + default: + putc(*p, fp); + break; + } + } +} + +static void +shcmd(union node *cmd, FILE *fp) +{ + union node *np; + int first; + const char *s; + int dftfd; + + first = 1; + for (np = cmd->ncmd.args; np; np = np->narg.next) { + if (!first) + putc(' ', fp); + sharg(np, fp); + first = 0; + } + for (np = cmd->ncmd.redirect; np; np = np->nfile.next) { + if (!first) + putc(' ', fp); + dftfd = 0; + switch (np->nfile.type) { + case NTO: s = ">>"+1; dftfd = 1; break; + case NCLOBBER: s = ">|"; dftfd = 1; break; + case NAPPEND: s = ">>"; dftfd = 1; break; +#if ENABLE_ASH_BASH_COMPAT + case NTO2: +#endif + case NTOFD: s = ">&"; dftfd = 1; break; + case NFROM: s = "<"; break; + case NFROMFD: s = "<&"; break; + case NFROMTO: s = "<>"; break; + default: s = "*error*"; break; + } + if (np->nfile.fd != dftfd) + fprintf(fp, "%d", np->nfile.fd); + fputs(s, fp); + if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) { + fprintf(fp, "%d", np->ndup.dupfd); + } else { + sharg(np->nfile.fname, fp); + } + first = 0; + } +} + +static void +shtree(union node *n, int ind, char *pfx, FILE *fp) +{ + struct nodelist *lp; + const char *s; + + if (n == NULL) + return; + + indent(ind, pfx, fp); + switch (n->type) { + case NSEMI: + s = "; "; + goto binop; + case NAND: + s = " && "; + goto binop; + case NOR: + s = " || "; + binop: + shtree(n->nbinary.ch1, ind, NULL, fp); + /* if (ind < 0) */ + fputs(s, fp); + shtree(n->nbinary.ch2, ind, NULL, fp); + break; + case NCMD: + shcmd(n, fp); + if (ind >= 0) + putc('\n', fp); + break; + case NPIPE: + for (lp = n->npipe.cmdlist; lp; lp = lp->next) { + shcmd(lp->n, fp); + if (lp->next) + fputs(" | ", fp); + } + if (n->npipe.pipe_backgnd) + fputs(" &", fp); + if (ind >= 0) + putc('\n', fp); + break; + default: + fprintf(fp, "<node type %d>", n->type); + if (ind >= 0) + putc('\n', fp); + break; + } +} + +static void +showtree(union node *n) +{ + trace_puts("showtree called\n"); + shtree(n, 1, NULL, stdout); +} + +#endif /* DEBUG */ + + +/* ============ Parser data */ /* - * 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. + * ash_vmsg() needs parsefile->fd, hence parsefile definition is moved up. */ -static int plinno = 1; /* input line number */ +struct strlist { + struct strlist *next; + char *text; +}; -/* number of characters left in input buffer */ -static int parsenleft; /* copy of parsefile->nleft */ -static int parselleft; /* copy of parsefile->lleft */ +struct alias; -/* 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 strpush { + struct strpush *prev; /* preceding string on stack */ + char *prev_string; + int prev_left_in_line; +#if ENABLE_ASH_ALIAS + struct alias *ap; /* if push was associated with an alias */ +#endif + char *string; /* remember the string since it may change */ +}; +struct parsefile { + struct parsefile *prev; /* preceding file on stack */ + int linno; /* current line */ + int fd; /* file descriptor (or -1 if string) */ + int left_in_line; /* number of chars left in this line */ + int left_in_buffer; /* number of chars left in this buffer past the line */ + char *next_to_pgetc; /* 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 */ +}; -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 struct parsefile basepf; /* top level input file */ +static struct parsefile *g_parsefile = &basepf; /* current input file */ static int startlinno; /* line # where last token started */ +static char *commandname; /* currently executing command */ +static struct strlist *cmdenviron; /* environment for builtin command */ +static uint8_t exitstatus; /* exit status of last command */ -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 $ */ +/* ============ Message printing */ + +static void +ash_vmsg(const char *msg, va_list ap) +{ + fprintf(stderr, "%s: ", arg0); + if (commandname) { + if (strcmp(arg0, commandname)) + fprintf(stderr, "%s: ", commandname); + if (!iflag || g_parsefile->fd) + fprintf(stderr, "line %d: ", startlinno); + } + vfprintf(stderr, msg, ap); + outcslow('\n', stderr); +} + +/* + * 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 ash_vmsg_and_raise(int, const char *, va_list) NORETURN; +static void +ash_vmsg_and_raise(int cond, const char *msg, va_list ap) +{ +#if DEBUG + if (msg) { + TRACE(("ash_vmsg_and_raise(%d, \"", cond)); + TRACEV((msg, ap)); + TRACE(("\") pid=%d\n", getpid())); + } else + TRACE(("ash_vmsg_and_raise(%d, NULL) pid=%d\n", cond, getpid())); + if (msg) +#endif + ash_vmsg(msg, ap); + + flush_stdout_stderr(); + raise_exception(cond); + /* NOTREACHED */ +} + +static void ash_msg_and_raise_error(const char *, ...) NORETURN; +static void +ash_msg_and_raise_error(const char *msg, ...) +{ + va_list ap; + + va_start(ap, msg); + ash_vmsg_and_raise(EXERROR, msg, ap); + /* NOTREACHED */ + va_end(ap); +} + +static void raise_error_syntax(const char *) NORETURN; +static void +raise_error_syntax(const char *msg) +{ + ash_msg_and_raise_error("syntax error: %s", msg); + /* NOTREACHED */ +} -typedef void *pointer; +static void ash_msg_and_raise(int, const char *, ...) NORETURN; +static void +ash_msg_and_raise(int cond, const char *msg, ...) +{ + va_list ap; -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"; + va_start(ap, msg); + ash_vmsg_and_raise(cond, msg, ap); + /* NOTREACHED */ + va_end(ap); +} -#ifdef DEBUG -#define TRACE(param) trace param -#define TRACEV(param) tracev param +/* + * error/warning routines for external builtins + */ +static void +ash_msg(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + ash_vmsg(fmt, ap); + va_end(ap); +} + +/* + * Return a string describing an error. The returned string may be a + * pointer to a static buffer that will be overwritten on the next call. + * Action describes the operation that got the error. + */ +static const char * +errmsg(int e, const char *em) +{ + if (e == ENOENT || e == ENOTDIR) { + return em; + } + return strerror(e); +} + + +/* ============ Memory allocation */ + +/* + * 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) +enum { + /* Most machines require the value returned from malloc to be aligned + * in some way. The following macro will get this right + * on many machines. */ + SHELL_SIZE = sizeof(union {int i; char *cp; double d; }) - 1, + /* Minimum size of a block */ + MINSIZE = SHELL_ALIGN(504), +}; + +struct stack_block { + struct stack_block *prev; + char space[MINSIZE]; +}; + +struct stackmark { + struct stack_block *stackp; + char *stacknxt; + size_t stacknleft; + struct stackmark *marknext; +}; + + +struct globals_memstack { + struct stack_block *g_stackp; // = &stackbase; + struct stackmark *markp; + char *g_stacknxt; // = stackbase.space; + char *sstrend; // = stackbase.space + MINSIZE; + size_t g_stacknleft; // = MINSIZE; + int herefd; // = -1; + struct stack_block stackbase; +}; +extern struct globals_memstack *const ash_ptr_to_globals_memstack; +#define G_memstack (*ash_ptr_to_globals_memstack) +#define g_stackp (G_memstack.g_stackp ) +#define markp (G_memstack.markp ) +#define g_stacknxt (G_memstack.g_stacknxt ) +#define sstrend (G_memstack.sstrend ) +#define g_stacknleft (G_memstack.g_stacknleft) +#define herefd (G_memstack.herefd ) +#define stackbase (G_memstack.stackbase ) +#define INIT_G_memstack() do { \ + (*(struct globals_memstack**)&ash_ptr_to_globals_memstack) = xzalloc(sizeof(G_memstack)); \ + barrier(); \ + g_stackp = &stackbase; \ + g_stacknxt = stackbase.space; \ + g_stacknleft = MINSIZE; \ + sstrend = stackbase.space + MINSIZE; \ + herefd = -1; \ +} while (0) + +#define stackblock() ((void *)g_stacknxt) +#define stackblocksize() g_stacknleft + + +static void * +ckrealloc(void * p, size_t nbytes) +{ + p = realloc(p, nbytes); + if (!p) + ash_msg_and_raise_error(bb_msg_memory_exhausted); + return p; +} + +static void * +ckmalloc(size_t nbytes) +{ + return ckrealloc(NULL, nbytes); +} + +static void * +ckzalloc(size_t nbytes) +{ + return memset(ckmalloc(nbytes), 0, nbytes); +} + +/* + * Make a copy of a string in safe storage. + */ +static char * +ckstrdup(const char *s) +{ + char *p = strdup(s); + if (!p) + ash_msg_and_raise_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 void * +stalloc(size_t nbytes) +{ + char *p; + size_t aligned; + + aligned = SHELL_ALIGN(nbytes); + if (aligned > g_stacknleft) { + size_t len; + size_t blocksize; + struct stack_block *sp; + + blocksize = aligned; + if (blocksize < MINSIZE) + blocksize = MINSIZE; + len = sizeof(struct stack_block) - MINSIZE + blocksize; + if (len < blocksize) + ash_msg_and_raise_error(bb_msg_memory_exhausted); + INT_OFF; + sp = ckmalloc(len); + sp->prev = g_stackp; + g_stacknxt = sp->space; + g_stacknleft = blocksize; + sstrend = g_stacknxt + blocksize; + g_stackp = sp; + INT_ON; + } + p = g_stacknxt; + g_stacknxt += aligned; + g_stacknleft -= aligned; + return p; +} + +static void * +stzalloc(size_t nbytes) +{ + return memset(stalloc(nbytes), 0, nbytes); +} + +static void +stunalloc(void *p) +{ +#if DEBUG + if (!p || (g_stacknxt < (char *)p) || ((char *)p < g_stackp->space)) { + write(STDERR_FILENO, "stunalloc\n", 10); + abort(); + } +#endif + g_stacknleft += g_stacknxt - (char *)p; + g_stacknxt = p; +} + +/* + * Like strdup but works with the ash stack. + */ +static char * +ststrdup(const char *p) +{ + size_t len = strlen(p) + 1; + return memcpy(stalloc(len), p, len); +} + +static void +setstackmark(struct stackmark *mark) +{ + mark->stackp = g_stackp; + mark->stacknxt = g_stacknxt; + mark->stacknleft = g_stacknleft; + mark->marknext = markp; + markp = mark; +} + +static void +popstackmark(struct stackmark *mark) +{ + struct stack_block *sp; + + if (!mark->stackp) + return; + + INT_OFF; + markp = mark->marknext; + while (g_stackp != mark->stackp) { + sp = g_stackp; + g_stackp = sp->prev; + free(sp); + } + g_stacknxt = mark->stacknxt; + g_stacknleft = mark->stacknleft; + sstrend = mark->stacknxt + mark->stacknleft; + INT_ON; +} + +/* + * When the parser reads in a string, it wants to stick the string on the + * stack and only adjust the stack pointer when it knows how big the + * string is. Stackblock (defined in stack.h) returns a pointer to a block + * of space on top of the stack and stackblocklen returns the length of + * this block. Growstackblock will grow this space by at least one byte, + * possibly moving it (like realloc). Grabstackblock actually allocates the + * part of the block that has been used. + */ +static void +growstackblock(void) +{ + size_t newlen; + + newlen = g_stacknleft * 2; + if (newlen < g_stacknleft) + ash_msg_and_raise_error(bb_msg_memory_exhausted); + if (newlen < 128) + newlen += 128; + + if (g_stacknxt == g_stackp->space && g_stackp != &stackbase) { + struct stack_block *oldstackp; + struct stackmark *xmark; + struct stack_block *sp; + struct stack_block *prevstackp; + size_t grosslen; + + INT_OFF; + oldstackp = g_stackp; + sp = g_stackp; + prevstackp = sp->prev; + grosslen = newlen + sizeof(struct stack_block) - MINSIZE; + sp = ckrealloc(sp, grosslen); + sp->prev = prevstackp; + g_stackp = sp; + g_stacknxt = sp->space; + g_stacknleft = newlen; + 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 = g_stackp; + xmark->stacknxt = g_stacknxt; + xmark->stacknleft = g_stacknleft; + xmark = xmark->marknext; + } + INT_ON; + } else { + char *oldspace = g_stacknxt; + size_t oldlen = g_stacknleft; + char *p = stalloc(newlen); + + /* free the space we just allocated */ + g_stacknxt = memcpy(p, oldspace, oldlen); + g_stacknleft += newlen; + } +} + +static void +grabstackblock(size_t len) +{ + len = SHELL_ALIGN(len); + g_stacknxt += len; + g_stacknleft -= len; +} + +/* + * 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 + * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is + * grown as necessary. When the user is done, she can just leave the + * string there and refer to it using stackblock(). Or she can allocate + * the space for it using grabstackstr(). If it is necessary to allow + * someone else to use the stack temporarily and then continue to grow + * the string, the user should use grabstack to allocate the space, and + * then call ungrabstr(p) to return to the previous mode of operation. + * + * USTPUTC is like STPUTC except that it doesn't check for overflow. + * CHECKSTACKSPACE can be called before USTPUTC to ensure that there + * is space for at least one character. + */ +static void * +growstackstr(void) +{ + size_t len = stackblocksize(); + if (herefd >= 0 && len >= 1024) { + full_write(herefd, stackblock(), len); + return stackblock(); + } + growstackblock(); + return (char *)stackblock() + len; +} + +/* + * Called from CHECKSTRSPACE. + */ +static char * +makestrspace(size_t newlen, char *p) +{ + size_t len = p - g_stacknxt; + size_t size = stackblocksize(); + + for (;;) { + size_t nleft; + + size = stackblocksize(); + nleft = size - len; + if (nleft >= newlen) + break; + growstackblock(); + } + return (char *)stackblock() + len; +} + +static char * +stack_nputstr(const char *s, size_t n, char *p) +{ + p = makestrspace(n, p); + p = (char *)memcpy(p, s, n) + n; + return p; +} + +static char * +stack_putstr(const char *s, char *p) +{ + return stack_nputstr(s, strlen(s), p); +} + +static char * +_STPUTC(int c, char *p) +{ + if (p == sstrend) + p = growstackstr(); + *p++ = c; + return p; +} + +#define STARTSTACKSTR(p) ((p) = stackblock()) +#define STPUTC(c, p) ((p) = _STPUTC((c), (p))) +#define CHECKSTRSPACE(n, p) do { \ + char *q = (p); \ + size_t l = (n); \ + size_t m = sstrend - q; \ + if (l > m) \ + (p) = makestrspace(l, q); \ +} while (0) +#define USTPUTC(c, p) (*(p)++ = (c)) +#define STACKSTRNUL(p) do { \ + if ((p) == sstrend) \ + (p) = growstackstr(); \ + *(p) = '\0'; \ +} while (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) + + +/* ============ String helpers */ + +/* + * prefix -- see if pfx is a prefix of string. + */ +static char * +prefix(const char *string, const char *pfx) +{ + while (*pfx) { + if (*pfx++ != *string++) + return NULL; + } + return (char *) string; +} + +/* + * Check for a valid number. This should be elsewhere. + */ +static int +is_number(const char *p) +{ + do { + if (!isdigit(*p)) + return 0; + } while (*++p != '\0'); + return 1; +} + +/* + * Convert a string of digits to an integer, printing an error message on + * failure. + */ +static int +number(const char *s) +{ + if (!is_number(s)) + ash_msg_and_raise_error(illnum, s); + return atoi(s); +} + +/* + * 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 *p; + + STARTSTACKSTR(p); + + do { + char *q; + size_t len; + + len = strchrnul(s, '\'') - s; + + q = p = makestrspace(len + 3, p); + + *q++ = '\''; + q = (char *)memcpy(q, s, len) + len; + *q++ = '\''; + s += len; + + STADJUST(q - p, p); + + len = strspn(s, "'"); + if (!len) + break; + + q = p = makestrspace(len + 3, p); + + *q++ = '"'; + q = (char *)memcpy(q, s, len) + len; + *q++ = '"'; + s += len; + + STADJUST(q - p, p); + } while (*s); + + USTPUTC(0, p); + + return stackblock(); +} + + +/* ============ nextopt */ + +static char **argptr; /* argument list for builtin commands */ +static char *optionarg; /* set by nextopt (like getopt) */ +static char *optptr; /* used by nextopt */ + +/* + * XXX - should get rid of. Have all builtins use getopt(3). + * The library getopt must have the BSD extension static variable + * "optreset", otherwise it can't be used within the shell safely. + * + * Standard option processing (a la getopt) for builtin routines. + * The only argument that is passed to nextopt is the option string; + * the other arguments are unnecessary. It returns the character, + * or '\0' on end of input. + */ +static int +nextopt(const char *optstring) +{ + char *p; + const char *q; + char c; + + p = optptr; + if (p == NULL || *p == '\0') { + /* We ate entire "-param", take next one */ + p = *argptr; + if (p == NULL) + return '\0'; + if (*p != '-') + return '\0'; + if (*++p == '\0') /* just "-" ? */ + return '\0'; + argptr++; + if (LONE_DASH(p)) /* "--" ? */ + return '\0'; + /* p => next "-param" */ + } + /* p => some option char in the middle of a "-param" */ + c = *p++; + for (q = optstring; *q != c;) { + if (*q == '\0') + ash_msg_and_raise_error("illegal option -%c", c); + if (*++q == ':') + q++; + } + if (*++q == ':') { + if (*p == '\0') { + p = *argptr++; + if (p == NULL) + ash_msg_and_raise_error("no arg for -%c option", c); + } + optionarg = p; + p = NULL; + } + optptr = p; + return c; +} + + +/* ============ Shell variables */ + +/* + * The parsefile structure pointed to by the global variable parsefile + * contains information about the current file being read. + */ +struct shparam { + int nparam; /* # of positional parameters (without $0) */ +#if ENABLE_ASH_GETOPTS + int optind; /* next parameter to be processed by getopts */ + int optoff; /* used by getopts */ +#endif + unsigned char malloced; /* if parameter list dynamically allocated */ + char **p; /* parameter list */ +}; + +/* + * Free the list of positional parameters. + */ +static void +freeparam(volatile struct shparam *param) +{ + if (param->malloced) { + char **ap, **ap1; + ap = ap1 = param->p; + while (*ap) + free(*ap++); + free(ap1); + } +} + +#if ENABLE_ASH_GETOPTS +static void getoptsreset(const char *value); +#endif + +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 */ +}; + +/* 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 */ +#if ENABLE_ASH_RANDOM_SUPPORT +# define VDYNAMIC 0x200 /* dynamic variable */ #else -#define TRACE(param) -#define TRACEV(param) +# define VDYNAMIC 0 #endif -#if defined(__GNUC__) && __GNUC__ < 3 -#define va_copy __va_copy +#ifdef IFS_BROKEN +static const char defifsvar[] ALIGN1 = "IFS= \t\n"; +#define defifs (defifsvar + 4) +#else +static const char defifs[] ALIGN1 = " \t\n"; #endif -#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96) -#define __builtin_expect(x, expected_value) (x) + +/* Need to be before varinit_data[] */ +#if ENABLE_LOCALE_SUPPORT +static void +change_lc_all(const char *value) +{ + if (value && *value != '\0') + setlocale(LC_ALL, value); +} +static void +change_lc_ctype(const char *value) +{ + if (value && *value != '\0') + setlocale(LC_CTYPE, value); +} +#endif +#if ENABLE_ASH_MAIL +static void chkmail(void); +static void changemail(const char *); +#endif +static void changepath(const char *); +#if ENABLE_ASH_RANDOM_SUPPORT +static void change_random(const char *); #endif -#define likely(x) __builtin_expect((x),1) -#define unlikely(x) __builtin_expect((x),0) +static const struct { + int flags; + const char *text; + void (*func)(const char *); +} varinit_data[] = { +#ifdef IFS_BROKEN + { VSTRFIXED|VTEXTFIXED , defifsvar , NULL }, +#else + { VSTRFIXED|VTEXTFIXED|VUNSET, "IFS\0" , NULL }, +#endif +#if ENABLE_ASH_MAIL + { VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL\0" , changemail }, + { VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH\0", changemail }, +#endif + { VSTRFIXED|VTEXTFIXED , bb_PATH_root_path, changepath }, + { VSTRFIXED|VTEXTFIXED , "PS1=$ " , NULL }, + { VSTRFIXED|VTEXTFIXED , "PS2=> " , NULL }, + { VSTRFIXED|VTEXTFIXED , "PS4=+ " , NULL }, +#if ENABLE_ASH_GETOPTS + { VSTRFIXED|VTEXTFIXED , "OPTIND=1" , getoptsreset }, +#endif +#if ENABLE_ASH_RANDOM_SUPPORT + { VSTRFIXED|VTEXTFIXED|VUNSET|VDYNAMIC, "RANDOM\0", change_random }, +#endif +#if ENABLE_LOCALE_SUPPORT + { VSTRFIXED|VTEXTFIXED|VUNSET, "LC_ALL\0" , change_lc_all }, + { VSTRFIXED|VTEXTFIXED|VUNSET, "LC_CTYPE\0", change_lc_ctype }, +#endif +#if ENABLE_FEATURE_EDITING_SAVEHISTORY + { VSTRFIXED|VTEXTFIXED|VUNSET, "HISTFILE\0", NULL }, +#endif +}; -#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 +struct redirtab; -/* 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}", +struct globals_var { + struct shparam shellparam; /* $@ current positional parameters */ + struct redirtab *redirlist; + int g_nullredirs; + int preverrout_fd; /* save fd2 before print debug if xflag is set. */ + struct var *vartab[VTABSIZE]; + struct var varinit[ARRAY_SIZE(varinit_data)]; }; +extern struct globals_var *const ash_ptr_to_globals_var; +#define G_var (*ash_ptr_to_globals_var) +#define shellparam (G_var.shellparam ) +//#define redirlist (G_var.redirlist ) +#define g_nullredirs (G_var.g_nullredirs ) +#define preverrout_fd (G_var.preverrout_fd) +#define vartab (G_var.vartab ) +#define varinit (G_var.varinit ) +#define INIT_G_var() do { \ + unsigned i; \ + (*(struct globals_var**)&ash_ptr_to_globals_var) = xzalloc(sizeof(G_var)); \ + barrier(); \ + for (i = 0; i < ARRAY_SIZE(varinit_data); i++) { \ + varinit[i].flags = varinit_data[i].flags; \ + varinit[i].text = varinit_data[i].text; \ + varinit[i].func = varinit_data[i].func; \ + } \ +} while (0) + +#define vifs varinit[0] +#if ENABLE_ASH_MAIL +# define vmail (&vifs)[1] +# define vmpath (&vmail)[1] +# define vpath (&vmpath)[1] +#else +# define vpath (&vifs)[1] +#endif +#define vps1 (&vpath)[1] +#define vps2 (&vps1)[1] +#define vps4 (&vps2)[1] +#if ENABLE_ASH_GETOPTS +# define voptind (&vps4)[1] +# if ENABLE_ASH_RANDOM_SUPPORT +# define vrandom (&voptind)[1] +# endif +#else +# if ENABLE_ASH_RANDOM_SUPPORT +# define vrandom (&vps4)[1] +# endif +#endif -static const char *tokname(int tok) +/* + * The following macros access the values of the above variables. + * They have to skip over the name. They return the null string + * for unset variables. + */ +#define ifsval() (vifs.text + 4) +#define ifsset() ((vifs.flags & VUNSET) == 0) +#if ENABLE_ASH_MAIL +# define mailval() (vmail.text + 5) +# define mpathval() (vmpath.text + 9) +# define mpathset() ((vmpath.flags & VUNSET) == 0) +#endif +#define pathval() (vpath.text + 5) +#define ps1val() (vps1.text + 4) +#define ps2val() (vps2.text + 4) +#define ps4val() (vps4.text + 4) +#if ENABLE_ASH_GETOPTS +# define optindval() (voptind.text + 7) +#endif + + +#define is_name(c) ((c) == '_' || isalpha((unsigned char)(c))) +#define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c))) + +#if ENABLE_ASH_GETOPTS +static void +getoptsreset(const char *value) { - static char buf[16]; + shellparam.optind = number(value); + shellparam.optoff = -1; +} +#endif - if (tok >= TSEMI) - buf[0] = '"'; - sprintf(buf + (tok >= TSEMI), "%s%c", - tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0)); - return buf; +/* + * Return of a legal variable name (a letter or underscore followed by zero or + * more letters, underscores, and digits). + */ +static char * +endofname(const char *name) +{ + char *p; + + p = (char *) name; + if (!is_name(*p)) + return p; + while (*++p) { + if (!is_in_name(*p)) + break; + } + return p; +} + +/* + * 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 +varcmp(const char *p, const char *q) +{ + int c, d; + + while ((c = *p) == (d = *q)) { + if (!c || c == '=') + goto out; + p++; + q++; + } + if (c == '=') + c = '\0'; + if (d == '=') + d = '\0'; + out: + return c - d; +} + +static int +varequal(const char *a, const char *b) +{ + return !varcmp(a, b); +} + +/* + * Find the appropriate entry in the hash table from the name. + */ +static struct var ** +hashvar(const char *p) +{ + unsigned hashval; + + hashval = ((unsigned char) *p) << 4; + while (*p && *p != '=') + hashval += (unsigned char) *p++; + return &vartab[hashval % VTABSIZE]; } -/* $NetBSD: machdep.h,v 1.10 2002/10/07 14:26:08 christos Exp $ */ +static int +vpcmp(const void *a, const void *b) +{ + return varcmp(*(const char **)a, *(const char **)b); +} /* - * Most machines require the value returned from malloc to be aligned - * in some way. The following macro will get this right on many machines. + * This routine initializes the builtin variables. */ +static void +initvar(void) +{ + struct var *vp; + struct var *end; + struct var **vpp; + + /* + * PS1 depends on uid + */ +#if ENABLE_FEATURE_EDITING && ENABLE_FEATURE_EDITING_FANCY_PROMPT + vps1.text = "PS1=\\w \\$ "; +#else + if (!geteuid()) + vps1.text = "PS1=# "; +#endif + vp = varinit; + end = vp + ARRAY_SIZE(varinit); + do { + vpp = hashvar(vp->text); + vp->next = *vpp; + *vpp = vp; + } while (++vp < end); +} + +static struct var ** +findvar(struct var **vpp, const char *name) +{ + for (; *vpp; vpp = &(*vpp)->next) { + if (varequal((*vpp)->text, name)) { + break; + } + } + return vpp; +} -#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. + * Find the value of a variable. Returns NULL if not set. */ -#define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE) +static const char * +lookupvar(const char *name) +{ + struct var *v; + + v = *findvar(hashvar(name), name); + if (v) { +#if ENABLE_ASH_RANDOM_SUPPORT + /* + * Dynamic variables are implemented roughly the same way they are + * in bash. Namely, they're "special" so long as they aren't unset. + * As soon as they're unset, they're no longer dynamic, and dynamic + * lookup will no longer happen at that point. -- PFM. + */ + if ((v->flags & VDYNAMIC)) + (*v->func)(NULL); +#endif + if (!(v->flags & VUNSET)) + return strchrnul(v->text, '=') + 1; + } + return NULL; +} /* - * This file was generated by the mksyntax program. + * Search the environment of a builtin command. */ +static const char * +bltinlookup(const char *name) +{ + struct strlist *sp; + for (sp = cmdenviron; sp; sp = sp->next) { + if (varequal(sp->text, name)) + return strchrnul(sp->text, '=') + 1; + } + return lookupvar(name); +} -/* 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 +/* + * Same as setvar except that the variable and value are passed in + * 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) +{ + struct var *vp, **vpp; + + vpp = hashvar(s); + flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1)); + vp = *findvar(vpp, s); + if (vp) { + if ((vp->flags & (VREADONLY|VDYNAMIC)) == VREADONLY) { + const char *n; + + if (flags & VNOSAVE) + free(s); + n = vp->text; + ash_msg_and_raise_error("%.*s: is read only", strchrnul(n, '=') - n, n); + } + + if (flags & VNOSET) + return; + + if (vp->func && (flags & VNOFUNC) == 0) + (*vp->func)(strchrnul(s, '=') + 1); + + if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0) + free((char*)vp->text); + + flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET); + } else { + if (flags & VNOSET) + return; + /* not found */ + vp = ckzalloc(sizeof(*vp)); + vp->next = *vpp; + /*vp->func = NULL; - ckzalloc did it */ + *vpp = vp; + } + if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE))) + s = ckstrdup(s); + vp->text = s; + vp->flags = flags; +} + +/* + * 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) +{ + char *p, *q; + size_t namelen; + char *nameeq; + size_t vallen; + + q = endofname(name); + p = strchrnul(q, '='); + namelen = p - name; + if (!namelen || p != q) + ash_msg_and_raise_error("%.*s: bad variable name", namelen, name); + vallen = 0; + if (val == NULL) { + flags |= VUNSET; + } else { + vallen = strlen(val); + } + INT_OFF; + nameeq = ckmalloc(namelen + vallen + 2); + p = (char *)memcpy(nameeq, name, namelen) + namelen; + if (val) { + *p++ = '='; + p = (char *)memcpy(p, val, vallen) + vallen; + } + *p = '\0'; + setvareq(nameeq, flags | VNOSAVE); + INT_ON; +} + +#if ENABLE_ASH_GETOPTS +/* + * Safe version of setvar, returns 1 on success 0 on failure. + */ +static int +setvarsafe(const char *name, const char *val, int flags) +{ + int err; + volatile int saveint; + struct jmploc *volatile savehandler = exception_handler; + struct jmploc jmploc; + + SAVE_INT(saveint); + if (setjmp(jmploc.loc)) + err = 1; + else { + exception_handler = &jmploc; + setvar(name, val, flags); + err = 0; + } + exception_handler = savehandler; + RESTORE_INT(saveint); + return err; +} +#endif + +/* + * Unset the specified variable. + */ +static int +unsetvar(const char *s) +{ + struct var **vpp; + struct var *vp; + int retval; + + vpp = findvar(hashvar(s), s); + vp = *vpp; + retval = 2; + if (vp) { + int flags = vp->flags; + + retval = 1; + if (flags & VREADONLY) + goto out; +#if ENABLE_ASH_RANDOM_SUPPORT + vp->flags &= ~VDYNAMIC; +#endif + if (flags & VUNSET) + goto ok; + if ((flags & VSTRFIXED) == 0) { + INT_OFF; + if ((flags & (VTEXTFIXED|VSTACK)) == 0) + free((char*)vp->text); + *vpp = vp->next; + free(vp); + INT_ON; + } else { + setvar(s, 0, 0); + vp->flags &= ~VEXPORT; + } + ok: + retval = 0; + } + out: + return retval; +} + +/* + * Process a linked list of variable assignments. + */ +static void +listsetvar(struct strlist *list_set_var, int flags) +{ + struct strlist *lp = list_set_var; + + if (!lp) + return; + INT_OFF; + do { + setvareq(lp->text, flags); + lp = lp->next; + } while (lp); + INT_ON; +} + +/* + * Generate a list of variables satisfying the given conditions. + */ +static char ** +listvars(int on, int off, char ***end) +{ + struct var **vpp; + struct var *vp; + char **ep; + int mask; + + 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); +} + + +/* ============ Path search helper + * + * The variable path (passed by reference) should be set to the start + * of the path before the first call; padvance will update + * this value as it proceeds. Successive calls to padvance will return + * the possible path expansions in sequence. If an option (indicated by + * a percent sign) appears in the path entry then the global variable + * pathopt will be set to point to it; otherwise pathopt will be set to + * NULL. + */ +static const char *pathopt; /* set by padvance */ + +static char * +padvance(const char **path, const char *name) +{ + const char *p; + char *q; + const char *start; + size_t len; + + if (*path == NULL) + return NULL; + start = *path; + for (p = start; *p && *p != ':' && *p != '%'; p++) + continue; + len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */ + while (stackblocksize() < len) + growstackblock(); + q = stackblock(); + if (p != start) { + memcpy(q, start, p - start); + q += p - start; + *q++ = '/'; + } + strcpy(q, name); + pathopt = NULL; + if (*p == '%') { + pathopt = ++p; + while (*p && *p != ':') + p++; + } + if (*p == ':') + *path = p + 1; + else + *path = NULL; + return stalloc(len); +} + + +/* ============ Prompt */ + +static smallint doprompt; /* if set, prompt the user */ +static smallint needprompt; /* true if interactive and at start of line */ + +#if ENABLE_FEATURE_EDITING +static line_input_t *line_input_state; +static const char *cmdedit_prompt; +static void +putprompt(const char *s) +{ + if (ENABLE_ASH_EXPAND_PRMT) { + free((char*)cmdedit_prompt); + cmdedit_prompt = ckstrdup(s); + return; + } + cmdedit_prompt = s; +} #else -#define SYNBASE 129 -#define PEOF -129 -#define PEOA_OR_PEOF PEOF +static void +putprompt(const char *s) +{ + out2str(s); +} #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))) +#if ENABLE_ASH_EXPAND_PRMT +/* expandstr() needs parsing machinery, so it is far away ahead... */ +static const char *expandstr(const char *ps); +#else +#define expandstr(s) s +#endif + +static void +setprompt(int whichprompt) +{ + const char *prompt; +#if ENABLE_ASH_EXPAND_PRMT + struct stackmark smark; +#endif + + needprompt = 0; + + switch (whichprompt) { + case 1: + prompt = ps1val(); + break; + case 2: + prompt = ps2val(); + break; + default: /* 0 */ + prompt = nullstr; + } +#if ENABLE_ASH_EXPAND_PRMT + setstackmark(&smark); + stalloc(stackblocksize()); +#endif + putprompt(expandstr(prompt)); +#if ENABLE_ASH_EXPAND_PRMT + popstackmark(&smark); +#endif +} + + +/* ============ The cd and pwd commands */ + +#define CD_PHYSICAL 1 +#define CD_PRINT 2 + +static int docd(const char *, int); + +static int +cdopt(void) +{ + int flags = 0; + int i, j; + + j = 'L'; + while ((i = nextopt("LP"))) { + if (i != j) { + flags ^= CD_PHYSICAL; + j = i; + } + } + + return flags; +} /* - * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise - * (assuming ascii char codes, as the original implementation did) + * Update curdir (the name of the current directory) in response to a + * cd command. */ -#define is_special(c) \ - ( (((unsigned int)c) - 33 < 32) \ - && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1)) +static const char * +updatepwd(const char *dir) +{ + char *new; + char *p; + char *cdcomppath; + const char *lim; + + cdcomppath = ststrdup(dir); + STARTSTACKSTR(new); + if (*dir != '/') { + if (curdir == nullstr) + return 0; + new = stack_putstr(curdir, new); + } + new = makestrspace(strlen(dir) + 2, new); + lim = (char *)stackblock() + 1; + if (*dir != '/') { + if (new[-1] != '/') + USTPUTC('/', new); + if (new > lim && *lim == '/') + lim++; + } else { + 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; + } + if (p[1] == '\0') + break; + /* fall through */ + default: + new = stack_putstr(p, new); + USTPUTC('/', new); + } + p = strtok(0, "/"); + } + if (new > lim) + STUNPUTC(new); + *new = 0; + return stackblock(); +} + +/* + * Find out what the current directory is. If we already know the current + * directory, this routine returns immediately. + */ +static char * +getpwd(void) +{ + char *dir = getcwd(NULL, 0); /* huh, using glibc extension? */ + return dir ? dir : nullstr; +} + +static void +setpwd(const char *val, int setold) +{ + char *oldcur, *dir; + + oldcur = dir = curdir; -#define digit_val(c) ((c) - '0') + if (setold) { + setvar("OLDPWD", oldcur, VEXPORT); + } + INT_OFF; + 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 = ckstrdup(val); + if (oldcur != dir && oldcur != nullstr) { + free(oldcur); + } + curdir = dir; + INT_ON; + setvar("PWD", dir, VEXPORT); +} + +static void hashcd(void); /* - * This file was generated by the mksyntax program. + * 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(const char *dest, int flags) +{ + const char *dir = 0; + int err; -#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE -#define USE_SIT_FUNCTION + TRACE(("docd(\"%s\", %d) called\n", dest, flags)); + + INT_OFF; + if (!(flags & CD_PHYSICAL)) { + dir = updatepwd(dest); + if (dir) + dest = dir; + } + err = chdir(dest); + if (err) + goto out; + setpwd(dir, 1); + hashcd(); + out: + INT_ON; + return err; +} + +static int +cdcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) +{ + const char *dest; + const char *path; + const char *p; + char c; + struct stat statb; + int flags; + + flags = cdopt(); + dest = *argptr; + if (!dest) + dest = bltinlookup(homestr); + else if (LONE_DASH(dest)) { + dest = bltinlookup("OLDPWD"); + flags |= CD_PRINT; + } + 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; + } + } + if (!*dest) + dest = "."; + path = bltinlookup("CDPATH"); + if (!path) { + step6: + step7: + p = dest; + goto docd; + } + do { + c = *path; + p = padvance(&path, dest); + if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) { + if (c && c != ':') + flags |= CD_PRINT; + docd: + if (!docd(p, flags)) + goto out; + break; + } + } while (path); + ash_msg_and_raise_error("can't cd to %s", dest); + /* NOTREACHED */ + out: + if (flags & CD_PRINT) + out1fmt(snlfmt, curdir); + return 0; +} + +static int +pwdcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) +{ + int flags; + const char *dir = curdir; + + flags = cdopt(); + if (flags) { + if (physdir == nullstr) + setpwd(dir, 0); + dir = physdir; + } + out1fmt(snlfmt, dir); + return 0; +} + + +/* ============ ... */ + + +#define IBUFSIZ COMMON_BUFSIZE +/* buffer for top level input file */ +#define basebuf bb_common_bufsiz1 + +/* 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 */ + +#if ENABLE_ASH_ALIAS +#define SYNBASE 130 +#define PEOF -130 +#define PEOA -129 +#define PEOA_OR_PEOF PEOA +#else +#define SYNBASE 129 +#define PEOF -129 +#define PEOA_OR_PEOF PEOF #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 */ +#define PSSYNTAX 4 /* prompt */ -#ifdef CONFIG_ASH_MATH_SUPPORT +#if ENABLE_ASH_OPTIMIZE_FOR_SIZE +#define USE_SIT_FUNCTION +#endif + +#if ENABLE_SH_MATH_SUPPORT static const char S_I_T[][4] = { -#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, } */ +#if ENABLE_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, } */ +#if ENABLE_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 ... */ + { CENDFILE, CENDFILE, CENDFILE }, /* 12, PEOF */ + { CWORD, CWORD, CWORD }, /* 13, 0-9A-Za-z */ + { CCTL, CCTL, CCTL } /* 14, CTLESC ... */ #endif }; -#endif /* CONFIG_ASH_MATH_SUPPORT */ +#endif /* SH_MATH_SUPPORT */ #ifdef USE_SIT_FUNCTION -#define U_C(c) ((unsigned char)(c)) - -static int SIT(int c, int syntax) +static int +SIT(int c, int syntax) { - static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~"; -#ifdef CONFIG_ASH_ALIAS - static const char syntax_index_table[] = { + static const char spec_symbls[] ALIGN1 = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~"; +#if ENABLE_ASH_ALIAS + static const char syntax_index_table[] ALIGN1 = { 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[] = { + static const char syntax_index_table[] ALIGN1 = { 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, /* "=>?[\\]`|" */ @@ -821,65 +2689,68 @@ static int SIT(int c, int syntax) const char *s; int indx; - if (c == PEOF) /* 2^8+2 */ + if (c == PEOF) { /* 2^8+2 */ return CENDFILE; -#ifdef CONFIG_ASH_ALIAS - if (c == PEOA) /* 2^8+1 */ + } +#if ENABLE_ASH_ALIAS + if (c == PEOA) { /* 2^8+1 */ indx = 0; - else + } else #endif - if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK)) + { + if ((unsigned char)c >= (unsigned char)(CTLESC) + && (unsigned char)c <= (unsigned char)(CTLQUOTEMARK) + ) { return CCTL; - else { - s = strchr(spec_symbls, c); - if (s == 0 || *s == 0) + } + s = strchrnul(spec_symbls, c); + if (*s == '\0') { return CWORD; - indx = syntax_index_table[(s - spec_symbls)]; + } + indx = syntax_index_table[s - spec_symbls]; } return S_I_T[indx][syntax]; } -#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_CWORD 4 -#define CVAR_CVAR_CWORD_CVAR 5 -#define CSQUOTE_CWORD_CENDQUOTE_CWORD 6 -#define CSPCL_CWORD_CWORD_CLP 7 -#define CSPCL_CWORD_CWORD_CRP 8 -#define CBACK_CBACK_CCTL_CBACK 9 -#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 10 -#define CENDVAR_CENDVAR_CWORD_CENDVAR 11 -#define CENDFILE_CENDFILE_CENDFILE_CENDFILE 12 -#define CWORD_CWORD_CWORD_CWORD 13 -#define CCTL_CCTL_CCTL_CCTL 14 +#else /* !USE_SIT_FUNCTION */ + +#if ENABLE_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_CWORD 4 +#define CVAR_CVAR_CWORD_CVAR 5 +#define CSQUOTE_CWORD_CENDQUOTE_CWORD 6 +#define CSPCL_CWORD_CWORD_CLP 7 +#define CSPCL_CWORD_CWORD_CRP 8 +#define CBACK_CBACK_CCTL_CBACK 9 +#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 10 +#define CENDVAR_CENDVAR_CWORD_CENDVAR 11 +#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 +#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 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE, -#ifdef CONFIG_ASH_ALIAS +#if ENABLE_ASH_ALIAS /* 1 PEOA */ CSPCL_CIGN_CIGN_CIGN, #endif /* 2 -128 0x80 */ CWORD_CWORD_CWORD_CWORD, @@ -1140,939 +3011,85 @@ static const char syntax_index_table[258] = { /* 257 127 */ CWORD_CWORD_CWORD_CWORD, }; -#endif /* USE_SIT_FUNCTION */ - -/* $NetBSD: alias.c,v 1.11 2002/11/24 22:35:38 christos Exp $ */ - - -#define ATABSIZE 39 - -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 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 evalstring(char *, int); -union node; /* BLETCH for ansi C */ -static void evaltree(union node *, int); -static void evalbackcmd(union node *, struct backcmd *); - -/* 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 -#define SKIPCONT 2 -#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 CMDFUNCTION 1 /* command is a shell function */ -#define CMDBUILTIN 2 /* command is a shell builtin */ - -struct builtincmd { - const char *name; - int (*builtin)(int, char **); - /* unsigned flags; */ -}; - -#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 */ - -#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) - -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 }, -}; - -#define NUMBUILTINS (sizeof (builtincmd) / sizeof (struct builtincmd) ) - - - -struct cmdentry { - int cmdtype; - union param { - int index; - const struct builtincmd *cmd; - struct funcnode *func; - } u; -}; - - -/* 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 - -/* $NetBSD: init.h,v 1.9 2002/11/24 22:35:40 christos Exp $ */ - -static void reset(void); - -/* $NetBSD: var.h,v 1.21 2003/01/22 20:36:04 dsl Exp $ */ - -/* - * 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 */ - - -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 struct localvar *localvars; - -/* - * Shell variables. - */ - -#ifdef CONFIG_ASH_GETOPTS -static void getoptsreset(const char *); -#endif - -#ifdef CONFIG_LOCALE_SUPPORT -#include <locale.h> -static void change_lc_all(const char *value); -static void change_lc_ctype(const char *value); -#endif - -#define VTABSIZE 39 - -static const char defpathvar[] = - "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"; -#ifdef IFS_BROKEN -static const char defifsvar[] = "IFS= \t\n"; -#define defifs (defifsvar + 4) -#else -static const char defifs[] = " \t\n"; -#endif - - -static struct var varinit[] = { -#ifdef IFS_BROKEN - { 0, VSTRFIXED|VTEXTFIXED, defifsvar, 0 }, -#else - { 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 - {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL=", change_lc_all}, - {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE=", change_lc_ctype}, -#endif -#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY - {0, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE=", NULL}, -#endif -}; - -#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] +#define SIT(c, syntax) (S_I_T[(int)syntax_index_table[(int)(c) + SYNBASE]][syntax]) -#define defpath (defpathvar + 5) +#endif /* USE_SIT_FUNCTION */ -/* - * The following macros access the values of the above variables. - * They have to skip over the name. They return the null string - * for unset variables. - */ -#define ifsval() (vifs.text + 4) -#define ifsset() ((vifs.flags & VUNSET) == 0) -#define mailval() (vmail.text + 5) -#define mpathval() (vmpath.text + 9) -#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 setvar(const char *, const char *, int); -static void setvareq(char *, int); -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 *); -#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 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 */ -}; - -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 */ -}; +/* ============ Alias handling */ -/* - * The parsefile structure pointed to by the global variable parsefile - * contains information about the current file being read. - */ +#if ENABLE_ASH_ALIAS +#define ALIASINUSE 1 +#define ALIASDEAD 2 -struct redirtab { - struct redirtab *next; - int renamed[10]; - int nullredirs; +struct alias { + struct alias *next; + char *name; + char *val; + int flag; }; -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); +static struct alias **atab; // [ATABSIZE]; +#define INIT_G_alias() do { \ + atab = xzalloc(ATABSIZE * sizeof(atab[0])); \ +} while (0) -#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); -} +static struct alias ** +__lookupalias(const char *name) { + unsigned int hashval; + struct alias **app; + const char *p; + unsigned int ch; -/* - * Initialization code. - */ + p = name; -/* - * This routine initializes the builtin variables. - */ + ch = (unsigned char)*p; + hashval = ch << 4; + while (ch) { + hashval += ch; + ch = (unsigned char)*++p; + } + app = &atab[hashval % ATABSIZE]; -static inline void -initvar(void) -{ - struct var *vp; - struct var *end; - struct var **vpp; + for (; *app; app = &(*app)->next) { + if (strcmp(name, (*app)->name) == 0) { + break; + } + } - /* - * 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); + return app; } -static inline void -init(void) +static struct alias * +lookupalias(const char *name, int check) { + struct alias *ap = *__lookupalias(name); - /* 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; + if (check && ap && (ap->flag & ALIASINUSE)) + return NULL; + return ap; } -#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) +static struct alias * +freealias(struct alias *ap) { - /* 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; - } + struct alias *next; - /* from redir.c: */ - { - clearredir(0); - } + if (ap->flag & ALIASINUSE) { + ap->flag |= ALIASDEAD; + return ap; + } + next = ap->next; + free(ap->name); + free(ap->val); + free(ap); + return next; } -#ifdef CONFIG_ASH_ALIAS -static struct alias *atab[ATABSIZE]; - -static void setalias(const char *, const char *); -static struct alias *freealias(struct alias *); -static struct alias **__lookupalias(const char *); - static void setalias(const char *name, const char *val) { @@ -2080,23 +3097,23 @@ setalias(const char *name, const char *val) app = __lookupalias(name); ap = *app; - INTOFF; + INT_OFF; if (ap) { if (!(ap->flag & ALIASINUSE)) { - ckfree(ap->val); + free(ap->val); } - ap->val = savestr(val); + ap->val = ckstrdup(val); ap->flag &= ~ALIASDEAD; } else { /* not found */ - ap = ckmalloc(sizeof (struct alias)); - ap->name = savestr(name); - ap->val = savestr(val); - ap->flag = 0; - ap->next = 0; + ap = ckzalloc(sizeof(struct alias)); + ap->name = ckstrdup(name); + ap->val = ckstrdup(val); + /*ap->flag = 0; - ckzalloc did it */ + /*ap->next = NULL;*/ *app = ap; } - INTON; + INT_ON; } static int @@ -2107,13 +3124,13 @@ unalias(const char *name) app = __lookupalias(name); if (*app) { - INTOFF; + INT_OFF; *app = freealias(*app); - INTON; - return (0); + INT_ON; + return 0; } - return (1); + return 1; } static void @@ -2122,7 +3139,7 @@ rmaliases(void) struct alias *ap, **app; int i; - INTOFF; + INT_OFF; for (i = 0; i < ATABSIZE; i++) { app = &atab[i]; for (ap = *app; ap; ap = *app) { @@ -2132,41 +3149,40 @@ rmaliases(void) } } } - INTON; + INT_ON; } -static struct alias * -lookupalias(const char *name, int check) +static void +printalias(const struct alias *ap) { - struct alias *ap = *__lookupalias(name); - - if (check && ap && (ap->flag & ALIASINUSE)) - return (NULL); - return (ap); + out1fmt("%s=%s\n", ap->name, single_quote(ap->val)); } /* * TODO - sort output */ static int -aliascmd(int argc, char **argv) +aliascmd(int argc UNUSED_PARAM, char **argv) { char *n, *v; int ret = 0; struct alias *ap; - if (argc == 1) { + if (!argv[1]) { int i; - for (i = 0; i < ATABSIZE; i++) + for (i = 0; i < ATABSIZE; i++) { for (ap = atab[i]; ap; ap = ap->next) { printalias(ap); } - return (0); + } + return 0; } while ((n = *++argv) != NULL) { - if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */ - if ((ap = *__lookupalias(n)) == NULL) { + v = strchr(n+1, '='); + if (v == NULL) { /* n+1: funny ksh stuff */ + ap = *__lookupalias(n); + if (ap == NULL) { fprintf(stderr, "%s: %s not found\n", "alias", n); ret = 1; } else @@ -2177,18 +3193,18 @@ aliascmd(int argc, char **argv) } } - return (ret); + return ret; } static int -unaliascmd(int argc, char **argv) +unaliascmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { int i; while ((i = nextopt("a")) != '\0') { if (i == 'a') { rmaliases(); - return (0); + return 0; } } for (i = 0; *argptr; argptr++) { @@ -2198,2444 +3214,2563 @@ unaliascmd(int argc, char **argv) } } - return (i); + return i; } -static struct alias * -freealias(struct alias *ap) { - struct alias *next; - - if (ap->flag & ALIASINUSE) { - ap->flag |= ALIASDEAD; - return ap; - } +#endif /* ASH_ALIAS */ - next = ap->next; - 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)); -} +/* ============ jobs.c */ -static struct alias ** -__lookupalias(const char *name) { - unsigned int hashval; - struct alias **app; - const char *p; - unsigned int ch; +/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */ +#define FORK_FG 0 +#define FORK_BG 1 +#define FORK_NOJOB 2 - p = name; +/* 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 */ - ch = (unsigned char)*p; - hashval = ch << 4; - while (ch) { - hashval += ch; - ch = (unsigned char)*++p; - } - app = &atab[hashval % ATABSIZE]; +/* + * 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. + */ - for (; *app; app = &(*app)->next) { - if (equal(name, (*app)->name)) { - break; - } - } +struct procstat { + pid_t pid; /* process id */ + int status; /* last process status from wait() */ + char *cmd; /* text of command being run */ +}; - return app; -} -#endif /* CONFIG_ASH_ALIAS */ +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 struct job *makejob(/*union node *,*/ int); +#if !JOBS +#define forkshell(job, node, mode) forkshell(job, mode) +#endif +static int forkshell(struct job *, union node *, int); +static int waitforjob(struct job *); -/* $NetBSD: cd.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */ +#if !JOBS +enum { doing_jobctl = 0 }; +#define setjobctl(on) do {} while (0) +#else +static smallint doing_jobctl; //references:8 +static void setjobctl(int); +#endif /* - * The cd and pwd commands. + * Ignore a signal. */ - -#define CD_PHYSICAL 1 -#define CD_PRINT 2 - -static int docd(const char *, int); -static int cdopt(void); - -static char *curdir = nullstr; /* current working directory */ -static char *physdir = nullstr; /* physical working directory */ - -static int -cdopt(void) +static void +ignoresig(int signo) { - int flags = 0; - int i, j; - - j = 'L'; - while ((i = nextopt("LP"))) { - if (i != j) { - flags ^= CD_PHYSICAL; - j = i; - } + /* Avoid unnecessary system calls. Is it already SIG_IGNed? */ + if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) { + /* No, need to do it */ + signal(signo, SIG_IGN); } - - return flags; + sigmode[signo - 1] = S_HARD_IGN; } -static int -cdcmd(int argc, char **argv) +/* + * Signal handler. Only one usage site - in setsignal() + */ +static void +onsig(int signo) { - const char *dest; - const char *path; - const char *p; - char c; - struct stat statb; - int flags; + gotsig[signo - 1] = 1; - flags = cdopt(); - dest = *argptr; - if (!dest) - dest = bltinlookup(homestr); - else if (dest[0] == '-' && dest[1] == '\0') { - dest = bltinlookup("OLDPWD"); - 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; + if (/* exsig || */ (signo == SIGINT && !trap[SIGINT])) { + if (!suppressint) { + pendingsig = 0; + raise_interrupt(); /* does not return */ } + intpending = 1; + } else { + pendingsig = signo; } - 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 (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. + * Set the signal handler for the specified signal. The routine figures + * out what it should be set to. */ - -static inline const char * -updatepwd(const char *dir) +static void +setsignal(int signo) { - char *new; - char *p; - char *cdcomppath; - const char *lim; + char *t; + char cur_act, new_act; + struct sigaction act; - cdcomppath = sstrdup(dir); - STARTSTACKSTR(new); - if (*dir != '/') { - if (curdir == nullstr) - return 0; - new = stputs(curdir, new); + t = trap[signo]; + new_act = S_DFL; + if (t != NULL) { /* trap for this sig is set */ + new_act = S_CATCH; + if (t[0] == '\0') /* trap is "": ignore this sig */ + new_act = S_IGN; } - new = makestrspace(strlen(dir) + 2, new); - lim = stackblock() + 1; - if (*dir != '/') { - if (new[-1] != '/') - USTPUTC('/', new); - if (new > lim && *lim == '/') - lim++; - } else { - 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') + + if (rootshell && new_act == S_DFL) { + switch (signo) { + case SIGINT: + if (iflag || minusc || sflag == 0) + new_act = S_CATCH; + break; + case SIGQUIT: +#if DEBUG + if (debug) break; - /* fall through */ - default: - new = stputs(p, new); - USTPUTC('/', new); +#endif + /* man bash: + * "In all cases, bash ignores SIGQUIT. Non-builtin + * commands run by bash have signal handlers + * set to the values inherited by the shell + * from its parent". */ + new_act = S_IGN; + break; + case SIGTERM: + if (iflag) + new_act = S_IGN; + break; +#if JOBS + case SIGTSTP: + case SIGTTOU: + if (mflag) + new_act = S_IGN; + break; +#endif } - p = strtok(0, "/"); } - if (new > lim) - STUNPUTC(new); - *new = 0; - return stackblock(); -} - -/* - * 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(const char *dest, int flags) -{ - const char *dir = 0; - int err; +//TODO: if !rootshell, we reset SIGQUIT to DFL, +//whereas we have to restore it to what shell got on entry +//from the parent. See comment above - TRACE(("docd(\"%s\", %d) called\n", dest, flags)); + t = &sigmode[signo - 1]; + cur_act = *t; + if (cur_act == 0) { + /* current setting is not yet known */ + if (sigaction(signo, NULL, &act)) { + /* pretend it worked; maybe we should give a warning, + * but other shells don't. We don't alter sigmode, + * so we retry every time. + * btw, in Linux it never fails. --vda */ + return; + } + if (act.sa_handler == SIG_IGN) { + cur_act = S_HARD_IGN; + if (mflag + && (signo == SIGTSTP || signo == SIGTTIN || signo == SIGTTOU) + ) { + cur_act = S_IGN; /* don't hard ignore these */ + } + } + } + if (cur_act == S_HARD_IGN || cur_act == new_act) + return; - INTOFF; - if (!(flags & CD_PHYSICAL)) { - dir = updatepwd(dest); - if (dir) - dest = dir; + act.sa_handler = SIG_DFL; + switch (new_act) { + case S_CATCH: + act.sa_handler = onsig; + act.sa_flags = 0; /* matters only if !DFL and !IGN */ + sigfillset(&act.sa_mask); /* ditto */ + break; + case S_IGN: + act.sa_handler = SIG_IGN; + break; } - err = chdir(dest); - if (err) - goto out; - setpwd(dir, 1); - hashcd(); -out: - INTON; - return err; -} + sigaction_set(signo, &act); -/* - * Find out what the current directory is. If we already know the current - * directory, this routine returns immediately. - */ -static inline char * -getpwd(void) -{ - char *dir = getcwd(0, 0); - return dir ? dir : nullstr; + *t = new_act; } -static int -pwdcmd(int argc, char **argv) -{ - int flags; - const char *dir = curdir; +/* mode flags for set_curjob */ +#define CUR_DELETE 2 +#define CUR_RUNNING 1 +#define CUR_STOPPED 0 - flags = cdopt(); - if (flags) { - if (physdir == nullstr) - setpwd(dir, 0); - dir = physdir; - } - out1fmt(snlfmt, dir); - return 0; -} +/* mode flags for dowait */ +#define DOWAIT_NONBLOCK WNOHANG +#define DOWAIT_BLOCK 0 + +#if JOBS +/* pgrp of shell on invocation */ +static int initialpgrp; //references:2 +static int ttyfd = -1; //5 +#endif +/* array of jobs */ +static struct job *jobtab; //5 +/* size of array */ +static unsigned njobs; //4 +/* current job */ +static struct job *curjob; //lots +/* number of presumed living untracked jobs */ +static int jobless; //4 static void -setpwd(const char *val, int setold) +set_curjob(struct job *jp, unsigned mode) { - char *oldcur, *dir; + struct job *jp1; + struct job **jpp, **curp; - oldcur = dir = curdir; + /* first remove from list */ + jpp = curp = &curjob; + do { + jp1 = *jpp; + if (jp1 == jp) + break; + jpp = &jp1->prev_job; + } while (1); + *jpp = jp1->prev_job; - if (setold) { - setvar("OLDPWD", oldcur, VEXPORT); - } - INTOFF; - 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); + /* Then re-insert in correct position */ + jpp = curp; + switch (mode) { + default: +#if 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; +#if JOBS + if (!jp1 || jp1->state != JOBSTOPPED) +#endif + break; + jpp = &jp1->prev_job; + } while (1); + /* FALLTHROUGH */ +#if JOBS + case CUR_STOPPED: +#endif + /* newly stopped job - becomes curjob */ + jp->prev_job = *jpp; + *jpp = jp; + break; } - curdir = dir; - INTON; - setvar("PWD", dir, VEXPORT); } -/* $NetBSD: error.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */ +#if JOBS || DEBUG +static int +jobno(const struct job *jp) +{ + return jp - jobtab + 1; +} +#endif /* - * Errors and exceptions. + * Convert a job name to a job structure. */ +#if !JOBS +#define getjob(name, getctl) getjob(name) +#endif +static struct job * +getjob(const char *name, int getctl) +{ + struct job *jp; + struct job *found; + const char *err_msg = "No such job: %s"; + unsigned num; + int c; + const char *p; + char *(*match)(const char *, const char *); -/* - * Code to handle exceptions in C. - */ + jp = curjob; + p = name; + if (!p) + goto currentjob; + if (*p != '%') + goto err; + c = *++p; + if (!c) + goto currentjob; -static void exverror(int, const char *, va_list) - __attribute__((__noreturn__)); + if (!p[1]) { + if (c == '+' || c == '%') { + currentjob: + err_msg = "No current job"; + goto check; + } + if (c == '-') { + if (jp) + jp = jp->prev_job; + err_msg = "No previous job"; + check: + if (!jp) + goto err; + goto gotit; + } + } -/* - * Called to raise an exception. Since C doesn't include exceptions, we - * just do a longjmp to the exception handler. The type of exception is - * stored in the global variable "exception". - */ + if (is_number(p)) { +// TODO: number() instead? It does error checking... + num = atoi(p); + if (num < njobs) { + jp = jobtab + num - 1; + if (jp->used) + goto gotit; + goto err; + } + } -static void -exraise(int e) -{ -#ifdef DEBUG - if (handler == NULL) - abort(); -#endif - INTOFF; + match = prefix; + if (*p == '?') { + match = strstr; + p++; + } - exception = e; - longjmp(handler->loc, 1); -} + 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: + ash_msg_and_raise_error(err_msg, name); +} /* - * 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 test for iflag is just - * defensive programming.) + * Mark a job structure as unused. */ - static void -onint(void) { +freejob(struct job *jp) +{ + struct procstat *ps; int i; - intpending = 0; - sigsetmask(0); - i = EXSIG; - if (gotsig[SIGINT - 1] && !trap[SIGINT]) { - if (!(rootshell && iflag)) { - signal(SIGINT, SIG_DFL); - raise(SIGINT); - } - i = EXINT; + INT_OFF; + for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) { + if (ps->cmd != nullstr) + free(ps->cmd); } - exraise(i); - /* NOTREACHED */ + if (jp->ps != &jp->ps0) + free(jp->ps); + jp->used = 0; + set_curjob(jp, CUR_DELETE); + INT_ON; } +#if JOBS static void -exvwarning(const char *msg, va_list ap) +xtcsetpgrp(int fd, pid_t pgrp) { - FILE *errs; - const char *name; - const char *fmt; - - 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); + if (tcsetpgrp(fd, pgrp)) + ash_msg_and_raise_error("can't set tty process group (%m)"); } /* - * 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. + * 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 -exverror(int cond, const char *msg, va_list ap) +setjobctl(int on) { -#ifdef DEBUG - 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 - exvwarning(msg, ap); + int fd; + int pgrp; - flushall(); - exraise(cond); - /* NOTREACHED */ -} + if (on == doing_jobctl || rootshell == 0) + return; + if (on) { + int ofd; + ofd = fd = open(_PATH_TTY, O_RDWR); + if (fd < 0) { + /* BTW, bash will try to open(ttyname(0)) if open("/dev/tty") fails. + * That sometimes helps to acquire controlling tty. + * Obviously, a workaround for bugs when someone + * failed to provide a controlling tty to bash! :) */ + fd = 2; + while (!isatty(fd)) + if (--fd < 0) + goto out; + } + fd = fcntl(fd, F_DUPFD, 10); + if (ofd >= 0) + close(ofd); + if (fd < 0) + goto out; + /* fd is a tty at this point */ + close_on_exec_on(fd); + do { /* while we are in the background */ + pgrp = tcgetpgrp(fd); + if (pgrp < 0) { + out: + ash_msg("can't access tty; job control turned off"); + mflag = on = 0; + goto close; + } + if (pgrp == getpgrp()) + break; + killpg(0, SIGTTIN); + } while (1); + initialpgrp = pgrp; + setsignal(SIGTSTP); + setsignal(SIGTTOU); + setsignal(SIGTTIN); + pgrp = rootpid; + setpgid(0, pgrp); + xtcsetpgrp(fd, pgrp); + } else { + /* turning job control off */ + fd = ttyfd; + pgrp = initialpgrp; + /* was xtcsetpgrp, but this can make exiting ash + * loop forever if pty is already deleted */ + tcsetpgrp(fd, pgrp); + setpgid(0, pgrp); + setsignal(SIGTSTP); + setsignal(SIGTTOU); + setsignal(SIGTTIN); + close: + if (fd >= 0) + close(fd); + fd = -1; + } + ttyfd = fd; + doing_jobctl = on; +} -static void -error(const char *msg, ...) +static int +killcmd(int argc, char **argv) { - va_list ap; - - va_start(ap, msg); - exverror(EXERROR, msg, ap); - /* NOTREACHED */ - va_end(ap); + int i = 1; + if (argv[1] && strcmp(argv[1], "-l") != 0) { + do { + if (argv[i][0] == '%') { + struct job *jp = getjob(argv[i], 0); + unsigned pid = jp->ps[0].pid; + /* Enough space for ' -NNN<nul>' */ + argv[i] = alloca(sizeof(int)*3 + 3); + /* kill_main has matching code to expect + * leading space. Needed to not confuse + * negative pids with "kill -SIGNAL_NO" syntax */ + sprintf(argv[i], " -%u", pid); + } + } while (argv[++i]); + } + return kill_main(argc, argv); } - static void -exerror(int cond, const char *msg, ...) +showpipe(struct job *jp, FILE *out) { - va_list ap; + struct procstat *sp; + struct procstat *spend; - va_start(ap, msg); - exverror(cond, msg, ap); - /* NOTREACHED */ - va_end(ap); + spend = jp->ps + jp->nprocs; + for (sp = jp->ps + 1; sp < spend; sp++) + fprintf(out, " | %s", sp->cmd); + outcslow('\n', out); + flush_stdout_stderr(); } -/* - * error/warning routines for external builtins - */ -static void -sh_warnx(const char *fmt, ...) +static int +restartjob(struct job *jp, int mode) { - va_list ap; + struct procstat *ps; + int i; + int status; + pid_t pgid; - va_start(ap, fmt); - exvwarning(fmt, ap); - va_end(ap); + INT_OFF; + 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; + } + ps++; + } while (--i); + out: + status = (mode == FORK_FG) ? waitforjob(jp) : 0; + INT_ON; + return status; } +static int +fg_bgcmd(int argc UNUSED_PARAM, char **argv) +{ + struct job *jp; + FILE *out; + int mode; + int retval; -/* - * Return a string describing an error. The returned string may be a - * pointer to a static buffer that will be overwritten on the next call. - * Action describes the operation that got the error. - */ + mode = (**argv == 'f') ? FORK_FG : FORK_BG; + nextopt(nullstr); + argv = argptr; + out = stdout; + do { + 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; +} +#endif -static const char * -errmsg(int e, const char *em) +static int +sprint_status(char *s, int status, int sigonly) { - if(e == ENOENT || e == ENOTDIR) { + int col; + int st; - return em; + col = 0; + if (!WIFEXITED(status)) { +#if JOBS + if (WIFSTOPPED(status)) + st = WSTOPSIG(status); + else +#endif + st = WTERMSIG(status); + if (sigonly) { + if (st == SIGINT || st == SIGPIPE) + goto out; +#if JOBS + if (WIFSTOPPED(status)) + goto out; +#endif + } + st &= 0x7f; + col = fmtstr(s, 32, strsignal(st)); + if (WCOREDUMP(status)) { + col += fmtstr(s + col, 16, " (core dumped)"); + } + } else if (!sigonly) { + st = WEXITSTATUS(status); + if (st) + col = fmtstr(s, 16, "Done(%d)", st); + else + col = fmtstr(s, 16, "Done"); } - return strerror(e); + out: + return col; } +static int +dowait(int wait_flags, struct job *job) +{ + int pid; + int status; + struct job *jp; + struct job *thisjob; + int state; -/* $NetBSD: eval.c,v 1.71 2003/01/23 03:33:16 rafal Exp $ */ - -/* - * 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 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 int eprintlist(struct strlist *, int); -static int bltincmd(int, char **); + TRACE(("dowait(0x%x) called\n", wait_flags)); + /* Do a wait system call. If job control is compiled in, we accept + * stopped processes. wait_flags may have WNOHANG, preventing blocking. + * NB: _not_ safe_waitpid, we need to detect EINTR */ + pid = waitpid(-1, &status, + (doing_jobctl ? (wait_flags | WUNTRACED) : wait_flags)); + TRACE(("wait returns pid=%d, status=0x%x, errno=%d(%s)\n", + pid, status, errno, strerror(errno))); + if (pid <= 0) + return pid; -static const struct builtincmd bltin = { - "\0\0", bltincmd -}; + INT_OFF; + thisjob = NULL; + 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; +#if JOBS + if (state == JOBRUNNING) + continue; + if (WIFSTOPPED(sp->status)) { + jp->stopstatus = sp->status; + state = JOBSTOPPED; + } +#endif + } while (++sp < spend); + if (thisjob) + goto gotjob; + } +#if JOBS + if (!WIFSTOPPED(status)) +#endif + jobless--; + goto out; + gotjob: + if (state != JOBRUNNING) { + thisjob->changed = 1; -/* - * Called to reset things after an exception. - */ + if (thisjob->state != state) { + TRACE(("Job %d: changing state from %d to %d\n", + jobno(thisjob), thisjob->state, state)); + thisjob->state = state; +#if JOBS + if (state == JOBSTOPPED) { + set_curjob(thisjob, CUR_STOPPED); + } +#endif + } + } -/* - * The eval commmand. - */ + out: + INT_ON; -static int -evalcmd(int argc, char **argv) -{ - char *p; - char *concat; - char **ap; + if (thisjob && thisjob == job) { + char s[48 + 1]; + int len; - if (argc > 1) { - p = argv[1]; - if (argc > 2) { - STARTSTACKSTR(concat); - ap = argv + 2; - for (;;) { - concat = stputs(p, concat); - if ((p = *ap++) == NULL) - break; - STPUTC(' ', concat); - } - STPUTC('\0', concat); - p = grabstackstr(concat); + len = sprint_status(s, status, 1); + if (len) { + s[len] = '\n'; + s[len + 1] = '\0'; + out2str(s); } - evalstring(p, EV_TESTED); } - return exitstatus; + return pid; } +static int +blocking_wait_with_raise_on_sig(struct job *job) +{ + pid_t pid = dowait(DOWAIT_BLOCK, job); + if (pid <= 0 && pendingsig) + raise_exception(EXSIG); + return pid; +} -/* - * Execute a command or commands contained in a string. - */ - +#if JOBS static void -evalstring(char *s, int flag) +showjob(FILE *out, struct job *jp, int mode) { - union node *n; - struct stackmark smark; + struct procstat *ps; + struct procstat *psend; + int col; + int indent_col; + char s[80]; - setstackmark(&smark); - setinputstring(s); + ps = jp->ps; - while ((n = parsecmd(0)) != NEOF) { - evaltree(n, flag); - popstackmark(&smark); - if (evalskip) - break; + if (mode & SHOW_PGID) { + /* just output process (group) id of pipeline */ + fprintf(out, "%d\n", ps->pid); + return; } - popfile(); - popstackmark(&smark); -} + col = fmtstr(s, 16, "[%d] ", jobno(jp)); + indent_col = col; + if (jp == curjob) + s[col - 2] = '+'; + else if (curjob && jp == curjob->prev_job) + s[col - 2] = '-'; -/* - * Evaluate a parse tree. The value is left in the global variable - * exitstatus. - */ + if (mode & SHOW_PID) + col += fmtstr(s + col, 16, "%d ", ps->pid); -static void -evaltree(union node *n, int flags) -{ - int checkexit = 0; - void (*evalfn)(union node *, int); - unsigned isor; - int status; - if (n == NULL) { - TRACE(("evaltree(NULL) called\n")); - goto out; + psend = ps + jp->nprocs; + + if (jp->state == JOBRUNNING) { + strcpy(s + col, "Running"); + col += sizeof("Running") - 1; + } else { + int status = psend[-1].status; + if (jp->state == JOBSTOPPED) + status = jp->stopstatus; + col += sprint_status(s + col, status, 0); } - 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 + + goto start; + + do { + /* for each process */ + col = fmtstr(s, 48, " |\n%*c%d ", indent_col, ' ', ps->pid) - 3; + start: + fprintf(out, "%s%*c%s", + s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd ); - if (!exitstatus == isor) - break; - if (!evalskip) { - n = n->nbinary.ch2; -evaln: - evalfn = evaltree; -calleval: - evalfn(n, flags); + if (!(mode & SHOW_PID)) { + showpipe(jp, out); break; } - break; - case NIF: - evaltree(n->nif.test, EV_TESTED); - if (evalskip) + if (++ps == psend) { + outcslow('\n', out); 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); -} - + } while (1); -#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3) -static -#endif -void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__)); + jp->changed = 0; + if (jp->state == JOBDONE) { + TRACE(("showjob: freeing job %d\n", jobno(jp))); + freejob(jp); + } +} +/* + * Print a list of jobs. If "change" is nonzero, only print jobs whose + * statuses have changed since the last call to showjobs. + */ static void -evalloop(union node *n, int flags) +showjobs(FILE *out, int mode) { - int status; + struct job *jp; - loopnest++; - status = 0; - flags &= EV_TESTED; - for (;;) { - int i; + TRACE(("showjobs(%x) called\n", mode)); - evaltree(n->nbinary.ch1, EV_TESTED); - if (evalskip) { -skipping: if (evalskip == SKIPCONT && --skipcount <= 0) { - evalskip = 0; - continue; - } - if (evalskip == SKIPBREAK && --skipcount <= 0) - evalskip = 0; - break; + /* Handle all finished jobs */ + while (dowait(DOWAIT_NONBLOCK, NULL) > 0) + continue; + + for (jp = curjob; jp; jp = jp->prev_job) { + if (!(mode & SHOW_CHANGED) || jp->changed) { + showjob(out, jp, mode); } - i = exitstatus; - if (n->type != NWHILE) - i = !i; - if (i != 0) - break; - evaltree(n->nbinary.ch2, flags); - status = exitstatus; - if (evalskip) - goto skipping; } - loopnest--; - exitstatus = status; } - - -static void -evalfor(union node *n, int flags) +static int +jobscmd(int argc UNUSED_PARAM, char **argv) { - struct arglist arglist; - union node *argp; - struct strlist *sp; - struct stackmark smark; + int mode, m; - setstackmark(&smark); - arglist.lastp = &arglist.list; - for (argp = n->nfor.args ; argp ; argp = argp->narg.next) { - expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD); - /* XXX */ - if (evalskip) - goto out; + mode = 0; + while ((m = nextopt("lp"))) { + if (m == 'l') + mode = SHOW_PID; + else + mode = SHOW_PGID; } - *arglist.lastp = NULL; - exitstatus = 0; - loopnest++; - flags &= EV_TESTED; - for (sp = arglist.list ; sp ; sp = sp->next) { - setvar(n->nfor.var, sp->text, 0); - evaltree(n->nfor.body, flags); - if (evalskip) { - if (evalskip == SKIPCONT && --skipcount <= 0) { - evalskip = 0; - continue; - } - if (evalskip == SKIPBREAK && --skipcount <= 0) - evalskip = 0; - break; + argv = argptr; + if (*argv) { + do + showjob(stdout, getjob(*argv,0), mode); + while (*++argv); + } else + showjobs(stdout, mode); + + return 0; +} +#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; } - loopnest--; -out: - popstackmark(&smark); + TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n", + jobno(job), job->nprocs, status, retval)); + return retval; } +static int +waitcmd(int argc UNUSED_PARAM, char **argv) +{ + struct job *job; + int retval; + struct job *jp; +// exsig++; +// xbarrier(); + if (pendingsig) + raise_exception(EXSIG); -static void -evalcase(union node *n, int flags) -{ - union node *cp; - union node *patp; - struct arglist arglist; - struct stackmark smark; + nextopt(nullstr); + retval = 0; - setstackmark(&smark); - arglist.lastp = &arglist.list; - expandarg(n->ncase.expr, &arglist, EXP_TILDE); - 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); - } - goto out; + argv = argptr; + if (!*argv) { + /* wait for all jobs */ + for (;;) { + jp = curjob; + while (1) { + if (!jp) /* no running procs */ + goto ret; + if (jp->state == JOBRUNNING) + break; + jp->waited = 1; + jp = jp->prev_job; } + /* man bash: + * "When bash is waiting for an asynchronous command via + * the wait builtin, the reception of a signal for which a trap + * has been set will cause the wait builtin to return immediately + * with an exit status greater than 128, immediately after which + * the trap is executed." + * Do we do it that way? */ + blocking_wait_with_raise_on_sig(NULL); } } -out: - popstackmark(&smark); -} - + retval = 127; + do { + if (**argv != '%') { + pid_t pid = number(*argv); + job = curjob; + while (1) { + if (!job) + goto repeat; + if (job->ps[job->nprocs - 1].pid == pid) + break; + job = job->prev_job; + } + } else + job = getjob(*argv, 0); + /* loop until process terminated or stopped */ + while (job->state == JOBRUNNING) + blocking_wait_with_raise_on_sig(NULL); + job->waited = 1; + retval = getstatus(job); + repeat: ; + } while (*++argv); -/* - * Kick off a subshell to evaluate a tree. - */ + ret: + return retval; +} -static void -evalsubshell(union node *n, int flags) +static struct job * +growjobtab(void) { - struct job *jp; - int backgnd = (n->type == NBACKGND); - int status; + size_t len; + ptrdiff_t offset; + struct job *jp, *jq; - 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; -} + 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 (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; +} /* - * Compute the names of the files in a redirection list. + * Return a new job structure. + * Called with interrupts off. */ - -static void -expredir(union node *n) +static struct job * +makejob(/*union node *node,*/ int nprocs) { - union node *redir; + int i; + struct job *jp; - 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); - } + for (i = njobs, jp = jobtab; ; jp++) { + if (--i < 0) { + jp = growjobtab(); break; } + if (jp->used == 0) + break; + if (jp->state != JOBDONE || !jp->waited) + continue; +#if JOBS + if (doing_jobctl) + continue; +#endif + freejob(jp); + break; + } + memset(jp, 0, sizeof(*jp)); +#if JOBS + /* jp->jobctl is a bitfield. + * "jp->jobctl |= jobctl" likely to give awful code */ + if (doing_jobctl) + jp->jobctl = 1; +#endif + jp->prev_job = curjob; + curjob = jp; + jp->used = 1; + jp->ps = &jp->ps0; + if (nprocs > 1) { + jp->ps = ckmalloc(nprocs * sizeof(struct procstat)); } + TRACE(("makejob(%d) returns %%%d\n", nprocs, + jobno(jp))); + return jp; } - - +#if JOBS /* - * Evaluate a pipeline. All the processes in the pipeline are children - * of the process creating the pipeline. (This differs from some versions - * of the shell, which make the last process in a pipeline the parent - * of all the rest.) + * Return a string identifying a command (to be printed by the + * jobs command). */ +static char *cmdnextc; static void -evalpipe(union node *n, int flags) +cmdputs(const char *s) { - struct job *jp; - struct nodelist *lp; - int pipelen; - int prevfd; - int pip[2]; + static const char vstype[VSTYPE + 1][3] = { + "", "}", "-", "+", "?", "=", + "%", "%%", "#", "##" + USE_ASH_BASH_COMPAT(, ":", "/", "//") + }; - TRACE(("evalpipe(0x%lx) called\n", (long)n)); - pipelen = 0; - 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) { - prehash(lp->n); - pip[1] = -1; - if (lp->next) { - if (pipe(pip) < 0) { - close(prevfd); - error("Pipe call failed"); - } + const char *p, *str; + char c, cc[2] = " "; + char *nextc; + int subtype = 0; + int quoted = 0; + + nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc); + p = s; + while ((c = *p++) != 0) { + str = NULL; + switch (c) { + case CTLESC: + c = *p++; + break; + case CTLVAR: + subtype = *p++; + if ((subtype & VSTYPE) == VSLENGTH) + str = "${#"; + else + str = "${"; + if (!(subtype & VSQUOTE) == !(quoted & 1)) + goto dostr; + quoted ^= 1; + c = '"'; + break; + case CTLENDVAR: + str = "\"}" + !(quoted & 1); + quoted >>= 1; + subtype = 0; + goto dostr; + case CTLBACKQ: + str = "$(...)"; + goto dostr; + case CTLBACKQ+CTLQUOTE: + str = "\"$(...)\""; + goto dostr; +#if ENABLE_SH_MATH_SUPPORT + case CTLARI: + str = "$(("; + goto dostr; + case CTLENDARI: + str = "))"; + goto dostr; +#endif + case CTLQUOTEMARK: + quoted ^= 1; + c = '"'; + break; + case '=': + if (subtype == 0) + break; + if ((subtype & VSTYPE) != VSNORMAL) + quoted <<= 1; + str = vstype[subtype & VSTYPE]; + if (subtype & VSNUL) + c = ':'; + else + goto checkstr; + break; + case '\'': + case '\\': + case '"': + case '$': + /* These can only happen inside quotes */ + cc[0] = c; + str = cc; + c = '\\'; + break; + default: + break; } - if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) { - INTON; - if (pip[1] >= 0) { - close(pip[0]); - } - if (prevfd > 0) { - dup2(prevfd, 0); - close(prevfd); - } - if (pip[1] > 1) { - dup2(pip[1], 1); - close(pip[1]); - } - evaltreenr(lp->n, flags); - /* never returns */ + USTPUTC(c, nextc); + checkstr: + if (!str) + continue; + dostr: + while ((c = *str++)) { + USTPUTC(c, nextc); } - if (prevfd >= 0) - close(prevfd); - prevfd = pip[0]; - close(pip[1]); } - if (n->npipe.backgnd == 0) { - exitstatus = waitforjob(jp); - TRACE(("evalpipe: job done exit status %d\n", exitstatus)); + if (quoted & 1) { + USTPUTC('"', nextc); } - INTON; + *nextc = 0; + cmdnextc = nextc; } - - -/* - * 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. - */ +/* cmdtxt() and cmdlist() call each other */ +static void cmdtxt(union node *n); static void -evalbackcmd(union node *n, struct backcmd *result) +cmdlist(union node *np, int sep) { - int saveherefd; - - result->fd = -1; - result->buf = NULL; - result->nleft = 0; - result->jp = NULL; - if (n == NULL) { - goto out; - } - - 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; + for (; np; np = np->narg.next) { + if (!sep) + cmdputs(" "); + cmdtxt(np); + if (sep && np->narg.next) + cmdputs(" "); } - 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) +static void +cmdtxt(union node *n) { - char *cp, c; + union node *np; + struct nodelist *lp; + const char *p; - for (;;) { - cp = *++argv; - if (!cp) - return 0; - if (*cp++ != '-') - break; - if (!(c = *cp++)) - break; - if (c == '-' && !*cp) { - argv++; + if (!n) + return; + switch (n->type) { + default: +#if DEBUG + abort(); +#endif + case NPIPE: + lp = n->npipe.cmdlist; + for (;;) { + cmdtxt(lp->n); + lp = lp->next; + if (!lp) + break; + 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: + 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 "); + 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: + p = "while "; + goto until; + case NUNTIL: + p = "until "; + until: + cmdputs(p); + cmdtxt(n->nbinary.ch1); + n = n->nbinary.ch2; + p = "; done"; + dodo: + cmdputs("; do "); + dotail: + cmdtxt(n); + goto dotail2; + case NFOR: + cmdputs("for "); + cmdputs(n->nfor.var); + cmdputs(" in "); + cmdlist(n->nfor.args, 1); + n = n->nfor.body; + p = "; done"; + goto dodo; + case NDEFUN: + cmdputs(n->narg.text); + p = "() { ... }"; + goto dotail2; + case NCMD: + cmdlist(n->ncmd.args, 1); + cmdlist(n->ncmd.redirect, 0); + break; + case NARG: + 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 = ">"; + goto redir; + case NCLOBBER: + p = ">|"; + goto redir; + case NAPPEND: + p = ">>"; + goto redir; +#if ENABLE_ASH_BASH_COMPAT + case NTO2: +#endif + case NTOFD: + p = ">&"; + goto redir; + case NFROM: + p = "<"; + goto redir; + case NFROMFD: + p = "<&"; + goto redir; + case NFROMTO: + p = "<>"; + redir: + cmdputs(utoa(n->nfile.fd)); + cmdputs(p); + if (n->type == NTOFD || n->type == NFROMFD) { + cmdputs(utoa(n->ndup.dupfd)); break; } - do { - switch (c) { - case 'p': - *path = defpath; - break; - default: - /* run 'typecmd' for other options */ - return 0; - } - } while ((c = *cp++)); + n = n->nfile.fname; + goto donode; } - return argv; } -#endif +static char * +commandtext(union node *n) +{ + char *name; + STARTSTACKSTR(cmdnextc); + cmdtxt(n); + name = stackblock(); + TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n", + name, cmdnextc, cmdnextc)); + return ckstrdup(name); +} +#endif /* JOBS */ /* - * Execute a simple command. + * 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: + * FORK_FG - Fork off a foreground process. + * FORK_BG - Fork off a background process. + * FORK_NOJOB - Like FORK_FG, but don't give the process its own + * process group even if job control is on. + * + * 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. + */ +/* + * Clear traps on a fork. */ - static void -evalcommand(union node *cmd, int flags) +clear_traps(void) { - struct stackmark smark; - union node *argp; - struct arglist arglist; - struct arglist varlist; - char **argv; - int argc; - struct strlist *sp; - struct cmdentry cmdentry; - struct job *jp; - char *lastarg; - const char *path; - int spclbltin; - int cmd_is_exec; - int status; - char **nargv; - - /* First expand the arguments. */ - TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags)); - setstackmark(&smark); - back_exitstatus = 0; - - cmdentry.cmdtype = CMDBUILTIN; - cmdentry.u.cmd = &bltin; - varlist.lastp = &varlist.list; - *varlist.lastp = NULL; - arglist.lastp = &arglist.list; - *arglist.lastp = NULL; - - argc = 0; - for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) { - struct strlist **spp; - - 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)); - *nargv++ = sp->text; - } - *nargv = NULL; - - lastarg = NULL; - if (iflag && funcnest == 0 && argc > 0) - 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); + char **tp; - /* - * Modify the command lookup path, if a PATH= assignment - * is present - */ - p = (*spp)->text; - if (varequal(p, path)) - path = p; + for (tp = trap; tp < &trap[NSIG]; tp++) { + if (*tp && **tp) { /* trap not NULL or "" (SIG_IGN) */ + INT_OFF; + free(*tp); + *tp = NULL; + if (tp != &trap[0]) + setsignal(tp - trap); + INT_ON; + } } +} - /* Print the command if xflag is set. */ - if (xflag) { - int sep; - - out2str(ps4val()); - sep = 0; - sep = eprintlist(varlist.list, sep); - eprintlist(arglist.list, sep); - out2c('\n'); - flushall(); - } +/* Lives far away from here, needed for forkchild */ +static void closescript(void); - cmd_is_exec = 0; - spclbltin = -1; +/* Called after fork(), in child */ +static void +forkchild(struct job *jp, /*union node *n,*/ int mode) +{ + int oldlvl; - /* Now locate the command. */ - if (argc) { - const char *oldpath; - int cmd_flag = DO_ERR; + TRACE(("Child shell %d\n", getpid())); + oldlvl = shlvl; + shlvl++; - path += 5; - oldpath = path; - for (;;) { - find_command(argv[0], &cmdentry, cmd_flag, path); - if (cmdentry.cmdtype == CMDUNKNOWN) { - status = 127; - flushout(stderr); - goto bail; - } + /* man bash: "Non-builtin commands run by bash have signal handlers + * set to the values inherited by the shell from its parent". + * Do we do it correctly? */ - /* implement bltin and command here */ - 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) { + closescript(); + clear_traps(); +#if JOBS + /* do job control only in root shell */ + doing_jobctl = 0; + if (mode != FORK_NOJOB && jp->jobctl && !oldlvl) { + pid_t pgrp; - path = oldpath; - nargv = parse_command_args(argv, &path); - if (!nargv) - break; - argc -= nargv - argv; - argv = nargv; - cmd_flag |= DO_NOFUNC; - } else + if (jp->nprocs == 0) + pgrp = getpid(); + else + pgrp = jp->ps[0].pid; + /* this can fail because we are doing it in the parent also */ + setpgid(0, pgrp); + if (mode == FORK_FG) + xtcsetpgrp(ttyfd, pgrp); + setsignal(SIGTSTP); + setsignal(SIGTTOU); + } else #endif - break; + if (mode == FORK_BG) { + /* man bash: "When job control is not in effect, + * asynchronous commands ignore SIGINT and SIGQUIT" */ + ignoresig(SIGINT); + ignoresig(SIGQUIT); + if (jp->nprocs == 0) { + close(0); + if (open(bb_dev_null, O_RDONLY) != 0) + ash_msg_and_raise_error("can't open '%s'", bb_dev_null); } } - - if (status) { - /* We have a redirection error. */ - if (spclbltin > 0) - exraise(EXERROR); -bail: - exitstatus = status; - goto out; - } - - /* Execute the command. */ - 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; - } - FORCEINTON; - } - listsetvar(varlist.list, VEXPORT|VSTACK); - shellexec(argv, path, cmdentry.u.index); - /* NOTREACHED */ - - 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 (!oldlvl) { + if (iflag) { /* why if iflag only? */ + setsignal(SIGINT); + setsignal(SIGTERM); } - break; - - case CMDFUNCTION: - listsetvar(varlist.list, 0); - if (evalfun(cmdentry.u.func, argc, argv, flags)) - goto raise; - break; + /* man bash: + * "In all cases, bash ignores SIGQUIT. Non-builtin + * commands run by bash have signal handlers + * set to the values inherited by the shell + * from its parent". + * Take care of the second rule: */ + setsignal(SIGQUIT); } - -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); -} - -static int -evalbltin(const struct builtincmd *cmd, int argc, char **argv) { - char *volatile savecmdname; - struct jmploc *volatile savehandler; - struct jmploc jmploc; - int i; - - 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; - - return i; + for (jp = curjob; jp; jp = jp->prev_job) + freejob(jp); + jobless = 0; } -static int -evalfun(struct funcnode *func, int argc, char **argv, int flags) +/* Called after fork(), in parent */ +#if !JOBS +#define forkparent(jp, n, mode, pid) forkparent(jp, mode, pid) +#endif +static void +forkparent(struct job *jp, union node *n, int mode, pid_t pid) { - volatile struct shparam saveparam; - struct localvar *volatile savelocalvars; - struct jmploc *volatile savehandler; - struct jmploc jmploc; - int e; + TRACE(("In parent shell: child = %d\n", pid)); + if (!jp) { + while (jobless && dowait(DOWAIT_NONBLOCK, NULL) > 0) + continue; + jobless++; + return; + } +#if JOBS + if (mode != FORK_NOJOB && jp->jobctl) { + int pgrp; - saveparam = shellparam; - savelocalvars = localvars; - if ((e = setjmp(jmploc.loc))) { - goto funcdone; + if (jp->nprocs == 0) + pgrp = pid; + else + pgrp = jp->ps[0].pid; + /* This can fail because we are doing it in the child also */ + setpgid(pid, pgrp); } - INTOFF; - savehandler = handler; - handler = &jmploc; - localvars = NULL; - shellparam.malloc = 0; - func->count++; - INTON; - 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; + 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 JOBS + if (doing_jobctl && n) + ps->cmd = commandtext(n); +#endif } - return e; } - -/* - * 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. - */ - -static void -prehash(union node *n) +static int +forkshell(struct job *jp, union node *n, int mode) { - struct cmdentry entry; + int pid; - if (n->type == NCMD && n->ncmd.args) - find_command(n->ncmd.args->narg.text, &entry, 0, pathval()); + 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); + ash_msg_and_raise_error("can't fork"); + } + if (pid == 0) + forkchild(jp, /*n,*/ mode); + else + forkparent(jp, n, mode, pid); + return pid; } - - -/* - * Builtin commands. Builtin commands whose functions are closely - * tied to evaluation are implemented here. - */ - /* - * No command given. + * Wait for job to finish. + * + * Under job control we have the problem that while a child process + * is running interrupts generated by the user are sent to the child + * but not to the shell. This means that an infinite loop started by + * an interactive user may be hard to kill. With job control turned off, + * an interactive user may place an interactive program inside a loop. + * If the interactive program catches interrupts, the user doesn't want + * these interrupts to also abort the loop. The approach we take here + * is to have the shell ignore interrupt signals while waiting for a + * foreground process to terminate, and then send itself an interrupt + * signal if the child process was terminated by an interrupt signal. + * Unfortunately, some programs want to do a bit of cleanup and then + * 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 -bltincmd(int argc, char **argv) +waitforjob(struct job *jp) { - /* - * Preserve exitstatus of a previous possible redirection - * as POSIX mandates - */ - return back_exitstatus; -} - + int st; -/* - * Handle break and continue commands. Break, continue, and return are - * all handled by setting the evalskip flag. The evaluation routines - * above all check this flag, and if it is set they start skipping - * commands rather than executing them. The variable skipcount is - * the number of loops to break/continue, or the number of function - * levels to return. (The latter is always 1.) It should probably - * be an error to break out of more loops than exist, but it isn't - * in the standard shell so we don't make it one here. - */ + TRACE(("waitforjob(%%%d) called\n", jobno(jp))); -static int -breakcmd(int argc, char **argv) -{ - int n = argc > 1 ? number(argv[1]) : 1; + INT_OFF; + while (jp->state == JOBRUNNING) { + /* In non-interactive shells, we _can_ get + * a keyboard signal here and be EINTRed, + * but we just loop back, waiting for command to complete. + * + * man bash: + * "If bash is waiting for a command to complete and receives + * a signal for which a trap has been set, the trap + * will not be executed until the command completes." + * + * Reality is that even if trap is not set, bash + * will not act on the signal until command completes. + * Try this. sleep5intoff.c: + * #include <signal.h> + * #include <unistd.h> + * int main() { + * sigset_t set; + * sigemptyset(&set); + * sigaddset(&set, SIGINT); + * sigaddset(&set, SIGQUIT); + * sigprocmask(SIG_BLOCK, &set, NULL); + * sleep(5); + * return 0; + * } + * $ bash -c './sleep5intoff; echo hi' + * ^C^C^C^C <--- pressing ^C once a second + * $ _ + * $ bash -c './sleep5intoff; echo hi' + * ^\^\^\^\hi <--- pressing ^\ (SIGQUIT) + * $ _ + */ + dowait(DOWAIT_BLOCK, jp); + } + INT_ON; - if (n <= 0) - error(illnum, argv[1]); - if (n > loopnest) - n = loopnest; - if (n > 0) { - evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK; - skipcount = n; + 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 + * occurred, and if so interrupt ourselves. Yuck. - mycroft + */ + if (jp->sigint) /* TODO: do the same with all signals */ + raise(SIGINT); /* ... by raise(jp->sig) instead? */ } - return 0; + if (jp->state == JOBDONE) +#endif + freejob(jp); + return st; } - /* - * The return command. + * return 1 if there are stopped jobs, otherwise 0 */ - static int -returncmd(int argc, char **argv) +stoppedjobs(void) { - int ret = argc > 1 ? number(argv[1]) : exitstatus; + struct job *jp; + int retval; - if (funcnest) { - evalskip = SKIPFUNC; - skipcount = 1; - return ret; - } - else { - /* Do what ksh does; skip the rest of the file */ - evalskip = SKIPFILE; - skipcount = 1; - return ret; + retval = 0; + if (job_warning) + goto out; + jp = curjob; + if (jp && jp->state == JOBSTOPPED) { + out2str("You have stopped jobs.\n"); + job_warning = 2; + retval++; } + out: + return retval; } -static int -falsecmd(int argc, char **argv) -{ - return 1; -} - - -static int -truecmd(int argc, char **argv) -{ - return 0; -} - - -static int -execcmd(int argc, char **argv) -{ - if (argc > 1) { - iflag = 0; /* exit on error */ - mflag = 0; - optschanged(); - shellexec(argv + 1, pathval(), 0); - } - return 0; -} +/* ============ redir.c + * + * Code for dealing with input/output redirection. + */ +#define EMPTY -2 /* marks an unused slot in redirtab */ +#define CLOSED -3 /* marks a slot of previously-closed fd */ +/* + * Open a file in noclobber mode. + * The code was copied from bash. + */ static int -eprintlist(struct strlist *sp, int sep) +noclobberopen(const char *fname) { - while (sp) { - const char *p; + int r, fd; + struct stat finfo, finfo2; - p = " %s" + (1 - sep); - sep |= 1; - fprintf(stderr, p, sp->text); - sp = sp->next; + /* + * If the file exists and is a regular file, return an error + * immediately. + */ + r = stat(fname, &finfo); + if (r == 0 && S_ISREG(finfo.st_mode)) { + errno = EEXIST; + return -1; } - 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 */ -}; - + /* + * If the file was not present (r != 0), make sure we open it + * exclusively so that if it is created before we open it, our open + * will fail. Make sure that we do not truncate an existing file. + * Note that we don't turn on O_EXCL unless the stat failed -- if the + * file was not a regular file, we leave O_EXCL off. + */ + if (r != 0) + return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666); + fd = open(fname, O_WRONLY|O_CREAT, 0666); -static struct tblentry *cmdtable[CMDTABLESIZE]; -static int builtinloc = -1; /* index in path of %builtin, or -1 */ + /* If the open failed, return the file descriptor right away. */ + if (fd < 0) + return fd; + /* + * OK, the open succeeded, but the file may have been changed from a + * non-regular file to a regular file between the stat and the open. + * We are assuming that the O_EXCL open handles the case where FILENAME + * did not exist and is symlinked to an existing file between the stat + * and open. + */ -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); + /* + * If we can open it and fstat the file descriptor, and neither check + * revealed that it was a regular file, and the file has not been + * replaced, return the file descriptor. + */ + if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) + && finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino) + return fd; + /* The file has been replaced. badness. */ + close(fd); + errno = EEXIST; + return -1; +} /* - * Exec a program. Never returns. If you change this routine, you may - * have to change the find_command routine as well. + * Handle here documents. Normally we fork off a process to write the + * data to a pipe. If the document is short, we can stuff the data in + * the pipe without forking. */ - -static void -shellexec(char **argv, const char *path, int idx) +/* openhere needs this forward reference */ +static void expandhere(union node *arg, int fd); +static int +openhere(union node *redir) { - char *cmdname; - int e; - char **envp; + int pip[2]; + size_t len = 0; - clearredir(1); - envp = environment(); - if (strchr(argv[0], '/') != NULL -#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL - || find_applet_by_name(argv[0]) -#endif - ) { - tryexec(argv[0], argv, envp); - e = errno; - } else { - e = ENOENT; - while ((cmdname = padvance(&path, argv[0])) != NULL) { - if (--idx < 0 && pathopt == NULL) { - tryexec(cmdname, argv, envp); - if (errno != ENOENT && errno != ENOTDIR) - e = errno; - } - stunalloc(cmdname); + if (pipe(pip) < 0) + ash_msg_and_raise_error("pipe call failed"); + if (redir->type == NHERE) { + len = strlen(redir->nhere.doc->narg.text); + if (len <= PIPE_BUF) { + full_write(pip[1], redir->nhere.doc->narg.text, len); + goto out; } } - - /* Map to POSIX errors */ - switch (e) { - case EACCES: - exerrno = 126; - break; - case ENOENT: - exerrno = 127; - break; - default: - exerrno = 2; - break; + if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) { + /* child */ + close(pip[0]); + ignoresig(SIGINT); //signal(SIGINT, SIG_IGN); + ignoresig(SIGQUIT); //signal(SIGQUIT, SIG_IGN); + ignoresig(SIGHUP); //signal(SIGHUP, SIG_IGN); + ignoresig(SIGTSTP); //signal(SIGTSTP, SIG_IGN); + signal(SIGPIPE, SIG_DFL); + if (redir->type == NHERE) + full_write(pip[1], redir->nhere.doc->narg.text, len); + else /* NXHERE */ + expandhere(redir->nhere.doc, pip[1]); + _exit(EXIT_SUCCESS); } - 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 */ + out: + close(pip[1]); + return pip[0]; } - -static void -tryexec(char *cmd, char **argv, char **envp) +static int +openredirect(union node *redir) { - int repeated = 0; -#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL - int flg_bb = 0; - char *name = cmd; - -#ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN - name = bb_get_last_path_component(name); - if(find_applet_by_name(name) != NULL) - flg_bb = 1; -#else - if(strchr(name, '/') == NULL && find_applet_by_name(name) != NULL) { - flg_bb = 1; - } -#endif - if(flg_bb) { - char **ap; - char **new; + char *fname; + int f; - *argv = name; - if(strcmp(name, "busybox")) { - for (ap = argv; *ap; ap++); - ap = new = xmalloc((ap - argv + 2) * sizeof(char *)); - *ap++ = cmd = "/bin/busybox"; - while ((*ap++ = *argv++)); - argv = new; - repeated++; - } else { - cmd = "/bin/busybox"; - } - } + switch (redir->nfile.type) { + case NFROM: + fname = redir->nfile.expfname; + f = open(fname, O_RDONLY); + if (f < 0) + goto eopen; + break; + case NFROMTO: + fname = redir->nfile.expfname; + f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666); + if (f < 0) + goto ecreate; + break; + case NTO: +#if ENABLE_ASH_BASH_COMPAT + case NTO2: #endif - -repeat: -#ifdef SYSV - do { - execve(cmd, argv, envp); - } while (errno == EINTR); -#else - execve(cmd, argv, envp); + /* Take care of noclobber mode. */ + if (Cflag) { + fname = redir->nfile.expfname; + f = noclobberopen(fname); + if (f < 0) + goto ecreate; + break; + } + /* FALLTHROUGH */ + case NCLOBBER: + fname = redir->nfile.expfname; + f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666); + if (f < 0) + goto ecreate; + break; + case NAPPEND: + fname = redir->nfile.expfname; + f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666); + if (f < 0) + goto ecreate; + break; + default: +#if DEBUG + abort(); #endif - if (repeated++) { - ckfree(argv); - } else if (errno == ENOEXEC) { - char **ap; - char **new; - - for (ap = argv; *ap; ap++) - ; - ap = new = ckmalloc((ap - argv + 2) * sizeof(char *)); - *ap++ = cmd = "/bin/sh"; - while ((*ap++ = *argv++)) - ; - argv = new; - goto repeat; + /* Fall through to eliminate warning. */ +/* Our single caller does this itself */ +// case NTOFD: +// case NFROMFD: +// f = -1; +// break; + case NHERE: + case NXHERE: + f = openhere(redir); + break; } -} - + return f; + ecreate: + ash_msg_and_raise_error("can't create %s: %s", fname, errmsg(errno, "nonexistent directory")); + eopen: + ash_msg_and_raise_error("can't open %s: %s", fname, errmsg(errno, "no such file")); +} /* - * Do a path search. The variable path (passed by reference) should be - * set to the start of the path before the first call; padvance will update - * this value as it proceeds. Successive calls to padvance will return - * the possible path expansions in sequence. If an option (indicated by - * a percent sign) appears in the path entry then the global variable - * pathopt will be set to point to it; otherwise pathopt will be set to - * NULL. + * 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 char * -padvance(const char **path, const char *name) +/* 0x800..00: bit to set in "to" to request dup2 instead of fcntl(F_DUPFD). + * old code was doing close(to) prior to copyfd() to achieve the same */ +enum { + COPYFD_EXACT = (int)~(INT_MAX), + COPYFD_RESTORE = (int)((unsigned)COPYFD_EXACT >> 1), +}; +static int +copyfd(int from, int to) { - const char *p; - char *q; - const char *start; - size_t len; + int newfd; - 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' */ - while (stackblocksize() < len) - growstackblock(); - q = stackblock(); - if (p != start) { - memcpy(q, start, p - start); - q += p - start; - *q++ = '/'; + if (to & COPYFD_EXACT) { + to &= ~COPYFD_EXACT; + /*if (from != to)*/ + newfd = dup2(from, to); + } else { + newfd = fcntl(from, F_DUPFD, to); } - strcpy(q, name); - pathopt = NULL; - if (*p == '%') { - pathopt = ++p; - while (*p && *p != ':') p++; + if (newfd < 0) { + if (errno == EMFILE) + return EMPTY; + /* Happens when source fd is not open: try "echo >&99" */ + ash_msg_and_raise_error("%d: %m", from); } - if (*p == ':') - *path = p + 1; - else - *path = NULL; - return stalloc(len); + return newfd; } +/* Struct def and variable are moved down to the first usage site */ +struct two_fd_t { + int orig, copy; +}; +struct redirtab { + struct redirtab *next; + int nullredirs; + int pair_count; + struct two_fd_t two_fd[0]; +}; +#define redirlist (G_var.redirlist) - -/*** Command hashing code ***/ - - -static int -hashcmd(int argc, char **argv) +static int need_to_remember(struct redirtab *rp, int fd) { - struct tblentry **pp; - struct tblentry *cmdp; - int c; - struct cmdentry entry; - char *name; + int i; - while ((c = nextopt("r")) != '\0') { - clearcmdentry(0); + if (!rp) /* remembering was not requested */ return 0; - } - if (*argptr == NULL) { - for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) { - for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { - if (cmdp->cmdtype == CMDNORMAL) - printentry(cmdp); - } + + for (i = 0; i < rp->pair_count; i++) { + if (rp->two_fd[i].orig == fd) { + /* already remembered */ + return 0; } - return 0; } - c = 0; - while ((name = *argptr) != NULL) { - if ((cmdp = cmdlookup(name, 0)) != NULL - && (cmdp->cmdtype == CMDNORMAL - || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))) - delete_cmd_entry(); - find_command(name, &entry, DO_ERR, pathval()); - if (entry.cmdtype == CMDUNKNOWN) - c = 1; - argptr++; - } - return c; + return 1; } - -static void -printentry(struct tblentry *cmdp) +/* "hidden" fd is a fd used to read scripts, or a copy of such */ +static int is_hidden_fd(struct redirtab *rp, int fd) { - int idx; - const char *path; - char *name; + int i; + struct parsefile *pf; - idx = cmdp->param.index; - path = pathval(); - do { - name = padvance(&path, cmdp->cmdname); - stunalloc(name); - } while (--idx >= 0); - out1str(name); - out1fmt(snlfmt, cmdp->rehash ? "*" : nullstr); + if (fd == -1) + return 0; + pf = g_parsefile; + while (pf) { + if (fd == pf->fd) { + return 1; + } + pf = pf->prev; + } + if (!rp) + return 0; + fd |= COPYFD_RESTORE; + for (i = 0; i < rp->pair_count; i++) { + if (rp->two_fd[i].copy == fd) { + return 1; + } + } + return 0; } - - /* - * Resolve a command name. If you change this routine, you may have to - * change the shellexec routine as well. + * 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, is saved in memory. */ - +/* flags passed to redirect */ +#define REDIR_PUSH 01 /* save previous values of file descriptors */ +#define REDIR_SAVEFD2 03 /* set preverrout */ static void -find_command(char *name, struct cmdentry *entry, int act, const char *path) +redirect(union node *redir, int flags) { - struct tblentry *cmdp; - int idx; - int prev; - char *fullname; - struct stat statb; - int e; - int updatetbl; - struct builtincmd *bcmd; - - /* 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) { -#ifdef SYSV - if (errno == EINTR) - continue; -#endif - entry->cmdtype = CMDUNKNOWN; - return; - } - } - entry->cmdtype = CMDNORMAL; - return; - } + struct redirtab *sv; + int sv_pos; + int i; + int fd; + int newfd; + int copied_fd2 = -1; -#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL - if (find_applet_by_name(name)) { - entry->cmdtype = CMDNORMAL; - entry->u.index = -1; + g_nullredirs++; + if (!redir) { return; } -#endif - - updatetbl = (path == pathval()); - if (!updatetbl) { - act |= DO_ALTPATH; - if (strstr(path, "%builtin") != NULL) - act |= DO_ALTBLTIN; - } - - /* If name is in the table, check answer will be ok */ - if ((cmdp = cmdlookup(name, 0)) != NULL) { - int bit; - switch (cmdp->cmdtype) { - default: -#if DEBUG - abort(); + sv = NULL; + sv_pos = 0; + INT_OFF; + if (flags & REDIR_PUSH) { + union node *tmp = redir; + do { + sv_pos++; +#if ENABLE_ASH_BASH_COMPAT + if (redir->nfile.type == NTO2) + sv_pos++; #endif - case CMDNORMAL: - bit = DO_ALTPATH; - break; - case CMDFUNCTION: - bit = DO_NOFUNC; - break; - case CMDBUILTIN: - bit = DO_ALTBLTIN; - break; + tmp = tmp->nfile.next; + } while (tmp); + sv = ckmalloc(sizeof(*sv) + sv_pos * sizeof(sv->two_fd[0])); + sv->next = redirlist; + sv->pair_count = sv_pos; + redirlist = sv; + sv->nullredirs = g_nullredirs - 1; + g_nullredirs = 0; + while (sv_pos > 0) { + sv_pos--; + sv->two_fd[sv_pos].orig = sv->two_fd[sv_pos].copy = EMPTY; } - 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 */ - 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 */ - if (cmdp->cmdtype == CMDBUILTIN) - prev = builtinloc; - else - prev = cmdp->param.index; - } - - e = ENOENT; - idx = -1; -loop: - while ((fullname = padvance(&path, name)) != NULL) { - stunalloc(fullname); - idx++; - if (pathopt) { - if (prefix(pathopt, "builtin")) { - if (bcmd) - goto builtin_success; - continue; - } else if (!(act & DO_NOFUNC) && - prefix(pathopt, "func")) { - /* handled below */ - } else { - /* ignore unimplemented options */ + do { + fd = redir->nfile.fd; + if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) { + int right_fd = redir->ndup.dupfd; + /* redirect from/to same file descriptor? */ + if (right_fd == fd) continue; + /* echo >&10 and 10 is a fd opened to the sh script? */ + if (is_hidden_fd(sv, right_fd)) { + errno = EBADF; /* as if it is closed */ + ash_msg_and_raise_error("%d: %m", right_fd); } - } - /* if rehash, don't redo absolute path names */ - if (fullname[0] == '/' && idx <= prev) { - if (idx < prev) + newfd = -1; + } else { + newfd = openredirect(redir); /* always >= 0 */ + if (fd == newfd) { + /* Descriptor wasn't open before redirect. + * Mark it for close in the future */ + if (need_to_remember(sv, fd)) { + goto remember_to_close; + } continue; - TRACE(("searchexec \"%s\": no change\n", name)); - goto success; + } } - while (stat(fullname, &statb) < 0) { -#ifdef SYSV - if (errno == EINTR) - continue; +#if ENABLE_ASH_BASH_COMPAT + redirect_more: #endif - if (errno != ENOENT && errno != ENOTDIR) - e = errno; - goto loop; - } - e = EACCES; /* if we fail, this will be the error */ - if (!S_ISREG(statb.st_mode)) - continue; - if (pathopt) { /* this is a %func directory */ - stalloc(strlen(fullname) + 1); - readcmdfile(fullname); - if ((cmdp = cmdlookup(name, 0)) == NULL || - cmdp->cmdtype != CMDFUNCTION) - error("%s not defined in %s", name, fullname); - stunalloc(fullname); - goto success; + if (need_to_remember(sv, fd)) { + /* Copy old descriptor */ + i = fcntl(fd, F_DUPFD, 10); +/* You'd expect copy to be CLOEXECed. Currently these extra "saved" fds + * are closed in popredir() in the child, preventing them from leaking + * into child. (popredir() also cleans up the mess in case of failures) + */ + if (i == -1) { + i = errno; + if (i != EBADF) { + /* Strange error (e.g. "too many files" EMFILE?) */ + if (newfd >= 0) + close(newfd); + errno = i; + ash_msg_and_raise_error("%d: %m", fd); + /* NOTREACHED */ + } + /* EBADF: it is not open - good, remember to close it */ + remember_to_close: + i = CLOSED; + } else { /* fd is open, save its copy */ + /* "exec fd>&-" should not close fds + * which point to script file(s). + * Force them to be restored afterwards */ + if (is_hidden_fd(sv, fd)) + i |= COPYFD_RESTORE; + } + if (fd == 2) + copied_fd2 = i; + sv->two_fd[sv_pos].orig = fd; + sv->two_fd[sv_pos].copy = i; + sv_pos++; + } + if (newfd < 0) { + /* NTOFD/NFROMFD: copy redir->ndup.dupfd to fd */ + if (redir->ndup.dupfd < 0) { /* "fd>&-" */ + /* Don't want to trigger debugging */ + if (fd != -1) + close(fd); + } else { + copyfd(redir->ndup.dupfd, fd | COPYFD_EXACT); + } + } else if (fd != newfd) { /* move newfd to fd */ + copyfd(newfd, fd | COPYFD_EXACT); +#if ENABLE_ASH_BASH_COMPAT + if (!(redir->nfile.type == NTO2 && fd == 2)) +#endif + close(newfd); } - TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname)); - if (!updatetbl) { - entry->cmdtype = CMDNORMAL; - entry->u.index = idx; - return; +#if ENABLE_ASH_BASH_COMPAT + if (redir->nfile.type == NTO2 && fd == 1) { + /* We already redirected it to fd 1, now copy it to 2 */ + newfd = 1; + fd = 2; + goto redirect_more; } - INTOFF; - cmdp = cmdlookup(name, 1); - cmdp->cmdtype = CMDNORMAL; - cmdp->param.index = idx; - INTON; - goto success; - } - - /* We failed. If there was an entry for this command, delete it */ - if (cmdp && updatetbl) - delete_cmd_entry(); - if (act & DO_ERR) - sh_warnx("%s: %s", name, errmsg(e, E_EXEC)); - entry->cmdtype = CMDUNKNOWN; - return; - -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) -{ - struct builtincmd *bp; +#endif + } while ((redir = redir->nfile.next) != NULL); - bp = bsearch( - name, builtincmd, NUMBUILTINS, sizeof(struct builtincmd), - pstrcmp - ); - return bp; + INT_ON; + if ((flags & REDIR_SAVEFD2) && copied_fd2 >= 0) + preverrout_fd = copied_fd2; } - - /* - * Called when a cd is done. Marks all commands so the next time they - * are executed they will be rehashed. + * Undo the effects of the last redirection. */ - static void -hashcd(void) +popredir(int drop, int restore) { - struct tblentry **pp; - struct tblentry *cmdp; + struct redirtab *rp; + int i; - 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; + if (--g_nullredirs >= 0) + return; + INT_OFF; + rp = redirlist; + for (i = 0; i < rp->pair_count; i++) { + int fd = rp->two_fd[i].orig; + int copy = rp->two_fd[i].copy; + if (copy == CLOSED) { + if (!drop) + close(fd); + continue; + } + if (copy != EMPTY) { + if (!drop || (restore && (copy & COPYFD_RESTORE))) { + copy &= ~COPYFD_RESTORE; + /*close(fd);*/ + copyfd(copy, fd | COPYFD_EXACT); + } + close(copy & ~COPYFD_RESTORE); } } + redirlist = rp->next; + g_nullredirs = rp->nullredirs; + free(rp); + INT_ON; } - - /* - * 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. + * Undo all redirections. Called on error or interrupt. */ +/* + * Discard all saved file descriptors. + */ static void -changepath(const char *newval) +clearredir(int drop) { - const char *old, *new; - int idx; - int firstchange; - int idx_bltin; - - 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') + g_nullredirs = 0; + if (!redirlist) break; - if (*new == '%' && idx_bltin < 0 && prefix(new + 1, "builtin")) - idx_bltin = idx; - if (*new == ':') { - idx++; - } - new++, old++; + popredir(drop, /*restore:*/ 0); } - if (builtinloc < 0 && idx_bltin >= 0) - builtinloc = idx_bltin; /* zap builtins */ - if (builtinloc >= 0 && idx_bltin < 0) - firstchange = 0; - clearcmdentry(firstchange); - builtinloc = idx_bltin; } - -/* - * Clear out command entries. The argument specifies the first entry in - * PATH which has changed. - */ - -static void -clearcmdentry(int firstchange) +static int +redirectsafe(union node *redir, int flags) { - struct tblentry **tblp; - struct tblentry **pp; - struct tblentry *cmdp; + int err; + volatile int saveint; + struct jmploc *volatile savehandler = exception_handler; + struct jmploc jmploc; - INTOFF; - 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)) { - *pp = cmdp->next; - ckfree(cmdp); - } else { - pp = &cmdp->next; - } - } + SAVE_INT(saveint); + /* "echo 9>/dev/null; echo >&9; echo result: $?" - result should be 1, not 2! */ + err = setjmp(jmploc.loc); // huh?? was = setjmp(jmploc.loc) * 2; + if (!err) { + exception_handler = &jmploc; + redirect(redir, flags); } - INTON; + exception_handler = savehandler; + if (err && exception_type != EXERROR) + longjmp(exception_handler->loc, 1); + RESTORE_INT(saveint); + return err; } - -/* - * 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. +/* ============ Routines to expand arguments to commands * - * Interrupts must be off if called with add != 0. + * We have to deal with backquotes, shell variables, and file metacharacters. */ -static struct tblentry **lastcmdentry; - - -static struct tblentry * -cmdlookup(const char *name, int add) +#if ENABLE_SH_MATH_SUPPORT +static arith_t +ash_arith(const char *s) { - unsigned int hashval; - const char *p; - struct tblentry *cmdp; - struct tblentry **pp; + arith_eval_hooks_t math_hooks; + arith_t result; + int errcode = 0; - p = name; - hashval = (unsigned char)*p << 4; - while (*p) - hashval += (unsigned char)*p++; - hashval &= 0x7FFF; - pp = &cmdtable[hashval % CMDTABLESIZE]; - for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) { - if (equal(cmdp->cmdname, name)) - break; - pp = &cmdp->next; - } - if (add && cmdp == NULL) { - cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB - + strlen(name) + 1); - cmdp->next = NULL; - cmdp->cmdtype = CMDUNKNOWN; - strcpy(cmdp->cmdname, name); + math_hooks.lookupvar = lookupvar; + math_hooks.setvar = setvar; + math_hooks.endofname = endofname; + + INT_OFF; + result = arith(s, &errcode, &math_hooks); + if (errcode < 0) { + if (errcode == -3) + ash_msg_and_raise_error("exponent less than 0"); + if (errcode == -2) + ash_msg_and_raise_error("divide by zero"); + if (errcode == -5) + ash_msg_and_raise_error("expression recursion loop detected"); + raise_error_syntax(s); } - lastcmdentry = pp; - return cmdp; + INT_ON; + + return result; } +#endif /* - * Delete the command entry returned on the last lookup. + * 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 */ +/* + * _rmescape() flags + */ +#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 */ -static void -delete_cmd_entry(void) -{ - struct tblentry *cmdp; +/* + * Structure specifying which parts of the string should be searched + * for IFS characters. + */ +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 */ +}; - INTOFF; - cmdp = *lastcmdentry; - *lastcmdentry = cmdp->next; - if (cmdp->cmdtype == CMDFUNCTION) - freefunc(cmdp->param.func); - ckfree(cmdp); - INTON; -} +struct arglist { + struct strlist *list; + struct strlist **lastp; +}; +/* 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; /* - * Add a new command entry, replacing any existing command entry for - * the same name - except special builtins. + * Our own itoa(). */ +static int +cvtnum(arith_t num) +{ + int len; -static inline void -addcmdentry(char *name, struct cmdentry *entry) + expdest = makestrspace(32, expdest); + len = fmtstr(expdest, 32, arith_t_fmt, num); + STADJUST(len, expdest); + return len; +} + +static size_t +esclen(const char *start, const char *p) { - struct tblentry *cmdp; + size_t esc = 0; - cmdp = cmdlookup(name, 1); - if (cmdp->cmdtype == CMDFUNCTION) { - freefunc(cmdp->param.func); + while (p > start && *--p == CTLESC) { + esc++; } - cmdp->cmdtype = entry->cmdtype; - cmdp->param = entry->u; - cmdp->rehash = 0; + return esc; } /* - * Make a copy of a parse tree. + * Remove any CTLESC characters from a string. */ - -static inline struct funcnode * -copyfunc(union node *n) +static char * +_rmescapes(char *str, int flag) { - struct funcnode *f; - size_t blocksize; + static const char qchars[] ALIGN1 = { CTLESC, CTLQUOTEMARK, '\0' }; - 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; + char *p, *q, *r; + unsigned inquotes; + int notescaped; + int globbing; + + p = strpbrk(str, qchars); + if (!p) { + return str; + } + q = p; + r = str; + if (flag & RMESCAPE_ALLOC) { + size_t len = p - str; + size_t fulllen = len + strlen(p) + 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) { + q = (char *)memcpy(q, str, len) + 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 (notescaped && inquotes && *p != '/') { + *q++ = '\\'; + } + } + notescaped = globbing; + copy: + *q++ = *p++; + } + *q = '\0'; + if (flag & RMESCAPE_GROW) { + expdest = r; + STADJUST(q - r + 1, expdest); + } + return r; } +#define rmescapes(p) _rmescapes((p), 0) + +#define pmatch(a, b) !fnmatch((a), (b), 0) /* - * Define a shell function. + * Prepare a pattern for a expmeta (internal glob(3)) call. + * + * Returns an stalloced string. */ +static char * +preglob(const char *pattern, int quoted, int flag) +{ + flag |= RMESCAPE_GLOB; + if (quoted) { + flag |= RMESCAPE_QUOTED; + } + return _rmescapes((char *)pattern, flag); +} +/* + * Put a string on the stack. + */ static void -defun(char *name, union node *func) +memtodest(const char *p, size_t len, int syntax, int quotes) { - struct cmdentry entry; + char *q = expdest; - INTOFF; - entry.cmdtype = CMDFUNCTION; - entry.u.func = copyfunc(func); - addcmdentry(name, &entry); - INTON; -} + q = makestrspace(len * 2, q); + while (len--) { + int c = signed_char2int(*p++); + if (!c) + continue; + if (quotes && (SIT(c, syntax) == CCTL || SIT(c, syntax) == CBACK)) + USTPUTC(CTLESC, q); + USTPUTC(c, q); + } -/* - * Delete a function if it exists. - */ + expdest = q; +} static void -unsetfunc(const char *name) +strtodest(const char *p, int syntax, int quotes) { - struct tblentry *cmdp; - - if ((cmdp = cmdlookup(name, 0)) != NULL && - cmdp->cmdtype == CMDFUNCTION) - delete_cmd_entry(); + memtodest(p, strlen(p), syntax, quotes); } /* - * Locate and print what a word is... + * Record the fact that we have to scan this region of the + * string for IFS characters. */ - - -#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 +static void +recordregion(int start, int end, int nulonly) { - 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; - } + struct ifsregion *ifsp; -#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; + if (ifslastp == NULL) { + ifsp = &ifsfirst; } 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; + INT_OFF; + ifsp = ckzalloc(sizeof(*ifsp)); + /*ifsp->next = NULL; - ckzalloc did it */ + ifslastp->next = ifsp; + INT_ON; } + ifslastp = ifsp; + ifslastp->begoff = start; + ifslastp->endoff = end; + ifslastp->nulonly = nulonly; +} - case CMDFUNCTION: - if (describe_command_verbose) { - out1str(" is a shell function"); - } else { - out1str(command); - } - break; +static void +removerecordregions(int endoff) +{ + if (ifslastp == NULL) + return; - case CMDBUILTIN: - if (describe_command_verbose) { - out1fmt(" is a %sshell builtin", - IS_BUILTIN_SPECIAL(entry.u.cmd) ? - "special " : nullstr - ); - } else { - out1str(command); + if (ifsfirst.endoff > endoff) { + while (ifsfirst.next != NULL) { + struct ifsregion *ifsp; + INT_OFF; + ifsp = ifsfirst.next->next; + free(ifsfirst.next); + ifsfirst.next = ifsp; + INT_ON; } - break; - - default: - if (describe_command_verbose) { - out1str(": not found\n"); + if (ifsfirst.begoff > endoff) + ifslastp = NULL; + else { + ifslastp = &ifsfirst; + ifsfirst.endoff = endoff; } - return 127; + return; } -out: - out1c('\n'); - return 0; -} - -static int -typecmd(int argc, char **argv) -{ - int i; - int err = 0; - - for (i = 1; i < argc; i++) { -#ifdef CONFIG_ASH_CMDCMD - err |= describe_command(argv[i], 1); -#else - err |= describe_command(argv[i]); -#endif + ifslastp = &ifsfirst; + while (ifslastp->next && ifslastp->next->begoff < endoff) + ifslastp=ifslastp->next; + while (ifslastp->next != NULL) { + struct ifsregion *ifsp; + INT_OFF; + ifsp = ifslastp->next->next; + free(ifslastp->next); + ifslastp->next = ifsp; + INT_ON; } - return err; + if (ifslastp->endoff > endoff) + ifslastp->endoff = endoff; } -#ifdef CONFIG_ASH_CMDCMD -static int -commandcmd(int argc, char **argv) +static char * +exptilde(char *startp, char *p, int flag) { - int c; - int default_path = 0; - int verify_only = 0; - int verbose_verify_only = 0; + char c; + char *name; + struct passwd *pw; + const char *home; + int quotes = flag & (EXP_FULL | EXP_CASE); + int startloc; - while ((c = nextopt("pvV")) != '\0') + name = p + 1; + + while ((c = *++p) != '\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; - case 'v': - verify_only = 1; - break; - case 'V': - verbose_verify_only = 1; + case CTLESC: + return startp; + case CTLQUOTEMARK: + return startp; + case ':': + if (flag & EXP_VARTILDE) + goto done; break; + case '/': + case CTLENDVAR: + goto done; } - - 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; } - - if (verify_only || verbose_verify_only) { - return describe_command(*argptr, verbose_verify_only); + done: + *p = '\0'; + if (*name == '\0') { + home = lookupvar(homestr); + } else { + pw = getpwnam(name); + if (pw == NULL) + goto lose; + home = pw->pw_dir; } - - return 0; + if (!home || !*home) + goto lose; + *p = c; + startloc = expdest - (char *)stackblock(); + strtodest(home, SQSYNTAX, quotes); + recordregion(startloc, expdest - (char *)stackblock(), 0); + return p; + lose: + *p = c; + return startp; } -#endif - -/* $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_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 - * for IFS characters. + * 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. */ - -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 backcmd { /* result of evalbackcmd */ + int fd; /* file descriptor to read from */ + int nleft; /* number of chars in buffer */ + char *buf; /* buffer */ + struct job *jp; /* job structure for command */ }; -/* 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; +/* These forward decls are needed to use "eval" code for backticks handling: */ +static uint8_t back_exitstatus; /* exit status of backquoted command */ +#define EV_EXIT 01 /* exit after evaluating tree */ +static void evaltree(union node *, int); + +static void +evalbackcmd(union node *n, struct backcmd *result) +{ + int saveherefd; -static void argstr(char *, int); -static char *exptilde(char *, char *, int); -static void expbackq(union node *, 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); -static void addglob(const glob_t *); -static void addfname(char *); -static int patmatch(char *, const char *); - -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__)); + result->fd = -1; + result->buf = NULL; + result->nleft = 0; + result->jp = NULL; + if (n == NULL) + goto out; + saveherefd = herefd; + herefd = -1; -#define pmatch(a, b) !fnmatch((a), (b), 0) -/* - * Prepare a pattern for a glob(3) call. - * - * Returns an stalloced string. - */ + { + int pip[2]; + struct job *jp; -static inline char * -preglob(const char *pattern, int quoted, int flag) { - flag |= RMESCAPE_GLOB; - if (quoted) { - flag |= RMESCAPE_QUOTED; + if (pipe(pip) < 0) + ash_msg_and_raise_error("pipe call failed"); + jp = makejob(/*n,*/ 1); + if (forkshell(jp, n, FORK_NOJOB) == 0) { + FORCE_INT_ON; + close(pip[0]); + if (pip[1] != 1) { + /*close(1);*/ + copyfd(pip[1], 1 | COPYFD_EXACT); + close(pip[1]); + } + eflag = 0; + evaltree(n, EV_EXIT); /* actually evaltreenr... */ + /* NOTREACHED */ + } + close(pip[1]); + result->fd = pip[0]; + result->jp = jp; } - return _rmescapes((char *)pattern, flag); + 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)); } +/* + * Expand stuff in backwards quotes. + */ +static void +expbackq(union node *cmd, int quoted, int quotes) +{ + struct backcmd in; + int i; + char buf[128]; + char *p; + char *dest; + int startloc; + int syntax = quoted ? DQSYNTAX : BASESYNTAX; + struct stackmark smark; -static size_t -esclen(const char *start, const char *p) { - size_t esc = 0; + INT_OFF; + setstackmark(&smark); + dest = expdest; + startloc = dest - (char *)stackblock(); + grabstackstr(dest); + evalbackcmd(cmd, &in); + popstackmark(&smark); - while (p > start && *--p == CTLESC) { - esc++; + p = in.buf; + i = in.nleft; + if (i == 0) + goto read; + for (;;) { + memtodest(p, i, syntax, quotes); + read: + if (in.fd < 0) + break; + i = nonblock_safe_read(in.fd, buf, sizeof(buf)); + TRACE(("expbackq: read returns %d\n", i)); + if (i <= 0) + break; + p = buf; } - return esc; -} + free(in.buf); + if (in.fd >= 0) { + close(in.fd); + back_exitstatus = waitforjob(in.jp); + } + INT_ON; -/* - * Expand shell variables and backquotes inside a here document. - */ + /* Eat all trailing newlines */ + dest = expdest; + for (; dest > (char *)stackblock() && dest[-1] == '\n';) + STUNPUTC(dest); + expdest = dest; -static inline void -expandhere(union node *arg, int fd) -{ - herefd = fd; - expandarg(arg, (struct arglist *)NULL, 0); - xwrite(fd, stackblock(), expdest - (char *)stackblock()); + if (quoted == 0) + recordregion(startloc, dest - (char *)stackblock(), 0); + TRACE(("evalbackq: size=%d: \"%.*s\"\n", + (dest - (char *)stackblock()) - startloc, + (dest - (char *)stackblock()) - startloc, + stackblock() + startloc)); } - +#if ENABLE_SH_MATH_SUPPORT /* - * Perform variable substitution and command substitution on an argument, - * placing the resulting list of arguments in arglist. If EXP_FULL is true, - * perform splitting and file name expansion. When arglist is NULL, perform - * here document expansion. + * Expand arithmetic expression. Backup to start of expression, + * evaluate, place result in (backed up) result, adjust string position. */ - -void -expandarg(union node *arg, struct arglist *arglist, int flag) +static void +expari(int quotes) { - struct strlist *sp; - char *p; + char *p, *start; + int begoff; + int flag; + int len; + + /* ifsfree(); */ - argbackq = arg->narg.backquote; - STARTSTACKSTR(expdest); - ifsfirst.next = NULL; - ifslastp = NULL; - argstr(arg->narg.text, flag); - if (arglist == NULL) { - return; /* here document expanded */ - } - STPUTC('\0', expdest); - p = grabstackstr(expdest); - exparg.lastp = &exparg.list; /* - * TODO - EXP_REDIR + * This routine is slightly over-complicated for + * efficiency. Next we scan backwards looking for the + * start of arithmetic. */ - if (flag & EXP_FULL) { - ifsbreakup(p, &exparg); - *exparg.lastp = NULL; - exparg.lastp = &exparg.list; - expandmeta(exparg.list, flag); - } else { - if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */ - rmescapes(p); - sp = (struct strlist *)stalloc(sizeof (struct strlist)); - sp->text = p; - *exparg.lastp = sp; - exparg.lastp = &sp->next; - } - if (ifsfirst.next) - ifsfree(); - *exparg.lastp = NULL; - if (exparg.list) { - *arglist->lastp = exparg.list; - arglist->lastp = exparg.lastp; - } -} + start = stackblock(); + p = expdest - 1; + *p = '\0'; + p--; + do { + int esc; + + while (*p != CTLARI) { + p--; +#if DEBUG + if (p < start) { + ash_msg_and_raise_error("missing CTLARI (shouldn't happen)"); + } +#endif + } + + esc = esclen(start, p); + if (!(esc % 2)) { + break; + } + + p -= esc + 1; + } while (1); + + begoff = p - start; + + removerecordregions(begoff); + flag = p[1]; + + expdest = p; + + if (quotes) + rmescapes(p + 2); + + len = cvtnum(ash_arith(p + 2)); + + if (flag != '"') + recordregion(begoff, begoff + len, 0); +} +#endif +/* argstr needs it */ +static char *evalvar(char *p, int flag, struct strlist *var_str_list); /* * 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. + * + * var_str_list (can be NULL) is a list of "VAR=val" strings which take precedence + * over shell varables. Needed for "A=a B=$A; echo $B" case - we use it + * for correct expansion of "B=$A" word. */ - static void -argstr(char *p, int flag) +argstr(char *p, int flag, struct strlist *var_str_list) { - static const char spclchars[] = { + static const char spclchars[] ALIGN1 = { '=', ':', CTLQUOTEMARK, @@ -4644,14 +5779,14 @@ argstr(char *p, int flag) CTLVAR, CTLBACKQ, CTLBACKQ | CTLQUOTE, -#ifdef CONFIG_ASH_MATH_SUPPORT +#if ENABLE_SH_MATH_SUPPORT CTLENDARI, #endif 0 }; const char *reject = spclchars; int c; - int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */ + int quotes = flag & (EXP_FULL | EXP_CASE | EXP_REDIR); /* do CTLESC */ int breakall = flag & EXP_WORD; int inquotes; size_t length; @@ -4668,20 +5803,20 @@ argstr(char *p, int flag) char *q; flag &= ~EXP_TILDE; -tilde: + tilde: q = p; if (*q == CTLESC && (flag & EXP_QWORD)) q++; if (*q == '~') p = exptilde(p, q, flag); } -start: + start: startloc = expdest - (char *)stackblock(); for (;;) { length += strcspn(p + length, reject); c = p[length]; if (c && (!(c & 0x80) -#ifdef CONFIG_ASH_MATH_SUPPORT +#if ENABLE_SH_MATH_SUPPORT || c == CTLENDARI #endif )) { @@ -4690,7 +5825,7 @@ start: } if (length > 0) { int newloc; - expdest = stnputs(p, length, expdest); + expdest = stack_nputstr(p, length, expdest); newloc = expdest - (char *)stackblock(); if (breakall && !inquotes && newloc > startloc) { recordregion(startloc, newloc, 0); @@ -4729,17 +5864,17 @@ start: /* "$@" syntax adherence hack */ if ( !inquotes && - !memcmp(p, dolatstr, DOLATSTRLEN) && + !memcmp(p, dolatstr, 4) && (p[4] == CTLQUOTEMARK || ( p[4] == CTLENDVAR && p[5] == CTLQUOTEMARK )) ) { - p = evalvar(p + 1, flag) + 1; + p = evalvar(p + 1, flag, /* var_str_list: */ NULL) + 1; goto start; } inquotes = !inquotes; -addquote: + addquote: if (quotes) { p--; length++; @@ -4751,7 +5886,7 @@ addquote: length++; goto addquote; case CTLVAR: - p = evalvar(p, flag); + p = evalvar(p, flag, var_str_list); goto start; case CTLBACKQ: c = 0; @@ -4759,7 +5894,7 @@ addquote: expbackq(argbackq->n, c, quotes); argbackq = argbackq->next; goto start; -#ifdef CONFIG_ASH_MATH_SUPPORT +#if ENABLE_SH_MATH_SUPPORT case CTLENDARI: p--; expari(quotes); @@ -4767,247 +5902,72 @@ addquote: #endif } } -breakloop: + breakloop: ; } static char * -exptilde(char *startp, char *p, int flag) -{ - char c; - char *name; - struct passwd *pw; - const char *home; - int quotes = flag & (EXP_FULL | EXP_CASE); - int startloc; - - name = p + 1; - - while ((c = *++p) != '\0') { - switch(c) { - case CTLESC: - return (startp); - case CTLQUOTEMARK: - return (startp); - case ':': - if (flag & EXP_VARTILDE) - goto done; - break; - case '/': - case CTLENDVAR: - goto done; - } - } -done: - *p = '\0'; - if (*name == '\0') { - if ((home = lookupvar(homestr)) == NULL) - goto lose; - } else { - 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: - *p = c; - return (startp); -} - - -static void -removerecordregions(int endoff) -{ - if (ifslastp == NULL) - return; - - if (ifsfirst.endoff > endoff) { - while (ifsfirst.next != NULL) { - struct ifsregion *ifsp; - INTOFF; - ifsp = ifsfirst.next->next; - ckfree(ifsfirst.next); - ifsfirst.next = ifsp; - INTON; - } - if (ifsfirst.begoff > endoff) - ifslastp = NULL; - else { - ifslastp = &ifsfirst; - ifsfirst.endoff = endoff; - } - return; - } - - ifslastp = &ifsfirst; - while (ifslastp->next && ifslastp->next->begoff < endoff) - ifslastp=ifslastp->next; - while (ifslastp->next != NULL) { - struct ifsregion *ifsp; - INTOFF; - ifsp = ifslastp->next->next; - ckfree(ifslastp->next); - ifslastp->next = ifsp; - INTON; - } - if (ifslastp->endoff > endoff) - ifslastp->endoff = endoff; -} - - -#ifdef CONFIG_ASH_MATH_SUPPORT -/* - * Expand arithmetic expression. Backup to start of expression, - * evaluate, place result in (backed up) result, adjust string position. - */ -void -expari(int quotes) -{ - char *p, *start; - int begoff; - int flag; - int len; - - /* ifsfree(); */ - - /* - * This routine is slightly over-complicated for - * efficiency. Next we scan backwards looking for the - * start of arithmetic. - */ - start = stackblock(); - p = expdest - 1; - *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); - - begoff = p - start; - - removerecordregions(begoff); - - flag = p[1]; - - expdest = p; - - if (quotes) - rmescapes(p + 2); - - len = cvtnum(dash_arith(p + 2)); - - if (flag != '"') - recordregion(begoff, begoff + len, 0); -} -#endif - -/* - * Expand stuff in backwards quotes. - */ - -static void -expbackq(union node *cmd, int quoted, int quotes) -{ - struct backcmd in; - int i; - char buf[128]; - char *p; - char *dest; - int startloc; - int syntax = quoted? DQSYNTAX : BASESYNTAX; - struct stackmark smark; - - INTOFF; - setstackmark(&smark); - dest = expdest; - startloc = dest - (char *)stackblock(); - grabstackstr(dest); - evalbackcmd(cmd, (struct backcmd *) &in); - popstackmark(&smark); - - p = in.buf; - i = in.nleft; - if (i == 0) - goto read; - for (;;) { - 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 */ - dest = expdest; - for (; dest > (char *)stackblock() && dest[-1] == '\n';) - STUNPUTC(dest); - expdest = dest; - - if (quoted == 0) - recordregion(startloc, dest - (char *)stackblock(), 0); - TRACE(("evalbackq: size=%d: \"%.*s\"\n", - (dest - (char *)stackblock()) - startloc, - (dest - (char *)stackblock()) - startloc, - stackblock() + startloc)); -} - - -static char * -scanleft( - char *startp, char *rmesc, char *rmescend, char *str, int quotes, - int zero -) { - char *loc; - char *loc2; +scanleft(char *startp, char *rmesc, char *rmescend UNUSED_PARAM, char *str, int quotes, + int zero) +{ +// This commented out code was added by James Simmons <jsimmons@infradead.org> +// as part of a larger change when he added support for ${var/a/b}. +// However, it broke # and % operators: +// +//var=ababcdcd +// ok bad +//echo ${var#ab} abcdcd abcdcd +//echo ${var##ab} abcdcd abcdcd +//echo ${var#a*b} abcdcd ababcdcd (!) +//echo ${var##a*b} cdcd cdcd +//echo ${var#?} babcdcd ababcdcd (!) +//echo ${var##?} babcdcd babcdcd +//echo ${var#*} ababcdcd babcdcd (!) +//echo ${var##*} +//echo ${var%cd} ababcd ababcd +//echo ${var%%cd} ababcd abab (!) +//echo ${var%c*d} ababcd ababcd +//echo ${var%%c*d} abab ababcdcd (!) +//echo ${var%?} ababcdc ababcdc +//echo ${var%%?} ababcdc ababcdcd (!) +//echo ${var%*} ababcdcd ababcdcd +//echo ${var%%*} +// +// Commenting it back out helped. Remove it completely if it really +// is not needed. + + char *loc, *loc2; //, *full; char c; loc = startp; loc2 = rmesc; do { - int match; + int match; // = strlen(str); const char *s = loc2; + c = *loc2; if (zero) { *loc2 = '\0'; s = rmesc; } - match = pmatch(str, s); + match = pmatch(str, s); // this line was deleted + +// // chop off end if its '*' +// full = strrchr(str, '*'); +// if (full && full != str) +// match--; +// +// // If str starts with '*' replace with s. +// if ((*str == '*') && strlen(s) >= match) { +// full = xstrdup(s); +// strncpy(full+strlen(s)-match+1, str+1, match-1); +// } else +// full = xstrndup(str, match); +// match = strncmp(s, full, strlen(full)); +// free(full); +// *loc2 = c; - if (match) + if (match) // if (!match) return loc; if (quotes && *loc == CTLESC) loc++; @@ -5017,12 +5977,10 @@ scanleft( return 0; } - static char * -scanright( - char *startp, char *rmesc, char *rmescend, char *str, int quotes, - int zero -) { +scanright(char *startp, char *rmesc, char *rmescend, char *str, int quotes, + int zero) +{ int esc = 0; char *loc; char *loc2; @@ -5053,24 +6011,79 @@ scanright( return 0; } +static void varunset(const char *, const char *, const char *, int) NORETURN; +static void +varunset(const char *end, const char *var, const char *umsg, int varflags) +{ + const char *msg; + const char *tail; + + tail = nullstr; + msg = "parameter not set"; + if (umsg) { + if (*end == CTLENDVAR) { + if (varflags & VSNUL) + tail = " or null"; + } else { + msg = umsg; + } + } + ash_msg_and_raise_error("%.*s: %s%s", end - var - 1, var, msg, tail); +} + +#if ENABLE_ASH_BASH_COMPAT +static char * +parse_sub_pattern(char *arg, int inquotes) +{ + char *idx, *repl = NULL; + unsigned char c; + + idx = arg; + while (1) { + c = *arg; + if (!c) + break; + if (c == '/') { + /* Only the first '/' seen is our separator */ + if (!repl) { + repl = idx + 1; + c = '\0'; + } + } + *idx++ = c; + if (!inquotes && c == '\\' && arg[1] == '\\') + arg++; /* skip both \\, not just first one */ + arg++; + } + *idx = c; /* NUL */ + + return repl; +} +#endif /* ENABLE_ASH_BASH_COMPAT */ + static const char * -subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes) +subevalvar(char *p, char *str, int strloc, int subtype, + int startloc, int varflags, int quotes, struct strlist *var_str_list) { + struct nodelist *saveargbackq = argbackq; char *startp; char *loc; - int saveherefd = herefd; - struct nodelist *saveargbackq = argbackq; - int amount; char *rmesc, *rmescend; + USE_ASH_BASH_COMPAT(char *repl = NULL;) + USE_ASH_BASH_COMPAT(char null = '\0';) + USE_ASH_BASH_COMPAT(int pos, len, orig_len;) + int saveherefd = herefd; + int amount, workloc, resetloc; int zero; - char *(*scan)(char *, char *, char *, char *, int , int); + char *(*scan)(char*, char*, char*, char*, int, int); herefd = -1; - argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0); + argstr(p, (subtype != VSASSIGN && subtype != VSQUESTION) ? EXP_CASE : 0, + var_str_list); STPUTC('\0', expdest); herefd = saveherefd; argbackq = saveargbackq; - startp = stackblock() + startloc; + startp = (char *)stackblock() + startloc; switch (subtype) { case VSASSIGN: @@ -5079,30 +6092,177 @@ subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varfla STADJUST(amount, expdest); return startp; +#if ENABLE_ASH_BASH_COMPAT + case VSSUBSTR: + loc = str = stackblock() + strloc; +// TODO: number() instead? It does error checking... + pos = atoi(loc); + len = str - startp - 1; + + /* *loc != '\0', guaranteed by parser */ + if (quotes) { + char *ptr; + + /* We must adjust the length by the number of escapes we find. */ + for (ptr = startp; ptr < (str - 1); ptr++) { + if (*ptr == CTLESC) { + len--; + ptr++; + } + } + } + orig_len = len; + + if (*loc++ == ':') { +// TODO: number() instead? It does error checking... + len = atoi(loc); + } else { + len = orig_len; + while (*loc && *loc != ':') + loc++; + if (*loc++ == ':') +// TODO: number() instead? It does error checking... + len = atoi(loc); + } + if (pos >= orig_len) { + pos = 0; + len = 0; + } + if (len > (orig_len - pos)) + len = orig_len - pos; + + for (str = startp; pos; str++, pos--) { + if (quotes && *str == CTLESC) + str++; + } + for (loc = startp; len; len--) { + if (quotes && *str == CTLESC) + *loc++ = *str++; + *loc++ = *str++; + } + *loc = '\0'; + amount = loc - expdest; + STADJUST(amount, expdest); + return loc; +#endif + case VSQUESTION: varunset(p, str, startp, varflags); /* NOTREACHED */ } + resetloc = expdest - (char *)stackblock(); - subtype -= VSTRIMRIGHT; -#ifdef DEBUG - if (subtype < 0 || subtype > 3) - abort(); -#endif + /* We'll comeback here if we grow the stack while handling + * a VSREPLACE or VSREPLACEALL, since our pointers into the + * stack will need rebasing, and we'll need to remove our work + * areas each time + */ + USE_ASH_BASH_COMPAT(restart:) + + amount = expdest - ((char *)stackblock() + resetloc); + STADJUST(-amount, expdest); + startp = (char *)stackblock() + startloc; rmesc = startp; - rmescend = stackblock() + strloc; + rmescend = (char *)stackblock() + strloc; if (quotes) { rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW); if (rmesc != startp) { rmescend = expdest; - startp = stackblock() + startloc; + startp = (char *)stackblock() + startloc; } } rmescend--; - str = stackblock() + strloc; + str = (char *)stackblock() + strloc; preglob(str, varflags & VSQUOTE, 0); + workloc = expdest - (char *)stackblock(); + +#if ENABLE_ASH_BASH_COMPAT + if (subtype == VSREPLACE || subtype == VSREPLACEALL) { + char *idx, *end, *restart_detect; + + if (!repl) { + repl = parse_sub_pattern(str, varflags & VSQUOTE); + if (!repl) + repl = &null; + } + + /* If there's no pattern to match, return the expansion unmolested */ + if (*str == '\0') + return 0; + + len = 0; + idx = startp; + end = str - 1; + while (idx < end) { + loc = scanright(idx, rmesc, rmescend, str, quotes, 1); + if (!loc) { + /* No match, advance */ + restart_detect = stackblock(); + STPUTC(*idx, expdest); + if (quotes && *idx == CTLESC) { + idx++; + len++; + STPUTC(*idx, expdest); + } + if (stackblock() != restart_detect) + goto restart; + idx++; + len++; + rmesc++; + continue; + } + + if (subtype == VSREPLACEALL) { + while (idx < loc) { + if (quotes && *idx == CTLESC) + idx++; + idx++; + rmesc++; + } + } else { + idx = loc; + } + + for (loc = repl; *loc; loc++) { + restart_detect = stackblock(); + STPUTC(*loc, expdest); + if (stackblock() != restart_detect) + goto restart; + len++; + } + + if (subtype == VSREPLACE) { + while (*idx) { + restart_detect = stackblock(); + STPUTC(*idx, expdest); + if (stackblock() != restart_detect) + goto restart; + len++; + idx++; + } + break; + } + } + + /* We've put the replaced text into a buffer at workloc, now + * move it to the right place and adjust the stack. + */ + startp = stackblock() + startloc; + STPUTC('\0', expdest); + memmove(startp, stackblock() + workloc, len); + startp[len++] = '\0'; + amount = expdest - ((char *)stackblock() + startloc + len - 1); + STADJUST(-amount, expdest); + return startp; + } +#endif /* ENABLE_ASH_BASH_COMPAT */ + subtype -= VSTRIMRIGHT; +#if DEBUG + if (subtype < 0 || subtype > 7) + abort(); +#endif /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */ zero = subtype >> 1; /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */ @@ -5121,77 +6281,189 @@ subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varfla return loc; } +/* + * Add the value of a specialized variable to the stack string. + */ +static ssize_t +varvalue(char *name, int varflags, int flags, struct strlist *var_str_list) +{ + int num; + const char *p; + int i; + int sep = 0; + int sepq = 0; + ssize_t len = 0; + char **ap; + int syntax; + int quoted = varflags & VSQUOTE; + int subtype = varflags & VSTYPE; + int quotes = flags & (EXP_FULL | EXP_CASE); + + if (quoted && (flags & EXP_FULL)) + sep = 1 << CHAR_BIT; + + syntax = quoted ? DQSYNTAX : BASESYNTAX; + switch (*name) { + case '$': + num = rootpid; + goto numvar; + case '?': + num = exitstatus; + goto numvar; + case '#': + num = shellparam.nparam; + goto numvar; + case '!': + num = backgndpid; + if (num == 0) + return -1; + numvar: + len = cvtnum(num); + break; + case '-': + expdest = makestrspace(NOPTS, expdest); + for (i = NOPTS - 1; i >= 0; i--) { + if (optlist[i]) { + USTPUTC(optletters(i), expdest); + len++; + } + } + break; + case '@': + if (sep) + goto param; + /* fall through */ + case '*': + sep = ifsset() ? signed_char2int(ifsval()[0]) : ' '; + if (quotes && (SIT(sep, syntax) == CCTL || SIT(sep, syntax) == CBACK)) + sepq = 1; + param: + ap = shellparam.p; + if (!ap) + return -1; + while ((p = *ap++)) { + size_t partlen; + + partlen = strlen(p); + len += partlen; + + if (!(subtype == VSPLUS || subtype == VSLENGTH)) + memtodest(p, partlen, syntax, quotes); + + if (*ap && sep) { + char *q; + + len++; + if (subtype == VSPLUS || subtype == VSLENGTH) { + continue; + } + q = expdest; + if (sepq) + STPUTC(CTLESC, q); + STPUTC(sep, q); + expdest = q; + } + } + return len; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': +// TODO: number() instead? It does error checking... + num = atoi(name); + if (num < 0 || num > shellparam.nparam) + return -1; + p = num ? shellparam.p[num - 1] : arg0; + goto value; + default: + /* NB: name has form "VAR=..." */ + + /* "A=a B=$A" case: var_str_list is a list of "A=a" strings + * which should be considered before we check variables. */ + if (var_str_list) { + unsigned name_len = (strchrnul(name, '=') - name) + 1; + p = NULL; + do { + char *str, *eq; + str = var_str_list->text; + eq = strchr(str, '='); + if (!eq) /* stop at first non-assignment */ + break; + eq++; + if (name_len == (unsigned)(eq - str) + && strncmp(str, name, name_len) == 0) { + p = eq; + /* goto value; - WRONG! */ + /* think "A=1 A=2 B=$A" */ + } + var_str_list = var_str_list->next; + } while (var_str_list); + if (p) + goto value; + } + p = lookupvar(name); + value: + if (!p) + return -1; + + len = strlen(p); + if (!(subtype == VSPLUS || subtype == VSLENGTH)) + memtodest(p, len, syntax, quotes); + return len; + } + + if (subtype == VSPLUS || subtype == VSLENGTH) + STADJUST(-len, expdest); + return len; +} /* * Expand a variable, and return a pointer to the next character in the * input string. */ static char * -evalvar(char *p, int flag) +evalvar(char *p, int flag, struct strlist *var_str_list) { - int subtype; - int varflags; + char varflags; + char subtype; + char quoted; + char easy; char *var; int patloc; - int c; - int set; int startloc; - size_t varlen; - int easy; - int quotes; - int quoted; + ssize_t varlen; - 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; - } - } - } 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 - ); - } - } + again: + varlen = varvalue(var, varflags, flag, var_str_list); + if (varflags & VSNUL) + varlen--; + if (subtype == VSPLUS) { + varlen = -1 - varlen; + goto vsplus; + } if (subtype == VSMINUS) { -vsplus: - if (!set) { + vsplus: + if (varlen < 0) { argstr( p, flag | EXP_TILDE | - (quoted ? EXP_QWORD : EXP_WORD) + (quoted ? EXP_QWORD : EXP_WORD), + var_str_list ); goto end; } @@ -5201,9 +6473,12 @@ vsplus: } if (subtype == VSASSIGN || subtype == VSQUESTION) { - if (!set) { - if (subevalvar(p, var, 0, subtype, startloc, - varflags, 0)) { + if (varlen < 0) { + if (subevalvar(p, var, /* strloc: */ 0, + subtype, startloc, varflags, + /* quotes: */ 0, + var_str_list) + ) { varflags &= ~VSNUL; /* * Remove any recorded regions beyond @@ -5219,44 +6494,49 @@ vsplus: goto end; } - if (!set && uflag) + if (varlen < 0 && uflag) varunset(p, var, 0, 0); if (subtype == VSLENGTH) { -vslen: - cvtnum(varlen); + cvtnum(varlen > 0 ? varlen : 0); goto record; } if (subtype == VSNORMAL) { - if (!easy) - goto end; -record: - recordregion(startloc, expdest - (char *)stackblock(), quoted); + if (easy) + goto record; goto end; } -#ifdef DEBUG +#if DEBUG switch (subtype) { case VSTRIMLEFT: case VSTRIMLEFTMAX: case VSTRIMRIGHT: case VSTRIMRIGHTMAX: +#if ENABLE_ASH_BASH_COMPAT + case VSSUBSTR: + case VSREPLACE: + case VSREPLACEALL: +#endif break; default: abort(); } #endif - if (set) { + if (varlen >= 0) { /* * 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) { + if (0 == subevalvar(p, /* str: */ NULL, patloc, subtype, + startloc, varflags, + /* quotes: */ flag & (EXP_FULL | EXP_CASE), + var_str_list) + ) { int amount = expdest - ( (char *)stackblock() + patloc - 1 ); @@ -5264,17 +6544,19 @@ record: } /* Remove any recorded regions beyond start of variable */ removerecordregions(startloc); - goto record; + record: + recordregion(startloc, expdest - (char *)stackblock(), quoted); } -end: + end: if (subtype != VSNORMAL) { /* skip to end of alternative */ int nesting = 1; for (;;) { - if ((c = *p++) == CTLESC) + char c = *p++; + if (c == CTLESC) p++; else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) { - if (set) + if (varlen >= 0) argbackq = argbackq->next; } else if (c == CTLVAR) { if ((*p++ & VSTYPE) != VSNORMAL) @@ -5288,183 +6570,6 @@ end: return p; } - - -/* - * Test whether a specialized variable is set. - */ - -static int -varisset(char *name, int nulok) -{ - if (*name == '!') - return backgndpid != 0; - else if (*name == '@' || *name == '*') { - if (*shellparam.p == NULL) - return 0; - - if (nulok) { - char **av; - - for (av = shellparam.p; *av; av++) - if (**av != '\0') - return 1; - return 0; - } - } else if (is_digit(*name)) { - char *ap; - int num = atoi(name); - - if (num > shellparam.nparam) - return 0; - - if (num == 0) - ap = arg0; - else - ap = shellparam.p[num - 1]; - - if (nulok && (ap == NULL || *ap == '\0')) - return 0; - } - return 1; -} - - - -/* - * Put a string on the stack. - */ - -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) -{ - int num; - char *p; - int i; - int sep; - int sepq = 0; - char **ap; - int syntax; - int allow_split = flags & EXP_FULL; - int quotes = flags & (EXP_FULL | EXP_CASE); - - syntax = quoted ? DQSYNTAX : BASESYNTAX; - switch (*name) { - case '$': - num = rootpid; - goto numvar; - case '?': - num = exitstatus; - goto numvar; - case '#': - num = shellparam.nparam; - goto numvar; - case '!': - num = backgndpid; -numvar: - cvtnum(num); - break; - case '-': - for (i = 0 ; i < NOPTS ; i++) { - if (optlist[i]) - STPUTC(optletters(i), expdest); - } - break; - case '@': - if (allow_split && quoted) { - sep = 1 << CHAR_BIT; - goto param; - } - /* fall through */ - case '*': - sep = ifsset() ? ifsval()[0] : ' '; - if (quotes) { - sepq = (SIT(sep, syntax) == CCTL) || (SIT(sep, syntax) == CBACK); - } -param: - for (ap = shellparam.p ; (p = *ap++) != NULL ; ) { - strtodest(p, syntax, quotes); - if (*ap && sep) { - p = expdest; - if (sepq) - STPUTC(CTLESC, p); - STPUTC(sep, p); - expdest = p; - } - } - break; - case '0': - strtodest(arg0, syntax, quotes); - break; - default: - num = atoi(name); - if (num > 0 && num <= shellparam.nparam) { - strtodest(shellparam.p[num - 1], syntax, quotes); - } - break; - } -} - - - -/* - * 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) -{ - struct ifsregion *ifsp; - - if (ifslastp == NULL) { - ifsp = &ifsfirst; - } else { - INTOFF; - ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion)); - ifsp->next = NULL; - ifslastp->next = ifsp; - INTON; - } - ifslastp = ifsp; - ifslastp->begoff = start; - ifslastp->endoff = end; - ifslastp->nulonly = nulonly; -} - - - /* * Break the argument string into pieces based upon IFS and add the * strings to the argument list. The regions of the string to be @@ -5482,7 +6587,6 @@ ifsbreakup(char *string, struct arglist *arglist) int ifsspc; int nulonly; - start = string; if (ifslastp != NULL) { ifsspc = 0; @@ -5498,49 +6602,52 @@ ifsbreakup(char *string, struct arglist *arglist) q = p; if (*p == CTLESC) p++; - if (strchr(ifs, *p)) { - if (!nulonly) - ifsspc = (strchr(defifs, *p) != NULL); - /* Ignore IFS whitespace at start */ - if (q == start && ifsspc) { - p++; - start = p; - continue; - } - *q = '\0'; - sp = (struct strlist *)stalloc(sizeof *sp); - sp->text = start; - *arglist->lastp = sp; - arglist->lastp = &sp->next; + if (!strchr(ifs, *p)) { p++; - if (!nulonly) { - for (;;) { - if (p >= string + ifsp->endoff) { - break; - } - q = p; - if (*p == CTLESC) + continue; + } + if (!nulonly) + ifsspc = (strchr(defifs, *p) != NULL); + /* Ignore IFS whitespace at start */ + if (q == start && ifsspc) { + p++; + start = p; + continue; + } + *q = '\0'; + sp = stzalloc(sizeof(*sp)); + sp->text = start; + *arglist->lastp = sp; + arglist->lastp = &sp->next; + p++; + if (!nulonly) { + for (;;) { + if (p >= string + ifsp->endoff) { + break; + } + q = p; + if (*p == CTLESC) + p++; + if (strchr(ifs, *p) == NULL) { + p = q; + break; + } + if (strchr(defifs, *p) == NULL) { + if (ifsspc) { p++; - if (strchr(ifs, *p) == NULL ) { + ifsspc = 0; + } else { p = q; break; - } else if (strchr(defifs, *p) == NULL) { - if (ifsspc) { - p++; - ifsspc = 0; - } else { - p = q; - break; - } - } else - p++; - } + } + } else + p++; } - start = p; - } else - p++; - } - } while ((ifsp = ifsp->next) != NULL); + } + start = p; + } /* while */ + ifsp = ifsp->next; + } while (ifsp != NULL); if (nulonly) goto add; } @@ -5548,8 +6655,8 @@ ifsbreakup(char *string, struct arglist *arglist) if (!*start) return; -add: - sp = (struct strlist *)stalloc(sizeof *sp); + add: + sp = stzalloc(sizeof(*sp)); sp->text = start; *arglist->lastp = sp; arglist->lastp = &sp->next; @@ -5560,188 +6667,335 @@ ifsfree(void) { struct ifsregion *p; - INTOFF; + INT_OFF; p = ifsfirst.next; do { struct ifsregion *ifsp; ifsp = p->next; - ckfree(p); + free(p); p = ifsp; } while (p); ifslastp = NULL; ifsfirst.next = NULL; - INTON; + INT_ON; } +/* + * Add a file name to the list. + */ +static void +addfname(const char *name) +{ + struct strlist *sp; + + sp = stzalloc(sizeof(*sp)); + sp->text = ststrdup(name); + *exparg.lastp = sp; + exparg.lastp = &sp->next; +} +static char *expdir; /* - * Expand shell metacharacters. At this point, the only control characters - * should be escapes. The results are stored in the list exparg. + * Do metacharacter (i.e. *, ?, [...]) expansion. */ +static void +expmeta(char *enddir, char *name) +{ + char *p; + const char *cp; + 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; p++) { + if (*p == '*' || *p == '?') + metaflag = 1; + else if (*p == '[') { + char *q = p + 1; + if (*q == '!') + q++; + for (;;) { + if (*q == '\\') + q++; + if (*q == '/' || *q == '\0') + break; + if (*++q == ']') { + metaflag = 1; + break; + } + } + } else if (*p == '\\') + p++; + else if (*p == '/') { + if (metaflag) + goto out; + start = p + 1; + } + } + out: + if (metaflag == 0) { /* we've reached the end of the file name */ + if (enddir != expdir) + metaflag++; + p = name; + do { + if (*p == '\\') + p++; + *enddir++ = *p; + } while (*p++); + if (metaflag == 0 || lstat(expdir, &statb) >= 0) + addfname(expdir); + return; + } + endname = p; + if (name < start) { + p = name; + do { + if (*p == '\\') + p++; + *enddir++ = *p++; + } while (p < start); + } + if (enddir == expdir) { + cp = "."; + } else if (enddir == expdir + 1 && *expdir == '/') { + cp = "/"; + } else { + cp = expdir; + enddir[-1] = '\0'; + } + dirp = opendir(cp); + if (dirp == NULL) + return; + if (enddir != expdir) + enddir[-1] = '/'; + if (*endname == 0) { + atend = 1; + } else { + atend = 0; + *endname++ = '\0'; + } + matchdot = 0; + p = start; + if (*p == '\\') + p++; + if (*p == '.') + matchdot++; + while (!intpending && (dp = readdir(dirp)) != NULL) { + if (dp->d_name[0] == '.' && !matchdot) + continue; + if (pmatch(start, dp->d_name)) { + 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] = '/'; +} + +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 ENABLE_LOCALE_SUPPORT + if (strcoll(p->text, q->text) < 0) +#else + if (strcmp(p->text, q->text) < 0) +#endif + { + *lpp = p; + lpp = &p->next; + p = *lpp; + if (p == NULL) { + *lpp = q; + break; + } + } else { + *lpp = q; + lpp = &q->next; + q = *lpp; + if (q == NULL) { + *lpp = p; + break; + } + } + } + return list; +} + +/* + * 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. + */ +static struct strlist * +expsort(struct strlist *str) +{ + int len; + struct strlist *sp; + + len = 0; + for (sp = str; sp; sp = sp->next) + len++; + return msort(str, len); +} static void -expandmeta(str, flag) - struct strlist *str; - int flag; +expandmeta(struct strlist *str /*, int flag*/) { + static const char metachars[] ALIGN1 = { + '*', '?', '[', 0 + }; /* TODO - EXP_REDIR */ while (str) { - const char *p; - glob_t pglob; - int i; + struct strlist **savelastp; + struct strlist *sp; + char *p; if (fflag) goto nometa; - INTOFF; + if (!strpbrk(str->text, metachars)) + goto nometa; + savelastp = exparg.lastp; + + INT_OFF; p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP); - i = glob(p, GLOB_NOMAGIC, 0, &pglob); + { + int i = strlen(str->text); + expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */ + } + + expmeta(expdir, p); + free(expdir); if (p != str->text) - ckfree(p); - switch (i) { - case 0: - if (!(pglob.gl_flags & GLOB_MAGCHAR)) - goto nometa2; - addglob(&pglob); - globfree(&pglob); - INTON; - break; - case GLOB_NOMATCH: -nometa2: - globfree(&pglob); - INTON; -nometa: + free(p); + INT_ON; + if (exparg.lastp == savelastp) { + /* + * no matches + */ + nometa: *exparg.lastp = str; rmescapes(str->text); exparg.lastp = &str->next; - break; - default: /* GLOB_NOSPACE */ - error(bb_msg_memory_exhausted); + } else { + *exparg.lastp = NULL; + *savelastp = sp = expsort(*savelastp); + while (sp->next != NULL) + sp = sp->next; + exparg.lastp = &sp->next; } str = str->next; } } - /* - * Add the result of glob(3) to the list. + * Perform variable substitution and command substitution on an argument, + * placing the resulting list of arguments in arglist. If EXP_FULL is true, + * perform splitting and file name expansion. When arglist is NULL, perform + * here document expansion. */ - static void -addglob(pglob) - const glob_t *pglob; +expandarg(union node *arg, struct arglist *arglist, int flag) { - char **p = pglob->gl_pathv; + struct strlist *sp; + char *p; - do { - addfname(*p); - } while (*++p); + argbackq = arg->narg.backquote; + STARTSTACKSTR(expdest); + ifsfirst.next = NULL; + ifslastp = NULL; + argstr(arg->narg.text, flag, + /* var_str_list: */ arglist ? arglist->list : NULL); + p = _STPUTC('\0', expdest); + expdest = p - 1; + if (arglist == NULL) { + return; /* here document expanded */ + } + p = grabstackstr(p); + exparg.lastp = &exparg.list; + /* + * TODO - EXP_REDIR + */ + if (flag & EXP_FULL) { + ifsbreakup(p, &exparg); + *exparg.lastp = NULL; + exparg.lastp = &exparg.list; + expandmeta(exparg.list /*, flag*/); + } else { + if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */ + rmescapes(p); + sp = stzalloc(sizeof(*sp)); + sp->text = p; + *exparg.lastp = sp; + exparg.lastp = &sp->next; + } + if (ifsfirst.next) + ifsfree(); + *exparg.lastp = NULL; + if (exparg.list) { + *arglist->lastp = exparg.list; + arglist->lastp = exparg.lastp; + } } - /* - * Add a file name to the list. + * Expand shell variables and backquotes inside a here document. */ - static void -addfname(char *name) +expandhere(union node *arg, int fd) { - struct strlist *sp; - - sp = (struct strlist *)stalloc(sizeof *sp); - sp->text = sstrdup(name); - *exparg.lastp = sp; - exparg.lastp = &sp->next; + herefd = fd; + expandarg(arg, (struct arglist *)NULL, 0); + full_write(fd, stackblock(), expdest - (char *)stackblock()); } - /* * Returns true if the pattern matches the string. */ - -static inline int +static int patmatch(char *pattern, const char *string) { return pmatch(preglob(pattern, 0, 0), string); } - -/* - * Remove any CTLESC characters from a string. - */ - -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) { - return str; - } - q = p; - r = str; - if (flag & RMESCAPE_ALLOC) { - size_t len = p - str; - size_t fulllen = len + strlen(p) + 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) { - 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 (notescaped && inquotes && *p != '/') { - *q++ = '\\'; - } - } - notescaped = globbing; -copy: - *q++ = *p++; - } - *q = '\0'; - if (flag & RMESCAPE_GROW) { - expdest = r; - STADJUST(q - r + 1, expdest); - } - return r; -} - - - /* * See if a pattern matches in a case statement. */ - -int +static int casematch(union node *pattern, char *val) { struct stackmark smark; @@ -5751,2982 +7005,2833 @@ casematch(union node *pattern, char *val) argbackq = pattern->narg.backquote; STARTSTACKSTR(expdest); ifslastp = NULL; - argstr(pattern->narg.text, EXP_TILDE | EXP_CASE); + argstr(pattern->narg.text, EXP_TILDE | EXP_CASE, + /* var_str_list: */ NULL); STACKSTRNUL(expdest); result = patmatch(stackblock(), val); popstackmark(&smark); return result; } -/* - * Our own itoa(). - */ -static int -cvtnum(long num) -{ - int len; +/* ============ find_command */ - expdest = makestrspace(32, expdest); - len = fmtstr(expdest, 32, "%ld", num); - STADJUST(len, expdest); - return len; -} +struct builtincmd { + const char *name; + int (*builtin)(int, char **); + /* unsigned flags; */ +}; +#define IS_BUILTIN_SPECIAL(b) ((b)->name[0] & 1) +/* "regular" builtins always take precedence over commands, + * regardless of PATH=....%builtin... position */ +#define IS_BUILTIN_REGULAR(b) ((b)->name[0] & 2) +#define IS_BUILTIN_ASSIGN(b) ((b)->name[0] & 4) -static void -varunset(const char *end, const char *var, const char *umsg, int varflags) -{ - const char *msg; - const char *tail; +struct cmdentry { + smallint cmdtype; /* CMDxxx */ + union param { + int index; + /* index >= 0 for commands without path (slashes) */ + /* (TODO: what exactly does the value mean? PATH position?) */ + /* index == -1 for commands with slashes */ + /* index == (-2 - applet_no) for NOFORK applets */ + const struct builtincmd *cmd; + struct funcnode *func; + } u; +}; +/* values of cmdtype */ +#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 */ - 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 $ */ +/* 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 void find_command(char *, struct cmdentry *, int, const char *); +/* ============ Hashing commands */ /* - * This file implements the input routines used by the parser. + * 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 EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */ -#define IBUFSIZ (BUFSIZ + 1) +struct tblentry { + struct tblentry *next; /* next entry in hash chain */ + union param param; /* definition of builtin function */ + smallint cmdtype; /* CMDxxx */ + char rehash; /* if set, cd done since entry created */ + char cmdname[1]; /* name of command */ +}; -static void pushfile(void); +static struct tblentry **cmdtable; +#define INIT_G_cmdtable() do { \ + cmdtable = xzalloc(CMDTABLESIZE * sizeof(cmdtable[0])); \ +} while (0) -/* - * Read a line from the script. - */ +static int builtinloc = -1; /* index in path of %builtin, or -1 */ -static inline char * -pfgets(char *line, int len) + +static void +tryexec(USE_FEATURE_SH_STANDALONE(int applet_no,) char *cmd, char **argv, char **envp) { - char *p = line; - int nleft = len; - int c; + int repeated = 0; - while (--nleft > 0) { - c = pgetc2(); - if (c == PEOF) { - if (p == line) - return NULL; - break; +#if ENABLE_FEATURE_SH_STANDALONE + if (applet_no >= 0) { + if (APPLET_IS_NOEXEC(applet_no)) { + while (*envp) + putenv(*envp++); + run_applet_no_and_exit(applet_no, argv); } - *p++ = c; - if (c == '\n') - break; + /* re-exec ourselves with the new arguments */ + execve(bb_busybox_exec_path, argv, envp); + /* If they called chroot or otherwise made the binary no longer + * executable, fall through */ } - *p = '\0'; - return line; -} - - -/* - * Read a character from the script, returning PEOF on end of file. - * Nul characters in the input are silently discarded. - */ - -#define pgetc_as_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer()) +#endif -#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE -#define pgetc_macro() pgetc() -static int -pgetc(void) -{ - return pgetc_as_macro(); -} + repeat: +#ifdef SYSV + do { + execve(cmd, argv, envp); + } while (errno == EINTR); #else -#define pgetc_macro() pgetc_as_macro() -static int -pgetc(void) -{ - return pgetc_macro(); -} + execve(cmd, argv, envp); #endif + if (repeated) { + free(argv); + return; + } + if (errno == ENOEXEC) { + char **ap; + char **new; + for (ap = argv; *ap; ap++) + continue; + ap = new = ckmalloc((ap - argv + 2) * sizeof(ap[0])); + ap[1] = cmd; + ap[0] = cmd = (char *)DEFAULT_SHELL; + ap += 2; + argv++; + while ((*ap++ = *argv++) != NULL) + continue; + argv = new; + repeated++; + goto repeat; + } +} /* - * Same as pgetc(), but ignores PEOA. + * Exec a program. Never returns. If you change this routine, you may + * have to change the find_command routine as well. */ -#ifdef CONFIG_ASH_ALIAS -static int pgetc2(void) -{ - int c; - - do { - c = pgetc_macro(); - } while (c == PEOA); - return c; -} -#else -static inline int pgetc2(void) +static void shellexec(char **, const char *, int) NORETURN; +static void +shellexec(char **argv, const char *path, int idx) { - return pgetc_macro(); -} + char *cmdname; + int e; + char **envp; + int exerrno; +#if ENABLE_FEATURE_SH_STANDALONE + int applet_no = -1; #endif + clearredir(/*drop:*/ 1); + envp = listvars(VEXPORT, VUNSET, 0); + if (strchr(argv[0], '/') != NULL +#if ENABLE_FEATURE_SH_STANDALONE + || (applet_no = find_applet_by_name(argv[0])) >= 0 +#endif + ) { + tryexec(USE_FEATURE_SH_STANDALONE(applet_no,) argv[0], argv, envp); + e = errno; + } else { + e = ENOENT; + while ((cmdname = padvance(&path, argv[0])) != NULL) { + if (--idx < 0 && pathopt == NULL) { + tryexec(USE_FEATURE_SH_STANDALONE(-1,) cmdname, argv, envp); + if (errno != ENOENT && errno != ENOTDIR) + e = errno; + } + stunalloc(cmdname); + } + } -#ifdef CONFIG_FEATURE_COMMAND_EDITING -static const char *cmdedit_prompt; -static inline void putprompt(const char *s) -{ - cmdedit_prompt = s; + /* Map to POSIX errors */ + switch (e) { + case EACCES: + exerrno = 126; + break; + case ENOENT: + exerrno = 127; + break; + default: + exerrno = 2; + break; + } + exitstatus = exerrno; + TRACE(("shellexec failed for %s, errno %d, suppressint %d\n", + argv[0], e, suppressint)); + ash_msg_and_raise(EXEXEC, "%s: %s", argv[0], errmsg(e, "not found")); + /* NOTREACHED */ } -#else -static inline void putprompt(const char *s) + +static void +printentry(struct tblentry *cmdp) { - out2str(s); + int idx; + const char *path; + char *name; + + idx = cmdp->param.index; + path = pathval(); + do { + name = padvance(&path, cmdp->cmdname); + stunalloc(name); + } while (--idx >= 0); + out1fmt("%s%s\n", name, (cmdp->rehash ? "*" : nullstr)); } -#endif -static inline int -preadfd(void) +/* + * Clear out command entries. The argument specifies the first entry in + * PATH which has changed. + */ +static void +clearcmdentry(int firstchange) { - int nr; - char *buf = parsefile->buf; - parsenextc = buf; - -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(nr == 0) { - /* Ctrl+C presend */ - raise(SIGINT); - goto retry; - } - if(nr < 0) { - /* Ctrl+D presend */ - nr = 0; - } - } -#else - nr = safe_read(parsefile->fd, buf, BUFSIZ - 1); -#endif + struct tblentry **tblp; + struct tblentry **pp; + struct tblentry *cmdp; - 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; - if (fcntl(0, F_SETFL, flags) >= 0) { - out2str("sh: turning off NDELAY mode\n"); - goto retry; - } + INT_OFF; + 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) + ) { + *pp = cmdp->next; + free(cmdp); + } else { + pp = &cmdp->next; } } } - return nr; + INT_ON; } /* - * Refill the input buffer and return the next input character: + * 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. * - * 1) If a string was pushed back on the input, pop it; - * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading - * from a string so we can't refill the buffer, return EOF. - * 3) If the is more stuff in this buffer, use it else call read to fill it. - * 4) Process input up to the next newline, deleting nul characters. + * Interrupts must be off if called with add != 0. */ +static struct tblentry **lastcmdentry; -int -preadbuffer(void) +static struct tblentry * +cmdlookup(const char *name, int add) { - char *p, *q; - int more; - char savec; - - while (parsefile->strpush) { -#ifdef CONFIG_ASH_ALIAS - if (parsenleft == -1 && parsefile->strpush->ap && - parsenextc[-1] != ' ' && parsenextc[-1] != '\t') { - return PEOA; - } -#endif - popstring(); - if (--parsenleft >= 0) - return (*parsenextc++); - } - if (parsenleft == EOF_NLEFT || parsefile->buf == NULL) - return PEOF; - flushall(); - -again: - if (parselleft <= 0) { - if ((parselleft = preadfd()) <= 0) { - parselleft = parsenleft = EOF_NLEFT; - return PEOF; - } - } - - q = p = parsenextc; - - /* delete nul characters */ - for (more = 1; more;) { - switch (*p) { - case '\0': - p++; /* Skip nul */ - goto check; + unsigned int hashval; + const char *p; + struct tblentry *cmdp; + struct tblentry **pp; - case '\n': - parsenleft = q - parsenextc; - more = 0; /* Stop processing here */ + p = name; + hashval = (unsigned char)*p << 4; + while (*p) + hashval += (unsigned char)*p++; + hashval &= 0x7FFF; + pp = &cmdtable[hashval % CMDTABLESIZE]; + for (cmdp = *pp; cmdp; cmdp = cmdp->next) { + if (strcmp(cmdp->cmdname, name) == 0) break; - - } - - *q++ = *p++; -check: - if (--parselleft <= 0 && more) { - parsenleft = q - parsenextc - 1; - if (parsenleft < 0) - goto again; - more = 0; - } + pp = &cmdp->next; } - - savec = *q; - *q = '\0'; - - if (vflag) { - out2str(parsenextc); - flushout(stderr); + if (add && cmdp == NULL) { + cmdp = *pp = ckzalloc(sizeof(struct tblentry) + + strlen(name) + /* + 1 - already done because + * tblentry::cmdname is char[1] */); + /*cmdp->next = NULL; - ckzalloc did it */ + cmdp->cmdtype = CMDUNKNOWN; + strcpy(cmdp->cmdname, name); } - - *q = savec; - - return *parsenextc++; + lastcmdentry = pp; + return cmdp; } /* - * Undo the last call to pgetc. Only one character may be pushed back. - * PEOF may be pushed back. + * Delete the command entry returned on the last lookup. */ - -void -pungetc(void) +static void +delete_cmd_entry(void) { - parsenleft++; - parsenextc--; + struct tblentry *cmdp; + + INT_OFF; + cmdp = *lastcmdentry; + *lastcmdentry = cmdp->next; + if (cmdp->cmdtype == CMDFUNCTION) + freefunc(cmdp->param.func); + free(cmdp); + INT_ON; } /* - * Push a string back onto the input at this current parsefile level. - * We handle aliases this way. + * Add a new command entry, replacing any existing command entry for + * the same name - except special builtins. */ -void -pushstring(char *s, void *ap) +static void +addcmdentry(char *name, struct cmdentry *entry) { - struct strpush *sp; - size_t len; + struct tblentry *cmdp; - len = strlen(s); - INTOFF; -/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/ - if (parsefile->strpush) { - sp = ckmalloc(sizeof (struct strpush)); - sp->prev = parsefile->strpush; - parsefile->strpush = sp; - } else - sp = parsefile->strpush = &(parsefile->basestrpush); - sp->prevstring = parsenextc; - sp->prevnleft = parsenleft; -#ifdef CONFIG_ASH_ALIAS - sp->ap = (struct alias *)ap; - if (ap) { - ((struct alias *)ap)->flag |= ALIASINUSE; - sp->string = s; + cmdp = cmdlookup(name, 1); + if (cmdp->cmdtype == CMDFUNCTION) { + freefunc(cmdp->param.func); } -#endif - parsenextc = s; - parsenleft = len; - INTON; + cmdp->cmdtype = entry->cmdtype; + cmdp->param = entry->u; + cmdp->rehash = 0; } -void -popstring(void) +static int +hashcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { - struct strpush *sp = parsefile->strpush; + struct tblentry **pp; + struct tblentry *cmdp; + int c; + struct cmdentry entry; + char *name; - 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); + if (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 == CMDNORMAL) + printentry(cmdp); + } } - sp->ap->flag &= ~ALIASINUSE; - if (sp->ap->flag & ALIASDEAD) { - unalias(sp->ap->name); + return 0; + } + + c = 0; + while ((name = *argptr) != NULL) { + cmdp = cmdlookup(name, 0); + if (cmdp != NULL + && (cmdp->cmdtype == CMDNORMAL + || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)) + ) { + delete_cmd_entry(); } + find_command(name, &entry, DO_ERR, pathval()); + if (entry.cmdtype == CMDUNKNOWN) + c = 1; + argptr++; } -#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; + return c; } /* - * Set the input to take input from a file. If push is set, push the - * old input onto the stack first. + * Called when a cd is done. Marks all commands so the next time they + * are executed they will be rehashed. */ - -void -setinputfile(const char *fname, int push) +static void +hashcd(void) { - int fd; - int fd2; + struct tblentry **pp; + struct tblentry *cmdp; - 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; + 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; + } + } } - setinputfd(fd, push); - INTON; } - /* - * Like setinputfile, but takes an open file descriptor. Call this with - * interrupts off. + * 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. */ - static void -setinputfd(int fd, int push) +changepath(const char *new) { - (void) fcntl(fd, F_SETFD, FD_CLOEXEC); - if (push) { - pushfile(); - parsefile->buf = 0; + const char *old; + int firstchange; + int idx; + int idx_bltin; + + old = pathval(); + 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++; } - parsefile->fd = fd; - if (parsefile->buf == NULL) - parsefile->buf = ckmalloc(IBUFSIZ); - parselleft = parsenleft = 0; - plinno = 1; + if (builtinloc < 0 && idx_bltin >= 0) + builtinloc = idx_bltin; /* zap builtins */ + if (builtinloc >= 0 && idx_bltin < 0) + firstchange = 0; + clearcmdentry(firstchange); + builtinloc = idx_bltin; } +#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 +typedef smallint token_id_t; -/* - * Like setinputfile, but takes input from a string. - */ +/* 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 void -setinputstring(char *string) +static const char * +tokname(int tok) { - INTOFF; - pushfile(); - parsenextc = string; - parsenleft = strlen(string); - parsefile->buf = NULL; - plinno = 1; - INTON; -} - - - -/* - * To handle the "." command, a stack of input files is used. Pushfile - * adds a new entry to the stack and popfile restores the previous level. - */ + static char buf[16]; -static void -pushfile(void) -{ - struct parsefile *pf; +//try this: +//if (tok < TSEMI) return tokname_array[tok] + 1; +//sprintf(buf, "\"%s\"", tokname_array[tok] + 1); +//return buf; - parsefile->nleft = parsenleft; - parsefile->lleft = parselleft; - parsefile->nextc = parsenextc; - parsefile->linno = plinno; - pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile)); - pf->prev = parsefile; - pf->fd = -1; - pf->strpush = NULL; - pf->basestrpush.prev = NULL; - parsefile = pf; + if (tok >= TSEMI) + buf[0] = '"'; + sprintf(buf + (tok >= TSEMI), "%s%c", + tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0)); + return buf; } - -static void -popfile(void) +/* Wrapper around strcmp for qsort/bsearch/... */ +static int +pstrcmp(const void *a, const void *b) { - 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; + return strcmp((char*) a, (*(char**) b) + 1); } - -/* - * Return to top level. - */ - -static void -popallfiles(void) +static const char *const * +findkwd(const char *s) { - while (parsefile != &basepf) - popfile(); + return bsearch(s, tokname_array + KWDOFFSET, + ARRAY_SIZE(tokname_array) - KWDOFFSET, + sizeof(tokname_array[0]), pstrcmp); } - - /* - * Close the file(s) that the shell is reading commands from. Called - * after a fork is done. + * Locate and print what a word is... */ - -static void -closescript(void) +static int +describe_command(char *command, int describe_command_verbose) { - 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; + struct cmdentry entry; + struct tblentry *cmdp; +#if ENABLE_ASH_ALIAS + const struct alias *ap; #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; + const char *path = pathval(); - /* 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 (describe_command_verbose) { + out1str(command); } -} - -#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. - */ - -void -setjobctl(int on) -{ - int fd; - int pgrp; - if (on == jobctl || rootshell == 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 (pgrp == getpgrp()) - break; - killpg(0, SIGTTIN); - } while (1); - initialpgrp = pgrp; - - setsignal(SIGTSTP); - setsignal(SIGTTOU); - setsignal(SIGTTIN); - 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; + /* First look at the keywords */ + if (findkwd(command)) { + out1str(describe_command_verbose ? " is a shell keyword" : command); + goto out; } - ttyfd = fd; - jobctl = on; -} -static int -killcmd(argc, argv) - int argc; - char **argv; -{ - int signo = -1; - int list = 0; - int i; - pid_t pid; - struct job *jp; - - if (argc <= 1) { -usage: - error( -"Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n" -"kill -l [exitstatus]" - ); +#if ENABLE_ASH_ALIAS + /* Then look at the aliases */ + ap = lookupalias(command, 0); + if (ap != NULL) { + if (!describe_command_verbose) { + out1str("alias "); + printalias(ap); + return 0; + } + out1fmt(" is an alias for %s", ap->val); + goto out; } - - 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 - ); - } - break; - } - argv = argptr; - } else - argv++; - } - - if (!list && signo < 0) - signo = SIGTERM; - - if ((signo < 0 || !*argv) ^ list) { - goto usage; + /* Then check if it is a tracked alias */ + cmdp = cmdlookup(command, 0); + if (cmdp != NULL) { + entry.cmdtype = cmdp->cmdtype; + entry.u = cmdp->param; + } else { + /* Finally use brute force */ + find_command(command, &entry, DO_ABS, path); } - if (list) { - const char *name; - - if (!*argv) { - for (i = 1; i < NSIG; i++) { - name = u_signal_names(0, &i, 1); - if (name) - out1fmt(snlfmt, name); - } - return 0; + switch (entry.cmdtype) { + case CMDNORMAL: { + int j = entry.u.index; + char *p; + if (j < 0) { + p = command; + } else { + do { + p = padvance(&path, command); + stunalloc(p); + } while (--j >= 0); } - name = u_signal_names(*argptr, &signo, -1); - if (name) - out1fmt(snlfmt, name); - else - error("invalid signal number or exit status: %s", *argptr); - return 0; + if (describe_command_verbose) { + out1fmt(" is%s %s", + (cmdp ? " a tracked alias for" : nullstr), p + ); + } else { + out1str(p); + } + break; } - i = 0; - do { - if (**argv == '%') { - jp = getjob(*argv, 0); - pid = -jp->ps[0].pid; - } else - pid = number(*argv); - if (kill(pid, signo) != 0) { - sh_warnx("%m\n"); - i = 1; + case CMDFUNCTION: + if (describe_command_verbose) { + out1str(" is a shell function"); + } else { + out1str(command); } - } while (*++argv); - - return i; -} -#endif /* JOBS */ - -#if defined(JOBS) || defined(DEBUG) -static int -jobno(const struct job *jp) -{ - return jp - jobtab + 1; -} -#endif + break; -#ifdef JOBS -static int -fgcmd(int argc, char **argv) -{ - struct job *jp; - FILE *out; - int mode; - int retval; + case CMDBUILTIN: + if (describe_command_verbose) { + out1fmt(" is a %sshell builtin", + IS_BUILTIN_SPECIAL(entry.u.cmd) ? + "special " : nullstr + ); + } else { + out1str(command); + } + break; - mode = (**argv == 'f') ? FORK_FG : FORK_BG; - nextopt(nullstr); - argv = argptr; - out = stdout; - do { - jp = getjob(*argv, 1); - if (mode == FORK_BG) { - set_curjob(jp, CUR_RUNNING); - fprintf(out, "[%d] ", jobno(jp)); + default: + if (describe_command_verbose) { + out1str(": not found\n"); } - outstr(jp->ps->cmd, out); - showpipe(jp, out); - retval = restartjob(jp, mode); - } while (*argv && *++argv); - return retval; + return 127; + } + out: + outstr("\n", stdout); + return 0; } -static int bgcmd(int, char **) __attribute__((__alias__("fgcmd"))); - - static int -restartjob(struct job *jp, int mode) +typecmd(int argc UNUSED_PARAM, char **argv) { - struct procstat *ps; - int i; - int status; - pid_t pgid; + int i = 1; + int err = 0; + int verbose = 1; - INTOFF; - 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; - } - } while (ps++, --i); -out: - status = (mode == FORK_FG) ? waitforjob(jp) : 0; - INTON; - return status; + /* type -p ... ? (we don't bother checking for 'p') */ + if (argv[1] && argv[1][0] == '-') { + i++; + verbose = 0; + } + while (argv[i]) { + err |= describe_command(argv[i++], verbose); + } + return err; } -#endif +#if ENABLE_ASH_CMDCMD static int -sprint_status(char *s, int status, int sigonly) +commandcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { - int col; - int st; + int c; + enum { + VERIFY_BRIEF = 1, + VERIFY_VERBOSE = 2, + } verify = 0; - col = 0; - st = WEXITSTATUS(status); - if (!WIFEXITED(status)) { - st = WSTOPSIG(status); -#if JOBS - if (!WIFSTOPPED(status)) - st = WTERMSIG(status); + while ((c = nextopt("pvV")) != '\0') + if (c == 'V') + verify |= VERIFY_VERBOSE; + else if (c == 'v') + verify |= VERIFY_BRIEF; +#if DEBUG + else if (c != 'p') + abort(); #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"); + /* Mimic bash: just "command -v" doesn't complain, it's a nop */ + if (verify && (*argptr != NULL)) { + return describe_command(*argptr, verify - VERIFY_BRIEF); } -out: - return col; + return 0; } +#endif -#if JOBS -static void -showjob(FILE *out, struct job *jp, int mode) -{ - struct procstat *ps; - struct procstat *psend; - int col; - int indent; - char s[80]; - ps = jp->ps; +/* ============ eval.c */ - if (mode & SHOW_PGID) { - /* just output process (group) id of pipeline */ - fprintf(out, "%d\n", ps->pid); - return; - } +static int funcblocksize; /* size of structures in function */ +static int funcstringsize; /* size of strings in node */ +static void *funcblock; /* block to allocate function from */ +static char *funcstring; /* block to allocate strings from */ - col = fmtstr(s, 16, "[%d] ", jobno(jp)); - indent = col; +/* 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 */ - if (jp == curjob) - s[col - 2] = '+'; - else if (curjob && jp == curjob->prev_job) - s[col - 2] = '-'; +static const short nodesize[N_NUMBER] = { + [NCMD ] = SHELL_ALIGN(sizeof(struct ncmd)), + [NPIPE ] = SHELL_ALIGN(sizeof(struct npipe)), + [NREDIR ] = SHELL_ALIGN(sizeof(struct nredir)), + [NBACKGND ] = SHELL_ALIGN(sizeof(struct nredir)), + [NSUBSHELL] = SHELL_ALIGN(sizeof(struct nredir)), + [NAND ] = SHELL_ALIGN(sizeof(struct nbinary)), + [NOR ] = SHELL_ALIGN(sizeof(struct nbinary)), + [NSEMI ] = SHELL_ALIGN(sizeof(struct nbinary)), + [NIF ] = SHELL_ALIGN(sizeof(struct nif)), + [NWHILE ] = SHELL_ALIGN(sizeof(struct nbinary)), + [NUNTIL ] = SHELL_ALIGN(sizeof(struct nbinary)), + [NFOR ] = SHELL_ALIGN(sizeof(struct nfor)), + [NCASE ] = SHELL_ALIGN(sizeof(struct ncase)), + [NCLIST ] = SHELL_ALIGN(sizeof(struct nclist)), + [NDEFUN ] = SHELL_ALIGN(sizeof(struct narg)), + [NARG ] = SHELL_ALIGN(sizeof(struct narg)), + [NTO ] = SHELL_ALIGN(sizeof(struct nfile)), +#if ENABLE_ASH_BASH_COMPAT + [NTO2 ] = SHELL_ALIGN(sizeof(struct nfile)), +#endif + [NCLOBBER ] = SHELL_ALIGN(sizeof(struct nfile)), + [NFROM ] = SHELL_ALIGN(sizeof(struct nfile)), + [NFROMTO ] = SHELL_ALIGN(sizeof(struct nfile)), + [NAPPEND ] = SHELL_ALIGN(sizeof(struct nfile)), + [NTOFD ] = SHELL_ALIGN(sizeof(struct ndup)), + [NFROMFD ] = SHELL_ALIGN(sizeof(struct ndup)), + [NHERE ] = SHELL_ALIGN(sizeof(struct nhere)), + [NXHERE ] = SHELL_ALIGN(sizeof(struct nhere)), + [NNOT ] = SHELL_ALIGN(sizeof(struct nnot)), +}; - if (mode & SHOW_PID) - col += fmtstr(s + col, 16, "%d ", ps->pid); +static void calcsize(union node *n); - psend = ps + jp->nprocs; +static void +sizenodelist(struct nodelist *lp) +{ + while (lp) { + funcblocksize += SHELL_ALIGN(sizeof(struct nodelist)); + calcsize(lp->n); + lp = lp->next; + } +} - 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; +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: +#if ENABLE_ASH_BASH_COMPAT + case NTO2: #endif - col += sprint_status(s + col, status, 0); - } + 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; + }; +} - goto start; +static char * +nodeckstrdup(char *s) +{ + char *rtn = funcstring; - do { - /* for each process */ - col = fmtstr(s, 48, " |\n%*c%d ", indent, ' ', ps->pid) - 3; + strcpy(funcstring, s); + funcstring += strlen(s) + 1; + return rtn; +} -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); +static union node *copynode(union node *); - jp->changed = 0; +static struct nodelist * +copynodelist(struct nodelist *lp) +{ + struct nodelist *start; + struct nodelist **lpp; - if (jp->state == JOBDONE) { - TRACE(("showjob: freeing job %d\n", jobno(jp))); - freejob(jp); + lpp = &start; + while (lp) { + *lpp = funcblock; + funcblock = (char *) funcblock + SHELL_ALIGN(sizeof(struct nodelist)); + (*lpp)->n = copynode(lp->n); + lp = lp->next; + lpp = &(*lpp)->next; } + *lpp = NULL; + return start; } - -static int -jobscmd(int argc, char **argv) +static union node * +copynode(union node *n) { - int mode, m; - FILE *out; + union node *new; - 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); + if (n == NULL) + return NULL; + new = funcblock; + funcblock = (char *) funcblock + nodesize[n->type]; - return 0; + 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.pipe_backgnd = n->npipe.pipe_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 = nodeckstrdup(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 = nodeckstrdup(n->narg.text); + new->narg.next = copynode(n->narg.next); + break; + case NTO: +#if ENABLE_ASH_BASH_COMPAT + case NTO2: +#endif + 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; } - /* - * Print a list of jobs. If "change" is nonzero, only print jobs whose - * statuses have changed since the last call to showjobs. + * Make a copy of a parse tree. */ - -static void -showjobs(FILE *out, int mode) +static struct funcnode * +copyfunc(union node *n) { - struct job *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; + struct funcnode *f; + size_t blocksize; - for (jp = curjob; jp; jp = jp->prev_job) { - if (!(mode & SHOW_CHANGED) || jp->changed) - showjob(out, jp, mode); - } + 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; } -#endif /* JOBS */ /* - * Mark a job structure as unused. + * Define a shell function. */ - static void -freejob(struct job *jp) +defun(char *name, union node *func) { - struct procstat *ps; - int i; + struct cmdentry entry; - INTOFF; - for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) { - if (ps->cmd != nullstr) - ckfree(ps->cmd); - } - if (jp->ps != &jp->ps0) - ckfree(jp->ps); - jp->used = 0; - set_curjob(jp, CUR_DELETE); - INTON; + INT_OFF; + entry.cmdtype = CMDFUNCTION; + entry.u.func = copyfunc(func); + addcmdentry(name, &entry); + INT_ON; } +/* Reasons for skipping commands (see comment on breakcmd routine) */ +#define SKIPBREAK (1 << 0) +#define SKIPCONT (1 << 1) +#define SKIPFUNC (1 << 2) +#define SKIPFILE (1 << 3) +#define SKIPEVAL (1 << 4) +static smallint evalskip; /* set to SKIPxxx if we are skipping commands */ +static int skipcount; /* number of levels to skip */ +static int funcnest; /* depth of function calls */ +static int loopnest; /* current loop nesting level */ + +/* Forward decl way out to parsing code - dotrap needs it */ +static int evalstring(char *s, int mask); +/* Called to execute a trap. + * Single callsite - at the end of evaltree(). + * If we return non-zero, exaltree raises EXEXIT exception. + * + * Perhaps we should avoid entering new trap handlers + * while we are executing a trap handler. [is it a TODO?] + */ static int -waitcmd(int argc, char **argv) +dotrap(void) { - struct job *job; - int retval; - struct job *jp; + uint8_t *g; + int sig; + uint8_t savestatus; - EXSIGON(); + savestatus = exitstatus; + pendingsig = 0; + xbarrier(); - nextopt(nullstr); - retval = 0; + TRACE(("dotrap entered\n")); + for (sig = 1, g = gotsig; sig < NSIG; sig++, g++) { + int want_exexit; + char *t; - argv = argptr; - if (!*argv) { - /* wait for all jobs */ - for (;;) { - jp = curjob; - while (1) { - if (!jp) { - /* no running procs */ - goto out; - } - if (jp->state == JOBRUNNING) - break; - jp->waited = 1; - jp = jp->prev_job; - } - dowait(DOWAIT_BLOCK, 0); + if (*g == 0) + continue; + t = trap[sig]; + /* non-trapped SIGINT is handled separately by raise_interrupt, + * don't upset it by resetting gotsig[SIGINT-1] */ + if (sig == SIGINT && !t) + continue; + + TRACE(("sig %d is active, will run handler '%s'\n", sig, t)); + *g = 0; + if (!t) + continue; + want_exexit = evalstring(t, SKIPEVAL); + exitstatus = savestatus; + if (want_exexit) { + TRACE(("dotrap returns %d\n", want_exexit)); + return want_exexit; } } - 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; + TRACE(("dotrap returns 0\n")); + return 0; } - +/* forward declarations - evaluation is fairly recursive business... */ +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 void prehash(union node *); /* - * Convert a job name to a job structure. + * Evaluate a parse tree. The value is left in the global variable + * exitstatus. */ - -static struct job * -getjob(const char *name, int getctl) +static void +evaltree(union node *n, int flags) { - struct job *jp; - struct job *found; - const char *err_msg = "No such job: %s"; - unsigned num; - int c; - const char *p; - char *(*match)(const char *, const char *); - - jp = curjob; - p = name; - if (!p) - goto currentjob; - - if (*p != '%') - goto err; + struct jmploc *volatile savehandler = exception_handler; + struct jmploc jmploc; + int checkexit = 0; + void (*evalfn)(union node *, int); + int status; + int int_level; - c = *++p; - if (!c) - goto currentjob; + SAVE_INT(int_level); - 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; - } + if (n == NULL) { + TRACE(("evaltree(NULL) called\n")); + goto out1; } + TRACE(("evaltree(%p: %d, %d) called\n", n, n->type, flags)); - if (is_number(p)) { - num = atoi(p); - if (num < njobs) { - jp = jobtab + num - 1; - if (jp->used) - goto gotit; - goto err; + exception_handler = &jmploc; + { + int err = setjmp(jmploc.loc); + if (err) { + /* if it was a signal, check for trap handlers */ + if (exception_type == EXSIG) { + TRACE(("exception %d (EXSIG) in evaltree, err=%d\n", + exception_type, err)); + goto out; + } + /* continue on the way out */ + TRACE(("exception %d in evaltree, propagating err=%d\n", + exception_type, err)); + exception_handler = savehandler; + longjmp(exception_handler->loc, err); } } - 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"; + switch (n->type) { + default: +#if DEBUG + out1fmt("Node type = %d\n", n->type); + fflush(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; } - jp = jp->prev_job; - } + popredir(/*drop:*/ 0, /*restore:*/ 0 /* not sure */); + 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: { -gotit: -#if JOBS - err_msg = "job %s not created under job control"; - if (getctl && jp->jobctl == 0) - goto err; +#if NAND + 1 != NOR +#error NAND + 1 != NOR #endif - return jp; -err: - error(err_msg, name); -} - - - -/* - * Return a new job structure. - * Called with interrupts off. - */ - -static struct job * -makejob(union node *node, int nprocs) -{ - int i; - struct job *jp; - - for (i = njobs, jp = jobtab ; ; jp++) { - if (--i < 0) { - jp = growjobtab(); +#if NOR + 1 != NSEMI +#error NOR + 1 != NSEMI +#endif + unsigned is_or = n->type - NAND; + evaltree( + n->nbinary.ch1, + (flags | ((is_or >> 1) - 1)) & EV_TESTED + ); + if (!exitstatus == is_or) break; - } - if (jp->used == 0) + if (!evalskip) { + n = n->nbinary.ch2; + evaln: + evalfn = evaltree; + calleval: + evalfn(n, flags); break; - if (jp->state != JOBDONE || !jp->waited) - continue; -#if JOBS - if (jobctl) - continue; -#endif - freejob(jp); + } break; } - 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 = ckmalloc(nprocs * sizeof (struct procstat)); + case NIF: + evaltree(n->nif.test, EV_TESTED); + if (evalskip) + break; + if (exitstatus == 0) { + n = n->nif.ifpart; + goto evaln; + } + 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; } - 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; + out: + exception_handler = savehandler; + out1: + if (checkexit & exitstatus) + evalskip |= SKIPEVAL; + else if (pendingsig && dotrap()) + goto exexit; - 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 + if (flags & EV_EXIT) { + exexit: + raise_exception(EXEXIT); } - njobs += 4; - jobtab = jp; - jp = (struct job *)((char *)jp + len); - jq = jp + 3; - do { - jq->used = 0; - } while (--jq >= jp); - return jp; + RESTORE_INT(int_level); + TRACE(("leaving evaltree (no interrupts)\n")); } +#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3) +static +#endif +void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__)); -/* - * 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: - * FORK_FG - Fork off a foreground process. - * FORK_BG - Fork off a background process. - * FORK_NOJOB - Like FORK_FG, but don't give the process its own - * process group even if job control is on. - * - * 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 inline void -forkchild(struct job *jp, union node *n, int mode) +static void +evalloop(union node *n, int flags) { - int wasroot; - - TRACE(("Child shell %d\n", getpid())); - wasroot = rootshell; - rootshell = 0; + int status; - closescript(); - clear_traps(); -#if JOBS - /* do job control only in root shell */ - jobctl = 0; - if (mode != FORK_NOJOB && jp->jobctl && wasroot) { - pid_t pgrp; + loopnest++; + status = 0; + flags &= EV_TESTED; + for (;;) { + int i; - 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 - 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); + evaltree(n->nbinary.ch1, EV_TESTED); + if (evalskip) { + skipping: + if (evalskip == SKIPCONT && --skipcount <= 0) { + evalskip = 0; + continue; + } + if (evalskip == SKIPBREAK && --skipcount <= 0) + evalskip = 0; + break; } + i = exitstatus; + if (n->type != NWHILE) + i = !i; + if (i != 0) + break; + evaltree(n->nbinary.ch2, flags); + status = exitstatus; + if (evalskip) + goto skipping; } - if (wasroot && iflag) { - setsignal(SIGINT); - setsignal(SIGQUIT); - setsignal(SIGTERM); - } - for (jp = curjob; jp; jp = jp->prev_job) - freejob(jp); - jobless = 0; + loopnest--; + exitstatus = status; } -static inline void -forkparent(struct job *jp, union node *n, int mode, pid_t pid) +static void +evalfor(union node *n, int flags) { - 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; + struct arglist arglist; + union node *argp; + struct strlist *sp; + struct stackmark smark; - if (jp->nprocs == 0) - pgrp = pid; - else - pgrp = jp->ps[0].pid; - /* This can fail because we are doing it in the child also */ - (void)setpgid(pid, pgrp); - } -#endif - if (mode == FORK_BG) { - backgndpid = pid; /* set $! */ - set_curjob(jp, CUR_RUNNING); + setstackmark(&smark); + arglist.list = NULL; + arglist.lastp = &arglist.list; + for (argp = n->nfor.args; argp; argp = argp->narg.next) { + expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD); + /* XXX */ + if (evalskip) + goto out; } - if (jp) { - struct procstat *ps = &jp->ps[jp->nprocs++]; - ps->pid = pid; - ps->status = -1; - ps->cmd = nullstr; -#if JOBS - if (jobctl && n) - ps->cmd = commandtext(n); -#endif + *arglist.lastp = NULL; + + exitstatus = 0; + loopnest++; + flags &= EV_TESTED; + for (sp = arglist.list; sp; sp = sp->next) { + setvar(n->nfor.var, sp->text, 0); + evaltree(n->nfor.body, flags); + if (evalskip) { + if (evalskip == SKIPCONT && --skipcount <= 0) { + evalskip = 0; + continue; + } + if (evalskip == SKIPBREAK && --skipcount <= 0) + evalskip = 0; + break; + } } + loopnest--; + out: + popstackmark(&smark); } -static int -forkshell(struct job *jp, union node *n, int mode) +static void +evalcase(union node *n, int flags) { - int pid; + union node *cp; + union node *patp; + struct arglist arglist; + struct stackmark smark; - 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"); + setstackmark(&smark); + arglist.list = NULL; + arglist.lastp = &arglist.list; + expandarg(n->ncase.expr, &arglist, EXP_TILDE); + 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); + } + goto out; + } + } } - if (pid == 0) - forkchild(jp, n, mode); - else - forkparent(jp, n, mode, pid); - return pid; + out: + popstackmark(&smark); } /* - * Wait for job to finish. - * - * Under job control we have the problem that while a child process is - * running interrupts generated by the user are sent to the child but not - * to the shell. This means that an infinite loop started by an inter- - * active user may be hard to kill. With job control turned off, an - * interactive user may place an interactive program inside a loop. If - * the interactive program catches interrupts, the user doesn't want - * these interrupts to also abort the loop. The approach we take here - * is to have the shell ignore interrupt signals while waiting for a - * forground process to terminate, and then send itself an interrupt - * signal if the child process was terminated by an interrupt signal. - * Unfortunately, some programs want to do a bit of cleanup and then - * 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. + * Kick off a subshell to evaluate a tree. */ - -int -waitforjob(struct job *jp) +static void +evalsubshell(union node *n, int flags) { - int st; + struct job *jp; + int backgnd = (n->type == NBACKGND); + int status; - TRACE(("waitforjob(%%%d) called\n", jobno(jp))); - while (jp->state == JOBRUNNING) { - dowait(DOWAIT_BLOCK, jp); - } - 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 - * occurred, and if so interrupt ourselves. Yuck. - mycroft - */ - if (jp->sigint) - raise(SIGINT); + expredir(n->nredir.redirect); + if (!backgnd && flags & EV_EXIT && !trap[0]) + goto nofork; + INT_OFF; + jp = makejob(/*n,*/ 1); + if (forkshell(jp, n, backgnd) == 0) { + INT_ON; + flags |= EV_EXIT; + if (backgnd) + flags &=~ EV_TESTED; + nofork: + redirect(n->nredir.redirect, 0); + evaltreenr(n->nredir.n, flags); + /* never returns */ } - if (jp->state == JOBDONE) -#endif - freejob(jp); - return st; + status = 0; + if (!backgnd) + status = waitforjob(jp); + exitstatus = status; + INT_ON; } - /* - * 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 - * rather than blocking. - * - * System V doesn't have a non-blocking wait system call. It does - * have a SIGCLD signal that is sent to a process when one of it's - * children dies. The obvious way to use SIGCLD would be to install - * a handler for SIGCLD which simply bumped a counter when a SIGCLD - * was received, and have waitproc bump another counter when it got - * the status of a process. Waitproc would then know that a wait - * system call would not block if the two counters were different. - * This approach doesn't work because if a process has children that - * have not been waited for, System V will send it a SIGCLD when it - * installs a signal handler for SIGCLD. What this means is that when - * a child exits, the shell will be sent SIGCLD signals continuously - * until is runs out of stack space, unless it does a wait call before - * restoring the signal handler. The code below takes advantage of - * this (mis)feature by installing a signal handler for SIGCLD and - * 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. + * Compute the names of the files in a redirection list. */ - -static inline int -waitproc(int block, int *status) +static void fixredir(union node *, const char *, int); +static void +expredir(union node *n) { - int flags = 0; + union node *redir; -#if JOBS - if (jobctl) - flags |= WUNTRACED; + for (redir = n; redir; redir = redir->nfile.next) { + struct arglist fn; + + fn.list = NULL; + fn.lastp = &fn.list; + switch (redir->type) { + case NFROMTO: + case NFROM: + case NTO: +#if ENABLE_ASH_BASH_COMPAT + case NTO2: #endif - if (block == 0) - flags |= WNOHANG; - return wait3(status, flags, (struct rusage *)NULL); + case NCLOBBER: + case NAPPEND: + expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR); +#if ENABLE_ASH_BASH_COMPAT + store_expfname: +#endif + redir->nfile.expfname = fn.list->text; + break; + case NFROMFD: + case NTOFD: /* >& */ + if (redir->ndup.vname) { + expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE); + if (fn.list == NULL) + ash_msg_and_raise_error("redir error"); +#if ENABLE_ASH_BASH_COMPAT +//FIXME: we used expandarg with different args! + if (!isdigit_str9(fn.list->text)) { + /* >&file, not >&fd */ + if (redir->nfile.fd != 1) /* 123>&file - BAD */ + ash_msg_and_raise_error("redir error"); + redir->type = NTO2; + goto store_expfname; + } +#endif + fixredir(redir, fn.list->text, 1); + } + break; + } + } } /* - * Wait for a process to terminate. + * Evaluate a pipeline. All the processes in the pipeline are children + * of the process creating the pipeline. (This differs from some versions + * of the shell, which make the last process in a pipeline the parent + * of all the rest.) */ - -static int -dowait(int block, struct job *job) +static void +evalpipe(union node *n, int flags) { - int pid; - int status; struct job *jp; - struct job *thisjob; - int state; + struct nodelist *lp; + int pipelen; + int prevfd; + int pip[2]; - TRACE(("dowait(%d) called\n", block)); - pid = waitproc(block, &status); - TRACE(("wait returns pid %d, status=%d\n", pid, status)); - if (pid <= 0) - return pid; - INTOFF; - thisjob = NULL; - 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; + TRACE(("evalpipe(0x%lx) called\n", (long)n)); + pipelen = 0; + for (lp = n->npipe.cmdlist; lp; lp = lp->next) + pipelen++; + flags |= EV_EXIT; + INT_OFF; + jp = makejob(/*n,*/ pipelen); + prevfd = -1; + for (lp = n->npipe.cmdlist; lp; lp = lp->next) { + prehash(lp->n); + pip[1] = -1; + if (lp->next) { + if (pipe(pip) < 0) { + close(prevfd); + ash_msg_and_raise_error("pipe call failed"); } - if (sp->status == -1) - state = JOBRUNNING; -#ifdef JOBS - if (state == JOBRUNNING) - continue; - if (WIFSTOPPED(sp->status)) { - jp->stopstatus = sp->status; - state = JOBSTOPPED; + } + if (forkshell(jp, lp->n, n->npipe.pipe_backgnd) == 0) { + INT_ON; + if (pip[1] >= 0) { + close(pip[0]); } -#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); + if (prevfd > 0) { + dup2(prevfd, 0); + close(prevfd); } -#endif + if (pip[1] > 1) { + dup2(pip[1], 1); + close(pip[1]); + } + evaltreenr(lp->n, flags); + /* never returns */ } + if (prevfd >= 0) + close(prevfd); + prevfd = pip[0]; + /* Don't want to trigger debugging */ + if (pip[1] != -1) + close(pip[1]); } - -out: - INTON; - - 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); - } + if (n->npipe.pipe_backgnd == 0) { + exitstatus = waitforjob(jp); + TRACE(("evalpipe: job done exit status %d\n", exitstatus)); } - return pid; + INT_ON; } - - /* - * return 1 if there are stopped jobs, otherwise 0 + * Controls whether the shell is interactive or not. */ -int -stoppedjobs(void) +static void +setinteractive(int on) { - struct job *jp; - int retval; + static smallint is_interactive; - retval = 0; - if (job_warning) - goto out; - jp = curjob; - if (jp && jp->state == JOBSTOPPED) { - out2str("You have stopped jobs.\n"); - job_warning = 2; - retval++; - } + if (++on == is_interactive) + return; + is_interactive = on; + setsignal(SIGINT); + setsignal(SIGQUIT); + setsignal(SIGTERM); +#if !ENABLE_FEATURE_SH_EXTRA_QUIET + if (is_interactive > 1) { + /* Looks like they want an interactive shell */ + static smallint did_banner; -out: - return retval; + if (!did_banner) { + out1fmt( + "\n\n" + "%s built-in shell (ash)\n" + "Enter 'help' for a list of built-in commands." + "\n\n", + bb_banner); + did_banner = 1; + } + } +#endif } -/* - * Return a string identifying a command (to be printed by the - * jobs command). - */ - -#if JOBS -static char *cmdnextc; - -static char * -commandtext(union node *n) +static void +optschanged(void) { - char *name; - - STARTSTACKSTR(cmdnextc); - cmdtxt(n); - name = stackblock(); - TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n", - name, cmdnextc, cmdnextc)); - return savestr(name); +#if DEBUG + opentrace(); +#endif + setinteractive(iflag); + setjobctl(mflag); +#if ENABLE_FEATURE_EDITING_VI + if (viflag) + line_input_state->flags |= VI_MODE; + else + line_input_state->flags &= ~VI_MODE; +#else + viflag = 0; /* forcibly keep the option off */ +#endif } +static struct localvar *localvars; + +/* + * Called after a function returns. + * Interrupts must be off. + */ static void -cmdtxt(union node *n) +poplocalvars(void) { - union node *np; - struct nodelist *lp; - const char *p; - char s[2]; + struct localvar *lvp; + struct var *vp; - switch (n->type) { - default: -#if DEBUG - abort(); -#endif - case NPIPE: - lp = n->npipe.cmdlist; - for (;;) { - cmdtxt(lp->n); - lp = lp->next; - if (!lp) - break; - 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: - 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 "); - 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: - p = "while "; - goto until; - case NUNTIL: - p = "until "; -until: - cmdputs(p); - cmdtxt(n->nbinary.ch1); - n = n->nbinary.ch2; - p = "; done"; -dodo: - cmdputs("; do "); -dotail: - cmdtxt(n); - goto dotail2; - case NFOR: - cmdputs("for "); - cmdputs(n->nfor.var); - cmdputs(" in "); - cmdlist(n->nfor.args, 1); - n = n->nfor.body; - p = "; done"; - goto dodo; - case NDEFUN: - cmdputs(n->narg.text); - p = "() { ... }"; - goto dotail2; - case NCMD: - cmdlist(n->ncmd.args, 1); - cmdlist(n->ncmd.redirect, 0); - break; - case NARG: - 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 = ">"; - goto redir; - case NCLOBBER: - p = ">|"; - goto redir; - case NAPPEND: - p = ">>"; - goto redir; - case NTOFD: - p = ">&"; - goto redir; - case NFROM: - p = "<"; - goto redir; - case NFROMFD: - p = "<&"; - goto redir; - case NFROMTO: - p = "<>"; -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'; - p = s; - goto dotail2; + while ((lvp = localvars) != NULL) { + localvars = lvp->next; + vp = lvp->vp; + TRACE(("poplocalvar %s", vp ? vp->text : "-")); + if (vp == NULL) { /* $- saved */ + memcpy(optlist, lvp->text, sizeof(optlist)); + free((char*)lvp->text); + optschanged(); + } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) { + unsetvar(vp->text); } else { - n = n->nfile.fname; - goto donode; + if (vp->func) + (*vp->func)(strchrnul(lvp->text, '=') + 1); + if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0) + free((char*)vp->text); + vp->flags = lvp->flags; + vp->text = lvp->text; } + free(lvp); } } -static void -cmdlist(union node *np, int sep) +static int +evalfun(struct funcnode *func, int argc, char **argv, int flags) { - for (; np; np = np->narg.next) { - if (!sep) - cmdputs(spcstr); - cmdtxt(np); - if (sep && np->narg.next) - cmdputs(spcstr); + volatile struct shparam saveparam; + struct localvar *volatile savelocalvars; + struct jmploc *volatile savehandler; + struct jmploc jmploc; + int e; + + saveparam = shellparam; + savelocalvars = localvars; + e = setjmp(jmploc.loc); + if (e) { + goto funcdone; } + INT_OFF; + savehandler = exception_handler; + exception_handler = &jmploc; + localvars = NULL; + shellparam.malloced = 0; + func->count++; + funcnest++; + INT_ON; + shellparam.nparam = argc - 1; + shellparam.p = argv + 1; +#if ENABLE_ASH_GETOPTS + shellparam.optind = 1; + shellparam.optoff = -1; +#endif + evaltree(&func->n, flags & EV_TESTED); + funcdone: + INT_OFF; + funcnest--; + freefunc(func); + poplocalvars(); + localvars = savelocalvars; + freeparam(&shellparam); + shellparam = saveparam; + exception_handler = savehandler; + INT_ON; + evalskip &= ~SKIPFUNC; + return e; } - -static void -cmdputs(const char *s) +#if ENABLE_ASH_CMDCMD +static char ** +parse_command_args(char **argv, const char **path) { - const char *p, *str; - char c, cc[2] = " "; - char *nextc; - int subtype = 0; - int quoted = 0; - static const char *const vstype[16] = { - nullstr, "}", "-", "+", "?", "=", - "#", "##", "%", "%%" - }; + char *cp, c; - 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; + for (;;) { + cp = *++argv; + if (!cp) + return 0; + if (*cp++ != '-') break; - case '\'': - case '\\': - case '"': - case '$': - /* These can only happen inside quotes */ - cc[0] = c; - str = cc; - c = '\\'; + c = *cp++; + if (!c) break; - default: + if (c == '-' && !*cp) { + argv++; break; } - USTPUTC(c, nextc); - if (!str) - continue; -dostr: - while ((c = *str++)) { - USTPUTC(c, nextc); - } - } - if (quoted & 1) { - USTPUTC('"', nextc); + do { + switch (c) { + case 'p': + *path = bb_default_path; + break; + default: + /* run 'typecmd' for other options */ + return 0; + } + c = *cp++; + } while (c); } - *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(); + return argv; } +#endif +/* + * 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 -xtcsetpgrp(int fd, pid_t pgrp) +mklocal(char *name) { - if (tcsetpgrp(fd, pgrp)) - error("Cannot set tty process group (%m)"); -} -#endif /* JOBS */ + struct localvar *lvp; + struct var **vpp; + struct var *vp; -static int -getstatus(struct job *job) { - int status; - int retval; + INT_OFF; + lvp = ckzalloc(sizeof(struct localvar)); + if (LONE_DASH(name)) { + char *p; + p = ckmalloc(sizeof(optlist)); + lvp->text = memcpy(p, optlist, sizeof(optlist)); + vp = NULL; + } else { + char *eq; - 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 + vpp = hashvar(name); + vp = *findvar(vpp, name); + eq = strchr(name, '='); + if (vp == NULL) { + if (eq) + setvareq(name, VSTRFIXED); + else + setvar(name, NULL, VSTRFIXED); + vp = *vpp; /* the new variable */ + lvp->flags = VUNSET; + } else { + lvp->text = vp->text; + lvp->flags = vp->flags; + vp->flags |= VSTRFIXED|VTEXTFIXED; + if (eq) + setvareq(name, 0); } - retval += 128; } - TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n", - jobno(job), job->nprocs, status, retval)); - return retval; + lvp->vp = vp; + lvp->next = localvars; + localvars = lvp; + INT_ON; } -#ifdef CONFIG_ASH_MAIL -/* $NetBSD: mail.c,v 1.15 2002/11/24 22:35:40 christos Exp $ */ - /* - * Routines to check for mail. (Perhaps make part of main.c?) - */ - -#define MAXMBOXES 10 - -/* 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 mail_var_path_changed is set, - * then the value of MAIL has mail_var_path_changed, - * so we just update the values. + * The "local" command. */ - -static void -chkmail(void) +static int +localcmd(int argc UNUSED_PARAM, char **argv) { - const char *mpath; - char *p; - char *q; - time_t *mtp; - struct stackmark smark; - struct stat statb; + char *name; - setstackmark(&smark); - 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++); -#ifdef DEBUG - if (q[-1] != '/') - abort(); -#endif - 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" - ); - } - *mtp = statb.st_mtime; + argv = argptr; + while ((name = *argv++) != NULL) { + mklocal(name); } - mail_var_path_changed = 0; - popstackmark(&smark); + return 0; } - -static void -changemail(const char *val) +static int +falsecmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { - mail_var_path_changed++; + return 1; } -#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; +static int +truecmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) +{ + return 0; +} -static void read_profile(const char *); +static int +execcmd(int argc UNUSED_PARAM, char **argv) +{ + if (argv[1]) { + iflag = 0; /* exit on error */ + mflag = 0; + optschanged(); + shellexec(argv + 1, pathval(), 0); + } + return 0; +} /* - * Main routine. We initialize things, parse the arguments, execute - * profiles if we're a login shell, and then call cmdloop to execute - * commands. The setjmp call sets up the location to jump to when an - * exception occurs. When an exception occurs the variable "state" - * is used to figure out how far we had gotten. + * The return command. */ - -int -ash_main(int argc, char **argv) +static int +returncmd(int argc UNUSED_PARAM, char **argv) { - char *shinit; - volatile int state; - struct jmploc jmploc; - struct stackmark smark; + /* + * If called outside a function, do what ksh does; + * skip the rest of the file. + */ + evalskip = funcnest ? SKIPFUNC : SKIPFILE; + return argv[1] ? number(argv[1]) : exitstatus; +} -#ifdef __GLIBC__ - dash_errno = __errno_location(); +/* Forward declarations for builtintab[] */ +static int breakcmd(int, char **); +static int dotcmd(int, char **); +static int evalcmd(int, char **); +static int exitcmd(int, char **); +static int exportcmd(int, char **); +#if ENABLE_ASH_GETOPTS +static int getoptscmd(int, char **); #endif - -#if PROFILE - monitor(4, etext, profile_buf, sizeof profile_buf, 50); +#if !ENABLE_FEATURE_SH_EXTRA_QUIET +static int helpcmd(int, char **); #endif - state = 0; - if (setjmp(jmploc.loc)) { - int status; - int e; - - reset(); - - e = exception; - switch (exception) { - case EXEXEC: - status = exerrno; - break; +#if ENABLE_SH_MATH_SUPPORT +static int letcmd(int, char **); +#endif +static int readcmd(int, char **); +static int setcmd(int, char **); +static int shiftcmd(int, char **); +static int timescmd(int, char **); +static int trapcmd(int, char **); +static int umaskcmd(int, char **); +static int unsetcmd(int, char **); +static int ulimitcmd(int, char **); - case EXERROR: - status = 2; - break; +#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" - default: - status = exitstatus; - break; - } - exitstatus = status; +/* We do not handle [[ expr ]] bashism bash-compatibly, + * we make it a synonym of [ expr ]. + * Basically, word splitting and pathname expansion should NOT be performed + * Examples: + * no word splitting: a="a b"; [[ $a = "a b" ]]; echo $? should print "0" + * no pathname expansion: [[ /bin/m* = "/bin/m*" ]]; echo $? should print "0" + * Additional operators: + * || and && should work as -o and -a + * =~ regexp match + * Apart from the above, [[ expr ]] should work as [ expr ] + */ - if (e == EXEXIT || state == 0 || iflag == 0 || ! rootshell) - exitshell(); +#define echocmd echo_main +#define printfcmd printf_main +#define testcmd test_main - if (e == EXINT ) { - outcslow('\n', stderr); - } - popstackmark(&smark); - FORCEINTON; /* enable interrupts */ - if (state == 1) - goto state1; - else if (state == 2) - goto state2; - else if (state == 3) - goto state3; - else - goto state4; - } - handler = &jmploc; -#ifdef DEBUG - opentrace(); - trputs("Shell args: "); trargs(argv); +/* Keep these in proper order since it is searched via bsearch() */ +static const struct builtincmd builtintab[] = { + { BUILTIN_SPEC_REG ".", dotcmd }, + { BUILTIN_SPEC_REG ":", truecmd }, +#if ENABLE_ASH_BUILTIN_TEST + { BUILTIN_REGULAR "[", testcmd }, +#if ENABLE_ASH_BASH_COMPAT + { BUILTIN_REGULAR "[[", testcmd }, #endif - rootpid = getpid(); - rootshell = 1; - init(); - setstackmark(&smark); - procargs(argc, argv); -#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY - if ( iflag ) { - const char *hp = lookupvar("HISTFILE"); - - if(hp == NULL ) { - hp = lookupvar("HOME"); - if(hp != NULL) { - char *defhp = concat_path_file(hp, ".ash_history"); - setvar("HISTFILE", defhp, 0); - free(defhp); - } - } - } #endif - if (argv[0] && argv[0][0] == '-') - isloginsh = 1; - if (isloginsh) { - state = 1; - read_profile("/etc/profile"); -state1: - state = 2; - read_profile(".profile"); - } -state2: - state = 3; - if ( -#ifndef linux - getuid() == geteuid() && getgid() == getegid() && +#if ENABLE_ASH_ALIAS + { BUILTIN_REG_ASSG "alias", aliascmd }, #endif - iflag - ) { - if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') { - read_profile(shinit); - } - } -state3: - state = 4; - if (minusc) - evalstring(minusc, 0); - - if (sflag || minusc == NULL) { -state4: /* XXX ??? - why isn't this before the "if" statement */ -#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY - if ( iflag ) { - const char *hp = lookupvar("HISTFILE"); - - if(hp != NULL ) - load_history ( hp ); - } +#if JOBS + { BUILTIN_REGULAR "bg", fg_bgcmd }, #endif - cmdloop(1); - } -#if PROFILE - monitor(0); + { BUILTIN_SPEC_REG "break", breakcmd }, + { BUILTIN_REGULAR "cd", cdcmd }, + { BUILTIN_NOSPEC "chdir", cdcmd }, +#if ENABLE_ASH_CMDCMD + { BUILTIN_REGULAR "command", commandcmd }, #endif -#if GPROF - { - extern void _mcleanup(void); - _mcleanup(); - } + { BUILTIN_SPEC_REG "continue", breakcmd }, +#if ENABLE_ASH_BUILTIN_ECHO + { BUILTIN_REGULAR "echo", echocmd }, #endif - exitshell(); - /* NOTREACHED */ -} + { BUILTIN_SPEC_REG "eval", evalcmd }, + { BUILTIN_SPEC_REG "exec", execcmd }, + { BUILTIN_SPEC_REG "exit", exitcmd }, + { BUILTIN_SPEC_REG_ASSG "export", exportcmd }, + { BUILTIN_REGULAR "false", falsecmd }, +#if JOBS + { BUILTIN_REGULAR "fg", fg_bgcmd }, +#endif +#if ENABLE_ASH_GETOPTS + { BUILTIN_REGULAR "getopts", getoptscmd }, +#endif + { BUILTIN_NOSPEC "hash", hashcmd }, +#if !ENABLE_FEATURE_SH_EXTRA_QUIET + { BUILTIN_NOSPEC "help", helpcmd }, +#endif +#if JOBS + { BUILTIN_REGULAR "jobs", jobscmd }, + { BUILTIN_REGULAR "kill", killcmd }, +#endif +#if ENABLE_SH_MATH_SUPPORT + { BUILTIN_NOSPEC "let", letcmd }, +#endif + { BUILTIN_ASSIGN "local", localcmd }, +#if ENABLE_ASH_BUILTIN_PRINTF + { BUILTIN_REGULAR "printf", printfcmd }, +#endif + { 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 "source", dotcmd }, +#if ENABLE_ASH_BUILTIN_TEST + { BUILTIN_REGULAR "test", testcmd }, +#endif + { 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 }, +#if ENABLE_ASH_ALIAS + { BUILTIN_REGULAR "unalias", unaliascmd }, +#endif + { BUILTIN_SPEC_REG "unset", unsetcmd }, + { BUILTIN_REGULAR "wait", waitcmd }, +}; +/* Should match the above table! */ +#define COMMANDCMD (builtintab + \ + 2 + \ + 1 * ENABLE_ASH_BUILTIN_TEST + \ + 1 * ENABLE_ASH_BUILTIN_TEST * ENABLE_ASH_BASH_COMPAT + \ + 1 * ENABLE_ASH_ALIAS + \ + 1 * ENABLE_ASH_JOB_CONTROL + \ + 3) +#define EXECCMD (builtintab + \ + 2 + \ + 1 * ENABLE_ASH_BUILTIN_TEST + \ + 1 * ENABLE_ASH_BUILTIN_TEST * ENABLE_ASH_BASH_COMPAT + \ + 1 * ENABLE_ASH_ALIAS + \ + 1 * ENABLE_ASH_JOB_CONTROL + \ + 3 + \ + 1 * ENABLE_ASH_CMDCMD + \ + 1 + \ + ENABLE_ASH_BUILTIN_ECHO + \ + 1) /* - * Read and execute commands. "Top" is nonzero for the top level command - * loop; it turns on prompting if the shell is interactive. + * Search the table of builtin commands. */ +static struct builtincmd * +find_builtin(const char *name) +{ + struct builtincmd *bp; + bp = bsearch( + name, builtintab, ARRAY_SIZE(builtintab), sizeof(builtintab[0]), + pstrcmp + ); + return bp; +} + +/* + * Execute a simple command. + */ +static int +isassignment(const char *p) +{ + const char *q = endofname(p); + if (p == q) + return 0; + return *q == '='; +} +static int +bltincmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) +{ + /* Preserve exitstatus of a previous possible redirection + * as POSIX mandates */ + return back_exitstatus; +} static void -cmdloop(int top) +evalcommand(union node *cmd, int flags) { - union node *n; + static const struct builtincmd null_bltin = { + "\0\0", bltincmd /* why three NULs? */ + }; struct stackmark smark; - int inter; - int numeof = 0; + union node *argp; + struct arglist arglist; + struct arglist varlist; + char **argv; + int argc; + const struct strlist *sp; + struct cmdentry cmdentry; + struct job *jp; + char *lastarg; + const char *path; + int spclbltin; + int status; + char **nargv; + struct builtincmd *bcmd; + smallint cmd_is_exec; + smallint pseudovarflag = 0; - TRACE(("cmdloop(%d) called\n", top)); + /* First expand the arguments. */ + TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags)); setstackmark(&smark); - for (;;) { - if (pendingsigs) - dotrap(); -#if JOBS - if (jobctl) - showjobs(stderr, SHOW_CHANGED); -#endif - inter = 0; - if (iflag && top) { - inter++; -#ifdef CONFIG_ASH_MAIL - chkmail(); -#endif - } - n = parsecmd(inter); - /* showtree(n); DEBUG */ - if (n == NEOF) { - if (!top || numeof >= 50) - break; - if (!stoppedjobs()) { - if (!Iflag) - break; - out2str("\nUse \"exit\" to leave shell.\n"); - } - numeof++; - } else if (n != NULL && nflag == 0) { - job_warning = (job_warning == 2) ? 1 : 0; - numeof = 0; - evaltree(n, 0); - } - popstackmark(&smark); - setstackmark(&smark); - if (evalskip == SKIPFILE) { - evalskip = 0; - break; - } - } - popstackmark(&smark); -} + back_exitstatus = 0; + cmdentry.cmdtype = CMDBUILTIN; + cmdentry.u.cmd = &null_bltin; + varlist.lastp = &varlist.list; + *varlist.lastp = NULL; + arglist.lastp = &arglist.list; + *arglist.lastp = NULL; + argc = 0; + if (cmd->ncmd.args) { + bcmd = find_builtin(cmd->ncmd.args->narg.text); + pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd); + } -/* - * Read /etc/profile or .profile. Return on error. - */ + for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) { + struct strlist **spp; -static void -read_profile(const char *name) -{ - int fd; - int xflag_set = 0; - int vflag_set = 0; + spp = arglist.lastp; + if (pseudovarflag && isassignment(argp->narg.text)) + expandarg(argp, &arglist, EXP_VARTILDE); + else + expandarg(argp, &arglist, EXP_FULL | EXP_TILDE); - INTOFF; - if ((fd = open(name, O_RDONLY)) >= 0) - setinputfd(fd, 1); - INTON; - if (fd < 0) - return; - /* -q turns off -x and -v just when executing init files */ - if (qflag) { - if (xflag) - xflag = 0, xflag_set = 1; - if (vflag) - vflag = 0, vflag_set = 1; + for (sp = *spp; sp; sp = sp->next) + argc++; } - cmdloop(0); - if (qflag) { - if (xflag_set) - xflag = 1; - if (vflag_set) - vflag = 1; + + argv = nargv = stalloc(sizeof(char *) * (argc + 1)); + for (sp = arglist.list; sp; sp = sp->next) { + TRACE(("evalcommand arg: %s\n", sp->text)); + *nargv++ = sp->text; } - popfile(); -} + *nargv = NULL; + lastarg = NULL; + if (iflag && funcnest == 0 && argc > 0) + lastarg = nargv[-1]; + preverrout_fd = 2; + expredir(cmd->ncmd.redirect); + status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH | REDIR_SAVEFD2); -/* - * Read a file containing shell functions. - */ + path = vpath.text; + for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) { + struct strlist **spp; + char *p; -static void -readcmdfile(char *name) -{ - int fd; + spp = varlist.lastp; + expandarg(argp, &varlist, EXP_VARTILDE); - INTOFF; - if ((fd = open(name, O_RDONLY)) >= 0) - setinputfd(fd, 1); - else - error("Can't open %s", name); - INTON; - cmdloop(0); - popfile(); -} + /* + * 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) { + int n; + const char *p = " %s"; -/* - * Take commands from a file. To be compatible we should do a path - * search for the file, which is necessary to find sub-commands. - */ + p++; + fdprintf(preverrout_fd, p, expandstr(ps4val())); + + sp = varlist.list; + for (n = 0; n < 2; n++) { + while (sp) { + fdprintf(preverrout_fd, p, sp->text); + sp = sp->next; + if (*p == '%') { + p--; + } + } + sp = arglist.list; + } + safe_write(preverrout_fd, "\n", 1); + } -static inline char * -find_dot_file(char *name) -{ - char *fullname; - const char *path = pathval(); - struct stat statb; + cmd_is_exec = 0; + spclbltin = -1; - /* don't try this for absolute or relative paths */ - if (strchr(name, '/')) - return name; + /* Now locate the command. */ + if (argc) { + const char *oldpath; + int cmd_flag = DO_ERR; - while ((fullname = padvance(&path, name)) != NULL) { - if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) { - /* - * Don't bother freeing here, since it will - * be freed by the caller. - */ - return fullname; + path += 5; + oldpath = path; + for (;;) { + find_command(argv[0], &cmdentry, cmd_flag, path); + if (cmdentry.cmdtype == CMDUNKNOWN) { + flush_stderr(); + status = 127; + goto bail; + } + + /* implement bltin and command here */ + if (cmdentry.cmdtype != CMDBUILTIN) + break; + if (spclbltin < 0) + spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd); + if (cmdentry.u.cmd == EXECCMD) + cmd_is_exec = 1; +#if ENABLE_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; } - stunalloc(fullname); } - /* not found in the PATH */ - error(not_found_msg, name); - /* NOTREACHED */ -} + if (status) { + /* We have a redirection error. */ + if (spclbltin > 0) + raise_exception(EXERROR); + bail: + exitstatus = status; + goto out; + } -int -dotcmd(int argc, char **argv) -{ - exitstatus = 0; + /* Execute the command. */ + switch (cmdentry.cmdtype) { + default: - if (argc >= 2) { /* That's what SVR2 does */ - char *fullname; - struct stackmark smark; +#if ENABLE_FEATURE_SH_NOFORK +/* Hmmm... shouldn't it happen somewhere in forkshell() instead? + * Why "fork off a child process if necessary" doesn't apply to NOFORK? */ + { + /* find_command() encodes applet_no as (-2 - applet_no) */ + int applet_no = (- cmdentry.u.index - 2); + if (applet_no >= 0 && APPLET_IS_NOFORK(applet_no)) { + listsetvar(varlist.list, VEXPORT|VSTACK); + /* run <applet>_main() */ + exitstatus = run_nofork_applet(applet_no, argv); + break; + } + } +#endif + /* Fork off a child process if necessary. */ + if (!(flags & EV_EXIT) || trap[0]) { + INT_OFF; + jp = makejob(/*cmd,*/ 1); + if (forkshell(jp, cmd, FORK_FG) != 0) { + exitstatus = waitforjob(jp); + INT_ON; + TRACE(("forked child exited with %d\n", exitstatus)); + break; + } + FORCE_INT_ON; + } + listsetvar(varlist.list, VEXPORT|VSTACK); + shellexec(argv, path, cmdentry.u.index); + /* NOTREACHED */ - setstackmark(&smark); - fullname = find_dot_file(argv[1]); - setinputfile(fullname, 1); - commandname = fullname; - cmdloop(0); - popfile(); - popstackmark(&smark); + 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); + } + /* Tight loop with builtins only: + * "while kill -0 $child; do true; done" + * will never exit even if $child died, unless we do this + * to reap the zombie and make kill detect that it's gone: */ + dowait(DOWAIT_NONBLOCK, NULL); + + if (evalbltin(cmdentry.u.cmd, argc, argv)) { + int exit_status; + int i = exception_type; + if (i == EXEXIT) + goto raise; + exit_status = 2; + if (i == EXINT) + exit_status = 128 + SIGINT; + if (i == EXSIG) + exit_status = 128 + pendingsig; + exitstatus = exit_status; + if (i == EXINT || spclbltin > 0) { + raise: + longjmp(exception_handler->loc, 1); + } + FORCE_INT_ON; + } + break; + + case CMDFUNCTION: + listsetvar(varlist.list, 0); + /* See above for the rationale */ + dowait(DOWAIT_NONBLOCK, NULL); + if (evalfun(cmdentry.u.func, argc, argv, flags)) + goto raise; + break; } - return exitstatus; -} + out: + popredir(/*drop:*/ cmd_is_exec, /*restore:*/ 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); +} static int -exitcmd(int argc, char **argv) +evalbltin(const struct builtincmd *cmd, int argc, char **argv) { - if (stoppedjobs()) - return 0; - if (argc > 1) - exitstatus = number(argv[1]); - exraise(EXEXIT); - /* NOTREACHED */ -} + char *volatile savecmdname; + struct jmploc *volatile savehandler; + struct jmploc jmploc; + int i; -/* $NetBSD: memalloc.c,v 1.27 2003/01/22 20:36:04 dsl Exp $ */ + savecmdname = commandname; + i = setjmp(jmploc.loc); + if (i) + goto cmddone; + savehandler = exception_handler; + exception_handler = &jmploc; + commandname = argv[0]; + argptr = argv + 1; + optptr = NULL; /* initialize nextopt */ + exitstatus = (*cmd->builtin)(argc, argv); + flush_stdout_stderr(); + cmddone: + exitstatus |= ferror(stdout); + clearerr(stdout); + commandname = savecmdname; +// exsig = 0; + exception_handler = savehandler; -/* - * Like malloc, but returns an error when out of space. - */ + return i; +} -static pointer -ckmalloc(size_t nbytes) +static int +goodname(const char *p) { - pointer p; - - p = malloc(nbytes); - if (p == NULL) - error(bb_msg_memory_exhausted); - return p; + return !*endofname(p); } /* - * Same for realloc. + * 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. */ - -static pointer -ckrealloc(pointer p, size_t nbytes) +static void +prehash(union node *n) { - p = realloc(p, nbytes); - if (p == NULL) - error(bb_msg_memory_exhausted); - return p; + struct cmdentry entry; + + if (n->type == NCMD && n->ncmd.args && goodname(n->ncmd.args->narg.text)) + find_command(n->ncmd.args->narg.text, &entry, 0, pathval()); } -/* - * Make a copy of a string in safe storage. +/* ============ Builtin commands + * + * Builtin commands whose functions are closely tied to evaluation + * are implemented here. */ -static char * -savestr(const char *s) +/* + * Handle break and continue commands. Break, continue, and return are + * all handled by setting the evalskip flag. The evaluation routines + * above all check this flag, and if it is set they start skipping + * commands rather than executing them. The variable skipcount is + * the number of loops to break/continue, or the number of function + * levels to return. (The latter is always 1.) It should probably + * be an error to break out of more loops than exist, but it isn't + * in the standard shell so we don't make it one here. + */ +static int +breakcmd(int argc UNUSED_PARAM, char **argv) { - char *p = strdup(s); - if (!p) - error(bb_msg_memory_exhausted); - return p; + int n = argv[1] ? number(argv[1]) : 1; + + if (n <= 0) + ash_msg_and_raise_error(illnum, argv[1]); + if (n > loopnest) + n = loopnest; + if (n > 0) { + evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK; + skipcount = n; + } + return 0; } -/* - * 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. +/* ============ input.c * - * The size 504 was chosen because the Ultrix malloc handles that size - * well. + * This implements the input routines used by the parser. */ +enum { + INPUT_PUSH_FILE = 1, + INPUT_NOFILE_OK = 2, +}; -static pointer -stalloc(size_t nbytes) -{ - char *p; - size_t aligned; +static smallint checkkwd; +/* values of checkkwd variable */ +#define CHKALIAS 0x1 +#define CHKKWD 0x2 +#define CHKNL 0x4 - aligned = SHELL_ALIGN(nbytes); - if (aligned > stacknleft) { - size_t len; - size_t blocksize; - struct stack_block *sp; +/* + * Push a string back onto the input at this current parsefile level. + * We handle aliases this way. + */ +#if !ENABLE_ASH_ALIAS +#define pushstring(s, ap) pushstring(s) +#endif +static void +pushstring(char *s, struct alias *ap) +{ + struct strpush *sp; + int len; - blocksize = aligned; - if (blocksize < MINSIZE) - blocksize = MINSIZE; - len = sizeof(struct stack_block) - MINSIZE + blocksize; - if (len < blocksize) - error(bb_msg_memory_exhausted); - INTOFF; - sp = ckmalloc(len); - sp->prev = stackp; - stacknxt = sp->space; - stacknleft = blocksize; - sstrend = stacknxt + blocksize; - stackp = sp; - INTON; - } - p = stacknxt; - stacknxt += aligned; - stacknleft -= aligned; - return p; + len = strlen(s); + INT_OFF; + if (g_parsefile->strpush) { + sp = ckzalloc(sizeof(*sp)); + sp->prev = g_parsefile->strpush; + } else { + sp = &(g_parsefile->basestrpush); + } + g_parsefile->strpush = sp; + sp->prev_string = g_parsefile->next_to_pgetc; + sp->prev_left_in_line = g_parsefile->left_in_line; +#if ENABLE_ASH_ALIAS + sp->ap = ap; + if (ap) { + ap->flag |= ALIASINUSE; + sp->string = s; + } +#endif + g_parsefile->next_to_pgetc = s; + g_parsefile->left_in_line = len; + INT_ON; } - -void -stunalloc(pointer p) +static void +popstring(void) { -#ifdef DEBUG - if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) { - write(2, "stunalloc\n", 10); - abort(); + struct strpush *sp = g_parsefile->strpush; + + INT_OFF; +#if ENABLE_ASH_ALIAS + if (sp->ap) { + if (g_parsefile->next_to_pgetc[-1] == ' ' + || g_parsefile->next_to_pgetc[-1] == '\t' + ) { + checkkwd |= CHKALIAS; + } + if (sp->string != sp->ap->val) { + free(sp->string); + } + sp->ap->flag &= ~ALIASINUSE; + if (sp->ap->flag & ALIASDEAD) { + unalias(sp->ap->name); + } } #endif - stacknleft += stacknxt - (char *)p; - stacknxt = p; + g_parsefile->next_to_pgetc = sp->prev_string; + g_parsefile->left_in_line = sp->prev_left_in_line; + g_parsefile->strpush = sp->prev; + if (sp != &(g_parsefile->basestrpush)) + free(sp); + INT_ON; } - - -void -setstackmark(struct stackmark *mark) +//FIXME: BASH_COMPAT with "...&" does TWO pungetc(): +//it peeks whether it is &>, and then pushes back both chars. +//This function needs to save last *next_to_pgetc to buf[0] +//to make two pungetc() reliable. Currently, +// pgetc (out of buf: does preadfd), pgetc, pungetc, pungetc won't work... +static int +preadfd(void) { - mark->stackp = stackp; - mark->stacknxt = stacknxt; - mark->stacknleft = stacknleft; - mark->marknext = markp; - markp = mark; -} - + int nr; + char *buf = g_parsefile->buf; -void -popstackmark(struct stackmark *mark) -{ - struct stack_block *sp; + g_parsefile->next_to_pgetc = buf; +#if ENABLE_FEATURE_EDITING + retry: + if (!iflag || g_parsefile->fd != STDIN_FILENO) + nr = nonblock_safe_read(g_parsefile->fd, buf, BUFSIZ - 1); + else { +#if ENABLE_FEATURE_TAB_COMPLETION + line_input_state->path_lookup = pathval(); +#endif + nr = read_line_input(cmdedit_prompt, buf, BUFSIZ, line_input_state); + if (nr == 0) { + /* Ctrl+C pressed */ + if (trap[SIGINT]) { + buf[0] = '\n'; + buf[1] = '\0'; + raise(SIGINT); + return 1; + } + goto retry; + } + if (nr < 0 && errno == 0) { + /* Ctrl+D pressed */ + nr = 0; + } + } +#else + nr = nonblock_safe_read(g_parsefile->fd, buf, BUFSIZ - 1); +#endif - INTOFF; - markp = mark->marknext; - while (stackp != mark->stackp) { - sp = stackp; - stackp = sp->prev; - ckfree(sp); +#if 0 +/* nonblock_safe_read() handles this problem */ + if (nr < 0) { + if (parsefile->fd == 0 && errno == EWOULDBLOCK) { + int flags = fcntl(0, F_GETFL); + if (flags >= 0 && (flags & O_NONBLOCK)) { + flags &= ~O_NONBLOCK; + if (fcntl(0, F_SETFL, flags) >= 0) { + out2str("sh: turning off NDELAY mode\n"); + goto retry; + } + } + } } - stacknxt = mark->stacknxt; - stacknleft = mark->stacknleft; - sstrend = mark->stacknxt + mark->stacknleft; - INTON; +#endif + return nr; } - /* - * When the parser reads in a string, it wants to stick the string on the - * stack and only adjust the stack pointer when it knows how big the - * string is. Stackblock (defined in stack.h) returns a pointer to a block - * of space on top of the stack and stackblocklen returns the length of - * this block. Growstackblock will grow this space by at least one byte, - * possibly moving it (like realloc). Grabstackblock actually allocates the - * part of the block that has been used. + * Refill the input buffer and return the next input character: + * + * 1) If a string was pushed back on the input, pop it; + * 2) If an EOF was pushed back (g_parsefile->left_in_line < -BIGNUM) + * or we are reading from a string so we can't refill the buffer, + * return EOF. + * 3) If the is more stuff in this buffer, use it else call read to fill it. + * 4) Process input up to the next newline, deleting nul characters. */ - -void -growstackblock(void) +//#define pgetc_debug(...) bb_error_msg(__VA_ARGS__) +#define pgetc_debug(...) ((void)0) +/* + * NB: due to SIT(c) internals (syntax_index_table[] vector), + * pgetc() and related functions must return chars SIGN-EXTENDED into ints, + * not zero-extended. Seems fragile to me. Affects only !USE_SIT_FUNCTION case, + * so we can fix it by ditching !USE_SIT_FUNCTION if Unicode requires that. + */ +static int +preadbuffer(void) { - 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; - 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; - sstrend = sp->space + newlen; + char *q; + int more; - /* - * 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; + while (g_parsefile->strpush) { +#if ENABLE_ASH_ALIAS + if (g_parsefile->left_in_line == -1 + && g_parsefile->strpush->ap + && g_parsefile->next_to_pgetc[-1] != ' ' + && g_parsefile->next_to_pgetc[-1] != '\t' + ) { + pgetc_debug("preadbuffer PEOA"); + return PEOA; } - INTON; - } else { - char *oldspace = stacknxt; - int oldlen = stacknleft; - char *p = stalloc(newlen); +#endif + popstring(); + /* try "pgetc" now: */ + pgetc_debug("preadbuffer internal pgetc at %d:%p'%s'", + g_parsefile->left_in_line, + g_parsefile->next_to_pgetc, + g_parsefile->next_to_pgetc); + if (--g_parsefile->left_in_line >= 0) + return (unsigned char)(*g_parsefile->next_to_pgetc++); + } + /* on both branches above g_parsefile->left_in_line < 0. + * "pgetc" needs refilling. + */ - /* free the space we just allocated */ - stacknxt = memcpy(p, oldspace, oldlen); - stacknleft += newlen; + /* -90 is our -BIGNUM. Below we use -99 to mark "EOF on read", + * pungetc() may increment it a few times. + * Assuming it won't increment it to less than -90. + */ + if (g_parsefile->left_in_line < -90 || g_parsefile->buf == NULL) { + pgetc_debug("preadbuffer PEOF1"); + /* even in failure keep left_in_line and next_to_pgetc + * in lock step, for correct multi-layer pungetc. + * left_in_line was decremented before preadbuffer(), + * must inc next_to_pgetc: */ + g_parsefile->next_to_pgetc++; + return PEOF; } -} -static inline void -grabstackblock(size_t len) -{ - len = SHELL_ALIGN(len); - stacknxt += len; - stacknleft -= len; -} - -/* - * 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 - * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is - * grown as necessary. When the user is done, she can just leave the - * string there and refer to it using stackblock(). Or she can allocate - * the space for it using grabstackstr(). If it is necessary to allow - * someone else to use the stack temporarily and then continue to grow - * the string, the user should use grabstack to allocate the space, and - * then call ungrabstr(p) to return to the previous mode of operation. - * - * USTPUTC is like STPUTC except that it doesn't check for overflow. - * CHECKSTACKSPACE can be called before USTPUTC to ensure that there - * is space for at least one character. - */ - -void * -growstackstr(void) -{ - size_t len = stackblocksize(); - if (herefd >= 0 && len >= 1024) { - xwrite(herefd, stackblock(), len); - return stackblock(); + more = g_parsefile->left_in_buffer; + if (more <= 0) { + flush_stdout_stderr(); + again: + more = preadfd(); + if (more <= 0) { + /* don't try reading again */ + g_parsefile->left_in_line = -99; + pgetc_debug("preadbuffer PEOF2"); + g_parsefile->next_to_pgetc++; + return PEOF; + } } - growstackblock(); - return stackblock() + len; -} -/* - * Called from CHECKSTRSPACE. - */ + /* Find out where's the end of line. + * Set g_parsefile->left_in_line + * and g_parsefile->left_in_buffer acordingly. + * NUL chars are deleted. + */ + q = g_parsefile->next_to_pgetc; + for (;;) { + char c; -char * -makestrspace(size_t newlen, char *p) -{ - size_t len = p - stacknxt; - size_t size = stackblocksize(); + more--; - for (;;) { - size_t nleft; + c = *q; + if (c == '\0') { + memmove(q, q + 1, more); + } else { + q++; + if (c == '\n') { + g_parsefile->left_in_line = q - g_parsefile->next_to_pgetc - 1; + break; + } + } - size = stackblocksize(); - nleft = size - len; - if (nleft >= newlen) + if (more <= 0) { + g_parsefile->left_in_line = q - g_parsefile->next_to_pgetc - 1; + if (g_parsefile->left_in_line < 0) + goto again; break; - growstackblock(); + } } - return stackblock() + len; -} + g_parsefile->left_in_buffer = more; -char * -stnputs(const char *s, size_t n, char *p) -{ - p = makestrspace(n, p); - p = mempcpy(p, s, n); - return p; + if (vflag) { + char save = *q; + *q = '\0'; + out2str(g_parsefile->next_to_pgetc); + *q = save; + } + + pgetc_debug("preadbuffer at %d:%p'%s'", + g_parsefile->left_in_line, + g_parsefile->next_to_pgetc, + g_parsefile->next_to_pgetc); + return signed_char2int(*g_parsefile->next_to_pgetc++); } -char * -stputs(const char *s, char *p) +#define pgetc_as_macro() \ + (--g_parsefile->left_in_line >= 0 \ + ? signed_char2int(*g_parsefile->next_to_pgetc++) \ + : preadbuffer() \ + ) + +static int +pgetc(void) { - return stnputs(s, strlen(s), p); + pgetc_debug("pgetc_fast at %d:%p'%s'", + g_parsefile->left_in_line, + g_parsefile->next_to_pgetc, + g_parsefile->next_to_pgetc); + return pgetc_as_macro(); } -/* $NetBSD: mystring.c,v 1.15 2002/11/24 22:35:42 christos Exp $ */ - -/* - * String functions. - * - * number(s) Convert a string of digits to an integer. - * is_number(s) Return true if s is a string of digits. - */ +#if ENABLE_ASH_OPTIMIZE_FOR_SIZE +#define pgetc_fast() pgetc() +#else +#define pgetc_fast() pgetc_as_macro() +#endif /* - * prefix -- see if pfx is a prefix of string. + * Same as pgetc(), but ignores PEOA. */ - -char * -prefix(const char *string, const char *pfx) +#if ENABLE_ASH_ALIAS +static int +pgetc2(void) { - while (*pfx) { - if (*pfx++ != *string++) - return 0; - } - return (char *) string; + int c; + do { + pgetc_debug("pgetc_fast at %d:%p'%s'", + g_parsefile->left_in_line, + g_parsefile->next_to_pgetc, + g_parsefile->next_to_pgetc); + c = pgetc_fast(); + } while (c == PEOA); + return c; } - +#else +#define pgetc2() pgetc() +#endif /* - * Convert a string of digits to an integer, printing an error message on - * failure. + * Read a line from the script. */ - -int -number(const char *s) +static char * +pfgets(char *line, int len) { + char *p = line; + int nleft = len; + int c; - if (! is_number(s)) - error(illnum, s); - return atoi(s); + while (--nleft > 0) { + c = pgetc2(); + if (c == PEOF) { + if (p == line) + return NULL; + break; + } + *p++ = c; + if (c == '\n') + break; + } + *p = '\0'; + return line; } - - /* - * Check for a valid number. This should be elsewhere. + * Undo the last call to pgetc. Only one character may be pushed back. + * PEOF may be pushed back. */ - -int -is_number(const char *p) +static void +pungetc(void) { - do { - if (! is_digit(*p)) - return 0; - } while (*++p != '\0'); - return 1; + g_parsefile->left_in_line++; + g_parsefile->next_to_pgetc--; + pgetc_debug("pushed back to %d:%p'%s'", + g_parsefile->left_in_line, + g_parsefile->next_to_pgetc, + g_parsefile->next_to_pgetc); } - /* - * Produce a possibly single quoted string suitable as input to the shell. - * The return string is allocated on the stack. + * To handle the "." command, a stack of input files is used. Pushfile + * adds a new entry to the stack and popfile restores the previous level. */ +static void +pushfile(void) +{ + struct parsefile *pf; -char * -single_quote(const char *s) { - char *p; - - STARTSTACKSTR(p); - - do { - char *q; - size_t len; - - len = strchrnul(s, '\'') - s; - - q = p = makestrspace(len + 3, p); - - *q++ = '\''; - q = mempcpy(q, s, len); - *q++ = '\''; - s += len; - - STADJUST(q - p, p); - - len = strspn(s, "'"); - if (!len) - break; - - q = p = makestrspace(len + 3, p); - - *q++ = '"'; - q = mempcpy(q, s, len); - *q++ = '"'; - s += len; - - STADJUST(q - p, p); - } while (*s); + pf = ckzalloc(sizeof(*pf)); + pf->prev = g_parsefile; + pf->fd = -1; + /*pf->strpush = NULL; - ckzalloc did it */ + /*pf->basestrpush.prev = NULL;*/ + g_parsefile = pf; +} - USTPUTC(0, p); +static void +popfile(void) +{ + struct parsefile *pf = g_parsefile; - return stackblock(); + INT_OFF; + if (pf->fd >= 0) + close(pf->fd); + free(pf->buf); + while (pf->strpush) + popstring(); + g_parsefile = pf->prev; + free(pf); + INT_ON; } /* - * Like strdup but works with the ash stack. + * Return to top level. */ - -char * -sstrdup(const char *p) -{ - size_t len = strlen(p) + 1; - return memcpy(stalloc(len), p, len); -} - - static void -calcsize(union node *n) +popallfiles(void) { - 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; - }; + while (g_parsefile != &basepf) + popfile(); } - - +/* + * Close the file(s) that the shell is reading commands from. Called + * after a fork is done. + */ static void -sizenodelist(struct nodelist *lp) +closescript(void) { - while (lp) { - funcblocksize += SHELL_ALIGN(sizeof(struct nodelist)); - calcsize(lp->n); - lp = lp->next; + popallfiles(); + if (g_parsefile->fd > 0) { + close(g_parsefile->fd); + g_parsefile->fd = 0; } } - - -static union node * -copynode(union node *n) +/* + * Like setinputfile, but takes an open file descriptor. Call this with + * interrupts off. + */ +static void +setinputfd(int fd, int push) { - 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; + close_on_exec_on(fd); + if (push) { + pushfile(); + g_parsefile->buf = NULL; + } + g_parsefile->fd = fd; + if (g_parsefile->buf == NULL) + g_parsefile->buf = ckmalloc(IBUFSIZ); + g_parsefile->left_in_buffer = 0; + g_parsefile->left_in_line = 0; + g_parsefile->linno = 1; } - -static struct nodelist * -copynodelist(struct nodelist *lp) +/* + * Set the input to take input from a file. If push is set, push the + * old input onto the stack first. + */ +static int +setinputfile(const char *fname, int flags) { - struct nodelist *start; - struct nodelist **lpp; + int fd; + int fd2; - lpp = &start; - while (lp) { - *lpp = funcblock; - funcblock = (char *) funcblock + - SHELL_ALIGN(sizeof(struct nodelist)); - (*lpp)->n = copynode(lp->n); - lp = lp->next; - lpp = &(*lpp)->next; + INT_OFF; + fd = open(fname, O_RDONLY); + if (fd < 0) { + if (flags & INPUT_NOFILE_OK) + goto out; + ash_msg_and_raise_error("can't open '%s'", fname); } - *lpp = NULL; - return start; + if (fd < 10) { + fd2 = copyfd(fd, 10); + close(fd); + if (fd2 < 0) + ash_msg_and_raise_error("out of file descriptors"); + fd = fd2; + } + setinputfd(fd, flags & INPUT_PUSH_FILE); + out: + INT_ON; + return fd; } +/* + * Like setinputfile, but takes input from a string. + */ +static void +setinputstring(char *string) +{ + INT_OFF; + pushfile(); + g_parsefile->next_to_pgetc = string; + g_parsefile->left_in_line = strlen(string); + g_parsefile->buf = NULL; + g_parsefile->linno = 1; + INT_ON; +} -static char * -nodesavestr(char *s) -{ - char *rtn = funcstring; +/* ============ mail.c + * + * Routines to check for mail. + */ - funcstring = stpcpy(funcstring, s) + 1; - return rtn; -} +#if ENABLE_ASH_MAIL +#define MAXMBOXES 10 +/* times of mailboxes */ +static time_t mailtime[MAXMBOXES]; +/* Set if MAIL or MAILPATH is changed. */ +static smallint mail_var_path_changed; /* - * Free a parse tree. + * 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(void) +{ + const char *mpath; + char *p; + char *q; + time_t *mtp; + struct stackmark smark; + struct stat statb; + + setstackmark(&smark); + 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++) + continue; +#if DEBUG + if (q[-1] != '/') + abort(); +#endif + 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" + ); + } + *mtp = statb.st_mtime; + } + mail_var_path_changed = 0; + popstackmark(&smark); +} static void -freefunc(struct funcnode *f) +changemail(const char *val UNUSED_PARAM) { - if (f && --f->count < 0) - ckfree(f); + mail_var_path_changed = 1; } +#endif /* ASH_MAIL */ -static void options(int); -static void setoption(int, int); +/* ============ ??? */ /* - * Process the shell command line arguments. + * Set the shell parameters. */ - -void -procargs(int argc, char **argv) +static void +setparam(char **argv) { - int i; - const char *xminusc; - char **xargv; + char **newparam; + char **ap; + int nparam; - xargv = argv; - arg0 = xargv[0]; - if (argc > 0) - xargv++; - for (i = 0; i < NOPTS; i++) - optlist[i] = 2; - argptr = xargv; - options(1); - 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 (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; + for (nparam = 0; argv[nparam]; nparam++) + continue; + ap = newparam = ckmalloc((nparam + 1) * sizeof(*ap)); + while (*argv) { + *ap++ = ckstrdup(*argv++); } - - shellparam.p = xargv; -#ifdef CONFIG_ASH_GETOPTS + *ap = NULL; + freeparam(&shellparam); + shellparam.malloced = 1; + shellparam.nparam = nparam; + shellparam.p = newparam; +#if ENABLE_ASH_GETOPTS shellparam.optind = 1; shellparam.optoff = -1; #endif - /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */ - while (*xargv) { - shellparam.nparam++; - xargv++; - } - optschanged(); } - -void -optschanged(void) -{ -#ifdef DEBUG - opentrace(); -#endif - setinteractive(iflag); - setjobctl(mflag); -} - -static inline void -minus_o(char *name, int val) +/* + * Process shell options. The global variable argptr contains a pointer + * to the argument list; we advance it past the options. + * + * SUSv3 section 2.8.1 "Consequences of Shell Errors" says: + * For a non-interactive shell, an error condition encountered + * by a special built-in ... shall cause the shell to write a diagnostic message + * to standard error and exit as shown in the following table: + * Error Special Built-In + * ... + * Utility syntax error (option or operand error) Shall exit + * ... + * However, in bug 1142 (http://busybox.net/bugs/view.php?id=1142) + * we see that bash does not do that (set "finishes" with error code 1 instead, + * and shell continues), and people rely on this behavior! + * Testcase: + * set -o barfoo 2>/dev/null + * echo $? + * + * Oh well. Let's mimic that. + */ +static int +plus_minus_o(char *name, int val) { int i; - if (name == NULL) { - out1str("Current option settings\n"); - for (i = 0; i < NOPTS; i++) - out1fmt("%-16s%s\n", optnames(i), - optlist[i] ? "on" : "off"); - } else { - for (i = 0; i < NOPTS; i++) - if (equal(name, optnames(i))) { + if (name) { + for (i = 0; i < NOPTS; i++) { + if (strcmp(name, optnames(i)) == 0) { optlist[i] = val; - return; + return 0; } - error("Illegal option -o %s", name); + } + ash_msg("illegal option %co %s", val ? '-' : '+', name); + return 1; + } + for (i = 0; i < NOPTS; i++) { + if (val) { + out1fmt("%-16s%s\n", optnames(i), optlist[i] ? "on" : "off"); + } else { + out1fmt("set %co %s\n", optlist[i] ? '-' : '+', optnames(i)); + } } + return 0; } - -/* - * Process shell options. The global variable argptr contains a pointer - * to the argument list; we advance it past the options. - */ - static void +setoption(int flag, int val) +{ + int i; + + for (i = 0; i < NOPTS; i++) { + if (optletters(i) == flag) { + optlist[i] = val; + return; + } + } + ash_msg_and_raise_error("illegal option %c%c", val ? '-' : '+', flag); + /* NOTREACHED */ +} +static int options(int cmdline) { char *p; @@ -8736,10 +9841,14 @@ options(int cmdline) if (cmdline) minusc = NULL; while ((p = *argptr) != NULL) { + c = *p++; + if (c != '-' && c != '+') + break; argptr++; - if ((c = *p++) == '-') { + val = 0; /* val = 0 if c == '+' */ + if (c == '-') { val = 1; - if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) { + if (p[0] == '\0' || LONE_DASH(p)) { if (!cmdline) { /* "-" means turn off -x and -v */ if (p[0] == '\0') @@ -8750,20 +9859,23 @@ options(int cmdline) } break; /* "-" or "--" terminates options */ } - } else if (c == '+') { - val = 0; - } else { - argptr--; - break; } + /* first char was + or - */ while ((c = *p++) != '\0') { + /* bash 3.2 indeed handles -c CMD and +c CMD the same */ if (c == 'c' && cmdline) { - minusc = p; /* command is after shell args*/ + minusc = p; /* command is after shell args */ } else if (c == 'o') { - minus_o(*argptr, val); + if (plus_minus_o(*argptr, val)) { + /* it already printed err message */ + return 1; /* error */ + } if (*argptr) argptr++; - } else if (cmdline && (c == '-')) { // long options + } else if (cmdline && (c == 'l')) { /* -l or +l == --login */ + isloginsh = 1; + /* bash does not accept +-login, we also won't */ + } else if (cmdline && val && (c == '-')) { /* long options */ if (strcmp(p, "login") == 0) isloginsh = 1; break; @@ -8772,151 +9884,131 @@ options(int cmdline) } } } + return 0; } - - -static void -setoption(int flag, int val) -{ - int i; - - for (i = 0; i < NOPTS; i++) - if (optletters(i) == flag) { - optlist[i] = val; - return; - } - error("Illegal option -%c", flag); - /* NOTREACHED */ -} - - - -/* - * Set the shell parameters. - */ - -void -setparam(char **argv) -{ - char **newparam; - char **ap; - int nparam; - - for (nparam = 0 ; argv[nparam] ; nparam++); - ap = newparam = ckmalloc((nparam + 1) * sizeof *ap); - while (*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 -} - - -/* - * Free the list of positional parameters. - */ - -void -freeparam(volatile struct shparam *param) -{ - char **ap; - - if (param->malloc) { - for (ap = param->p ; *ap ; ap++) - ckfree(*ap); - ckfree(param->p); - } -} - - - /* * The shift builtin command. */ - -int -shiftcmd(int argc, char **argv) +static int +shiftcmd(int argc UNUSED_PARAM, char **argv) { int n; char **ap1, **ap2; n = 1; - if (argc > 1) + if (argv[1]) n = number(argv[1]); if (n > shellparam.nparam) - error("can't shift that many"); - INTOFF; + n = 0; /* bash compat, was = shellparam.nparam; */ + INT_OFF; shellparam.nparam -= n; - for (ap1 = shellparam.p ; --n >= 0 ; ap1++) { - if (shellparam.malloc) - ckfree(*ap1); + for (ap1 = shellparam.p; --n >= 0; ap1++) { + if (shellparam.malloced) + free(*ap1); } ap2 = shellparam.p; - while ((*ap2++ = *ap1++) != NULL); -#ifdef CONFIG_ASH_GETOPTS + while ((*ap2++ = *ap1++) != NULL) + continue; +#if ENABLE_ASH_GETOPTS shellparam.optind = 1; shellparam.optoff = -1; #endif - INTON; + INT_ON; return 0; } - - /* - * The set command builtin. + * 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... */ - -int -setcmd(int argc, char **argv) +static int +showvars(const char *sep_prefix, int on, int off) { - if (argc == 1) - return showvars(nullstr, 0, VUNSET); - INTOFF; - options(0); - optschanged(); - if (*argptr != NULL) { - setparam(argptr); + const char *sep; + char **ep, **epend; + + ep = listvars(on, off, &epend); + qsort(ep, epend - ep, sizeof(char *), vpcmp); + + sep = *sep_prefix ? " " : 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); } - INTON; return 0; } - -#ifdef CONFIG_ASH_GETOPTS -static void -getoptsreset(value) - const char *value; +/* + * The set command builtin. + */ +static int +setcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { - shellparam.optind = number(value); - shellparam.optoff = -1; -} -#endif + int retval; -#ifdef CONFIG_LOCALE_SUPPORT -static void change_lc_all(const char *value) -{ - if (value != 0 && *value != 0) - setlocale(LC_ALL, value); + if (!argv[1]) + return showvars(nullstr, 0, VUNSET); + INT_OFF; + retval = 1; + if (!options(0)) { /* if no parse error... */ + retval = 0; + optschanged(); + if (*argptr != NULL) { + setparam(argptr); + } + } + INT_ON; + return retval; } -static void change_lc_ctype(const char *value) -{ - if (value != 0 && *value != 0) - setlocale(LC_CTYPE, value); +#if ENABLE_ASH_RANDOM_SUPPORT +static void +change_random(const char *value) +{ + /* Galois LFSR parameter */ + /* Taps at 32 31 29 1: */ + enum { MASK = 0x8000000b }; + /* Another example - taps at 32 31 30 10: */ + /* MASK = 0x00400007 */ + + if (value == NULL) { + /* "get", generate */ + uint32_t t; + + /* LCG has period of 2^32 and alternating lowest bit */ + random_LCG = 1664525 * random_LCG + 1013904223; + /* Galois LFSR has period of 2^32-1 = 3 * 5 * 17 * 257 * 65537 */ + t = (random_galois_LFSR << 1); + if (random_galois_LFSR < 0) /* if we just shifted 1 out of msb... */ + t ^= MASK; + random_galois_LFSR = t; + /* Both are weak, combining them gives better randomness + * and ~2^64 period. & 0x7fff is probably bash compat + * for $RANDOM range. Combining with subtraction is + * just for fun. + and ^ would work equally well. */ + t = (t - random_LCG) & 0x7fff; + /* set without recursion */ + setvar(vrandom.text, utoa(t), VNOFUNC); + vrandom.flags &= ~VNOFUNC; + } else { + /* set/reset */ + random_galois_LFSR = random_LCG = strtoul(value, (char **)NULL, 10); + } } - #endif -#ifdef CONFIG_ASH_GETOPTS +#if ENABLE_ASH_GETOPTS static int getopts(char *optstr, char *optvar, char **optfirst, int *param_optind, int *optoff) { @@ -8924,32 +10016,33 @@ getopts(char *optstr, char *optvar, char **optfirst, int *param_optind, int *opt char c = '?'; int done = 0; int err = 0; - char s[10]; - char **optnext = optfirst + *param_optind - 1; + char s[12]; + char **optnext; + + if (*param_optind < 1) + return 1; + optnext = optfirst + *param_optind - 1; - if (*param_optind <= 1 || *optoff < 0 || !(*(optnext - 1)) || - strlen(*(optnext - 1)) < *optoff) + if (*param_optind <= 1 || *optoff < 0 || (int)strlen(optnext[-1]) < *optoff) p = NULL; else - p = *(optnext - 1) + *optoff; + p = optnext[-1] + *optoff; if (p == NULL || *p == '\0') { /* Current word is done, advance */ - if (optnext == NULL) - return 1; p = *optnext; if (p == NULL || *p != '-' || *++p == '\0') { -atend: + atend: p = NULL; done = 1; goto out; } optnext++; - if (p[0] == '-' && p[1] == '\0') /* check for "--" */ + if (LONE_DASH(p)) /* 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; @@ -8957,7 +10050,7 @@ atend: err |= setvarsafe("OPTARG", s, 0); } else { fprintf(stderr, "Illegal option -%c\n", c); - (void) unsetvar("OPTARG"); + unsetvar("OPTARG"); } c = '?'; goto out; @@ -8975,7 +10068,7 @@ atend: c = ':'; } else { fprintf(stderr, "No arg for -%c option\n", c); - (void) unsetvar("OPTARG"); + unsetvar("OPTARG"); c = '?'; } goto out; @@ -8987,8 +10080,7 @@ atend: p = NULL; } else err |= setvarsafe("OPTARG", nullstr, 0); - -out: + out: *optoff = p ? p - *(optnext - 1) : -1; *param_optind = optnext - optfirst + 1; fmtstr(s, sizeof(s), "%d", *param_optind); @@ -8999,8 +10091,8 @@ out: if (err) { *param_optind = 1; *optoff = -1; - flushall(); - exraise(EXERROR); + flush_stdout_stderr(); + raise_exception(EXERROR); } return done; } @@ -9011,22 +10103,20 @@ out: * be processed in the current argument. If shellparam.optnext is NULL, * then it's the first time getopts has been called. */ - -int +static int getoptscmd(int argc, char **argv) { char **optbase; if (argc < 3) - error("Usage: getopts optstring var [arg]"); - else if (argc == 3) { + ash_msg_and_raise_error("usage: getopts optstring var [arg]"); + if (argc == 3) { optbase = shellparam.p; if (shellparam.optind > shellparam.nparam + 1) { shellparam.optind = 1; shellparam.optoff = -1; } - } - else { + } else { optbase = &argv[3]; if (shellparam.optind > argc - 2) { shellparam.optind = 1; @@ -9035,218 +10125,64 @@ getoptscmd(int argc, char **argv) } 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 - * library getopt must have the BSD extension static variable "optreset" - * otherwise it can't be used within the shell safely. - * - * Standard option processing (a la getopt) for builtin routines. The - * only argument that is passed to nextopt is the option string; the - * other arguments are unnecessary. It return the character, or '\0' on - * end of input. - */ - -static int -nextopt(const char *optstring) -{ - char *p; - const char *q; - char c; - - if ((p = optptr) == NULL || *p == '\0') { - p = *argptr; - if (p == NULL || *p != '-' || *++p == '\0') - return '\0'; - argptr++; - if (p[0] == '-' && p[1] == '\0') /* check for "--" */ - return '\0'; - } - c = *p++; - for (q = optstring ; *q != c ; ) { - if (*q == '\0') - error("Illegal option -%c", c); - if (*++q == ':') - q++; - } - if (*++q == ':') { - if (*p == '\0' && (p = *argptr++) == NULL) - error("No arg for -%c option", c); - optionarg = p; - p = NULL; - } - optptr = p; - return c; -} - -/* $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; + &shellparam.optoff); } +#endif /* ASH_GETOPTS */ -static int -out1fmt(const char *fmt, ...) -{ - va_list ap; - int r; - - INTOFF; - va_start(ap, fmt); - 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; -} +/* ============ Shell parser */ +struct heredoc { + struct heredoc *next; /* next here document in list */ + union node *here; /* redirection node */ + char *eofmark; /* string indicating end of input */ + smallint striptabs; /* if set, strip leading tabs */ +}; +static smallint tokpushback; /* last token pushed back */ +static smallint parsebackquote; /* nonzero if we are inside backquotes */ +static smallint quoteflag; /* set if (part of) last token was quoted */ +static token_id_t lasttoken; /* last token read (integer id Txxx) */ +static struct heredoc *heredoclist; /* list of here documents to read */ +static char *wordtext; /* text of last word returned by readtoken */ +static struct nodelist *backquotelist; +static union node *redirnode; +static struct heredoc *heredoc; /* - * Version of write which resumes after a signal is caught. + * 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 NEOF ((union node *)&tokpushback) +/* + * Called when an unexpected token is read during the parse. The argument + * is the token that is expected, or -1 if more than one type of token can + * occur at this point. + */ +static void raise_error_unexpected_syntax(int) NORETURN; static void -xwrite(int fd, const void *p, size_t n) +raise_error_unexpected_syntax(int token) { - ssize_t i; + char msg[64]; + int l; - do { - i = bb_full_write(fd, p, n); - } while (i < 0 && errno == EINTR); + l = sprintf(msg, "unexpected %s", tokname(lasttoken)); + if (token >= 0) + sprintf(msg + l, " (expecting %s)", tokname(token)); + raise_error_syntax(msg); + /* NOTREACHED */ } - -/* $NetBSD: parser.c,v 1.54 2002/11/24 22:35:42 christos Exp $ */ - - -/* - * Shell command parser. - */ - #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 */ -}; - - - -static struct heredoc *heredoclist; /* list of here documents to read */ - - -static union node *list(int); +/* parsing is heavily cross-recursive, need these forward decls */ static union node *andor(void); static union node *pipeline(void); -static union node *command(void); -static union node *simplecmd(void); -static union node *makename(void); -static void parsefname(void); +static union node *parse_command(void); static void parseheredoc(void); static char peektoken(void); static int readtoken(void); -static int xxreadtoken(void); -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 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.) - */ - -union node * -parsecmd(int interact) -{ - int t; - - tokpushback = 0; - doprompt = interact; - if (doprompt) - setprompt(doprompt); - needprompt = 0; - t = readtoken(); - if (t == TEOF) - return NEOF; - if (t == TNL) - return NULL; - tokpushback++; - return list(1); -} - static union node * list(int nlflag) @@ -9263,12 +10199,12 @@ list(int nlflag) tok = readtoken(); if (tok == TBACKGND) { if (n2->type == NPIPE) { - n2->npipe.backgnd = 1; + n2->npipe.pipe_backgnd = 1; } else { if (n2->type != NREDIR) { - n3 = stalloc(sizeof(struct nredir)); + n3 = stzalloc(sizeof(struct nredir)); n3->nredir.n = n2; - n3->nredir.redirect = NULL; + /*n3->nredir.redirect = NULL; - stzalloc did it */ n2 = n3; } n2->type = NBACKGND; @@ -9276,9 +10212,8 @@ list(int nlflag) } if (n1 == NULL) { n1 = n2; - } - else { - n3 = (union node *)stalloc(sizeof (struct nbinary)); + } else { + n3 = stzalloc(sizeof(struct nbinary)); n3->type = NSEMI; n3->nbinary.ch1 = n1; n3->nbinary.ch2 = n2; @@ -9295,7 +10230,7 @@ list(int nlflag) if (nlflag == 1) return n1; } else { - tokpushback++; + tokpushback = 1; } checkkwd = CHKNL | CHKKWD | CHKALIAS; if (peektoken()) @@ -9309,15 +10244,13 @@ list(int nlflag) return n1; default: if (nlflag == 1) - synexpect(-1); - tokpushback++; + raise_error_unexpected_syntax(-1); + tokpushback = 1; return n1; } } } - - static union node * andor(void) { @@ -9326,17 +10259,18 @@ andor(void) n1 = pipeline(); for (;;) { - if ((t = readtoken()) == TAND) { + t = readtoken(); + if (t == TAND) { t = NAND; } else if (t == TOR) { t = NOR; } else { - tokpushback++; + tokpushback = 1; return n1; } checkkwd = CHKNL | CHKKWD | CHKALIAS; n2 = pipeline(); - n3 = (union node *)stalloc(sizeof (struct nbinary)); + n3 = stzalloc(sizeof(struct nbinary)); n3->type = t; n3->nbinary.ch1 = n1; n3->nbinary.ch2 = n2; @@ -9344,8 +10278,6 @@ andor(void) } } - - static union node * pipeline(void) { @@ -9359,39 +10291,226 @@ pipeline(void) negate = !negate; checkkwd = CHKKWD | CHKALIAS; } else - tokpushback++; - n1 = command(); + tokpushback = 1; + n1 = parse_command(); if (readtoken() == TPIPE) { - pipenode = (union node *)stalloc(sizeof (struct npipe)); + pipenode = stzalloc(sizeof(struct npipe)); pipenode->type = NPIPE; - pipenode->npipe.backgnd = 0; - lp = (struct nodelist *)stalloc(sizeof (struct nodelist)); + /*pipenode->npipe.pipe_backgnd = 0; - stzalloc did it */ + lp = stzalloc(sizeof(struct nodelist)); pipenode->npipe.cmdlist = lp; lp->n = n1; do { prev = lp; - lp = (struct nodelist *)stalloc(sizeof (struct nodelist)); + lp = stzalloc(sizeof(struct nodelist)); checkkwd = CHKNL | CHKKWD | CHKALIAS; - lp->n = command(); + lp->n = parse_command(); prev->next = lp; } while (readtoken() == TPIPE); lp->next = NULL; n1 = pipenode; } - tokpushback++; + tokpushback = 1; if (negate) { - n2 = (union node *)stalloc(sizeof (struct nnot)); + n2 = stzalloc(sizeof(struct nnot)); n2->type = NNOT; n2->nnot.com = n1; return n2; - } else - return n1; + } + return n1; +} + +static union node * +makename(void) +{ + union node *n; + + n = stzalloc(sizeof(struct narg)); + n->type = NARG; + /*n->narg.next = NULL; - stzalloc did it */ + n->narg.text = wordtext; + n->narg.backquote = backquotelist; + return n; +} + +static void +fixredir(union node *n, const char *text, int err) +{ + int fd; + + TRACE(("Fix redir %s %d\n", text, err)); + if (!err) + n->ndup.vname = NULL; + + fd = bb_strtou(text, NULL, 10); + if (!errno && fd >= 0) + n->ndup.dupfd = fd; + else if (LONE_DASH(text)) + n->ndup.dupfd = -1; + else { + if (err) + raise_error_syntax("bad fd number"); + n->ndup.vname = makename(); + } } +/* + * Returns true if the text contains nothing to expand (no dollar signs + * or backquotes). + */ +static int +noexpand(const char *text) +{ + const char *p; + char c; + p = text; + while ((c = *p++) != '\0') { + if (c == CTLQUOTEMARK) + continue; + if (c == CTLESC) + p++; + else if (SIT((signed char)c, BASESYNTAX) == CCTL) + return 0; + } + return 1; +} + +static void +parsefname(void) +{ + union node *n = redirnode; + + if (readtoken() != TWORD) + raise_error_unexpected_syntax(-1); + if (n->type == NHERE) { + struct heredoc *here = heredoc; + struct heredoc *p; + int i; + + if (quoteflag == 0) + n->type = NXHERE; + TRACE(("Here document %d\n", n->type)); + if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN) + raise_error_syntax("illegal eof marker for << redirection"); + rmescapes(wordtext); + here->eofmark = wordtext; + here->next = NULL; + if (heredoclist == NULL) + heredoclist = here; + else { + for (p = heredoclist; p->next; p = p->next) + continue; + p->next = here; + } + } else if (n->type == NTOFD || n->type == NFROMFD) { + fixredir(n, wordtext, 0); + } else { + n->nfile.fname = makename(); + } +} static union node * -command(void) +simplecmd(void) +{ + union node *args, **app; + union node *n = NULL; + union node *vars, **vpp; + union node **rpp, *redir; + int savecheckkwd; +#if ENABLE_ASH_BASH_COMPAT + smallint double_brackets_flag = 0; +#endif + + args = NULL; + app = &args; + vars = NULL; + vpp = &vars; + redir = NULL; + rpp = &redir; + + savecheckkwd = CHKALIAS; + for (;;) { + int t; + checkkwd = savecheckkwd; + t = readtoken(); + switch (t) { +#if ENABLE_ASH_BASH_COMPAT + case TAND: /* "&&" */ + case TOR: /* "||" */ + if (!double_brackets_flag) { + tokpushback = 1; + goto out; + } + wordtext = (char *) (t == TAND ? "-a" : "-o"); +#endif + case TWORD: + n = stzalloc(sizeof(struct narg)); + n->type = NARG; + /*n->narg.next = NULL; - stzalloc did it */ + n->narg.text = wordtext; +#if ENABLE_ASH_BASH_COMPAT + if (strcmp("[[", wordtext) == 0) + double_brackets_flag = 1; + else if (strcmp("]]", wordtext) == 0) + double_brackets_flag = 0; +#endif + n->narg.backquote = backquotelist; + 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 */ + break; + case TLP: + if (args && app == &args->narg.next + && !vars && !redir + ) { + struct builtincmd *bcmd; + const char *name; + + /* We have a function */ + if (readtoken() != TRP) + raise_error_unexpected_syntax(TRP); + name = n->narg.text; + if (!goodname(name) + || ((bcmd = find_builtin(name)) && IS_BUILTIN_SPECIAL(bcmd)) + ) { + raise_error_syntax("bad function name"); + } + n->type = NDEFUN; + checkkwd = CHKNL | CHKKWD | CHKALIAS; + n->narg.next = parse_command(); + return n; + } + /* fall through */ + default: + tokpushback = 1; + goto out; + } + } + out: + *app = NULL; + *vpp = NULL; + *rpp = NULL; + n = stzalloc(sizeof(struct ncmd)); + n->type = NCMD; + n->ncmd.args = args; + n->ncmd.assign = vars; + n->ncmd.redirect = redir; + return n; +} + +static union node * +parse_command(void) { union node *n1, *n2; union node *ap, **app; @@ -9405,59 +10524,62 @@ command(void) switch (readtoken()) { default: - synexpect(-1); + raise_error_unexpected_syntax(-1); /* NOTREACHED */ case TIF: - n1 = (union node *)stalloc(sizeof (struct nif)); + n1 = stzalloc(sizeof(struct nif)); n1->type = NIF; n1->nif.test = list(0); if (readtoken() != TTHEN) - synexpect(TTHEN); + raise_error_unexpected_syntax(TTHEN); n1->nif.ifpart = list(0); n2 = n1; while (readtoken() == TELIF) { - n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif)); + n2->nif.elsepart = stzalloc(sizeof(struct nif)); n2 = n2->nif.elsepart; n2->type = NIF; n2->nif.test = list(0); if (readtoken() != TTHEN) - synexpect(TTHEN); + raise_error_unexpected_syntax(TTHEN); n2->nif.ifpart = list(0); } if (lasttoken == TELSE) n2->nif.elsepart = list(0); else { n2->nif.elsepart = NULL; - tokpushback++; + tokpushback = 1; } t = TFI; break; case TWHILE: case TUNTIL: { int got; - n1 = (union node *)stalloc(sizeof (struct nbinary)); - n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL; + n1 = stzalloc(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 : "")); - synexpect(TDO); + got = readtoken(); + if (got != TDO) { + TRACE(("expecting DO got %s %s\n", tokname(got), + got == TWORD ? wordtext : "")); + raise_error_unexpected_syntax(TDO); } n1->nbinary.ch2 = list(0); t = TDONE; break; } case TFOR: - if (readtoken() != TWORD || quoteflag || ! goodname(wordtext)) - synerror("Bad for loop variable"); - n1 = (union node *)stalloc(sizeof (struct nfor)); + if (readtoken() != TWORD || quoteflag || !goodname(wordtext)) + raise_error_syntax("bad for loop variable"); + n1 = stzalloc(sizeof(struct nfor)); n1->type = NFOR; n1->nfor.var = wordtext; checkkwd = CHKKWD | CHKALIAS; if (readtoken() == TIN) { app = ≈ while (readtoken() == TWORD) { - n2 = (union node *)stalloc(sizeof (struct narg)); + n2 = stzalloc(sizeof(struct narg)); n2->type = NARG; + /*n2->narg.next = NULL; - stzalloc did it */ n2->narg.text = wordtext; n2->narg.backquote = backquotelist; *app = n2; @@ -9466,55 +10588,56 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : "")); *app = NULL; n1->nfor.args = ap; if (lasttoken != TNL && lasttoken != TSEMI) - synexpect(-1); + raise_error_unexpected_syntax(-1); } else { - n2 = (union node *)stalloc(sizeof (struct narg)); + n2 = stzalloc(sizeof(struct narg)); n2->type = NARG; + /*n2->narg.next = NULL; - stzalloc did it */ n2->narg.text = (char *)dolatstr; - n2->narg.backquote = NULL; - n2->narg.next = NULL; + /*n2->narg.backquote = NULL;*/ n1->nfor.args = n2; /* * Newline or semicolon here is optional (but note * that the original Bourne shell only allowed NL). */ if (lasttoken != TNL && lasttoken != TSEMI) - tokpushback++; + tokpushback = 1; } checkkwd = CHKNL | CHKKWD | CHKALIAS; if (readtoken() != TDO) - synexpect(TDO); + raise_error_unexpected_syntax(TDO); n1->nfor.body = list(0); t = TDONE; break; case TCASE: - n1 = (union node *)stalloc(sizeof (struct ncase)); + n1 = stzalloc(sizeof(struct ncase)); n1->type = NCASE; if (readtoken() != TWORD) - synexpect(TWORD); - n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg)); + raise_error_unexpected_syntax(TWORD); + n1->ncase.expr = n2 = stzalloc(sizeof(struct narg)); n2->type = NARG; + /*n2->narg.next = NULL; - stzalloc did it */ n2->narg.text = wordtext; n2->narg.backquote = backquotelist; - n2->narg.next = NULL; do { checkkwd = CHKKWD | CHKALIAS; } while (readtoken() == TNL); if (lasttoken != TIN) - synexpect(TIN); + raise_error_unexpected_syntax(TIN); cpp = &n1->ncase.cases; -next_case: + next_case: checkkwd = CHKNL | CHKKWD; t = readtoken(); - while(t != TESAC) { + while (t != TESAC) { if (lasttoken == TLP) readtoken(); - *cpp = cp = (union node *)stalloc(sizeof (struct nclist)); + *cpp = cp = stzalloc(sizeof(struct nclist)); cp->type = NCLIST; app = &cp->nclist.pattern; for (;;) { - *app = ap = (union node *)stalloc(sizeof (struct narg)); + *app = ap = stzalloc(sizeof(struct narg)); ap->type = NARG; + /*ap->narg.next = NULL; - stzalloc did it */ ap->narg.text = wordtext; ap->narg.backquote = backquotelist; if (readtoken() != TPIPE) @@ -9522,28 +10645,28 @@ next_case: app = &ap->narg.next; readtoken(); } - ap->narg.next = NULL; + //ap->narg.next = NULL; if (lasttoken != TRP) - synexpect(TRP); + raise_error_unexpected_syntax(TRP); cp->nclist.body = list(2); cpp = &cp->nclist.next; checkkwd = CHKNL | CHKKWD; - if ((t = readtoken()) != TESAC) { + t = readtoken(); + if (t != TESAC) { if (t != TENDCASE) - synexpect(TENDCASE); - else - goto next_case; + raise_error_unexpected_syntax(TENDCASE); + goto next_case; } } *cpp = NULL; goto redir; case TLP: - n1 = (union node *)stalloc(sizeof (struct nredir)); + n1 = stzalloc(sizeof(struct nredir)); n1->type = NSUBSHELL; n1->nredir.n = list(0); - n1->nredir.redirect = NULL; + /*n1->nredir.redirect = NULL; - stzalloc did it */ t = TRP; break; case TBEGIN: @@ -9552,14 +10675,14 @@ next_case: break; case TWORD: case TREDIR: - tokpushback++; + tokpushback = 1; return simplecmd(); } if (readtoken() != t) - synexpect(t); + raise_error_unexpected_syntax(t); -redir: + redir: /* Now check for redirection which may follow command */ checkkwd = CHKKWD | CHKALIAS; rpp = rpp2; @@ -9568,445 +10691,65 @@ redir: rpp = &n2->nfile.next; parsefname(); } - tokpushback++; + tokpushback = 1; *rpp = NULL; if (redir) { if (n1->type != NSUBSHELL) { - n2 = (union node *)stalloc(sizeof (struct nredir)); + n2 = stzalloc(sizeof(struct nredir)); n2->type = NREDIR; n2->nredir.n = n1; n1 = n2; } n1->nredir.redirect = redir; } - return n1; } - -static union node * -simplecmd(void) { - union node *args, **app; - union node *n = NULL; - union node *vars, **vpp; - union node **rpp, *redir; - int savecheckkwd; - - args = NULL; - app = &args; - vars = NULL; - vpp = &vars; - redir = NULL; - rpp = &redir; - - savecheckkwd = CHKALIAS; - for (;;) { - checkkwd = savecheckkwd; - switch (readtoken()) { - case TWORD: - n = (union node *)stalloc(sizeof (struct narg)); - n->type = NARG; - n->narg.text = wordtext; - n->narg.backquote = backquotelist; - 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 */ - break; - case TLP: - 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 = CHKNL | CHKKWD | CHKALIAS; - n->narg.next = command(); - return n; - } - /* fall through */ - default: - tokpushback++; - goto out; - } - } -out: - *app = NULL; - *vpp = NULL; - *rpp = NULL; - n = (union node *)stalloc(sizeof (struct ncmd)); - n->type = NCMD; - n->ncmd.args = args; - n->ncmd.assign = vars; - n->ncmd.redirect = redir; - return n; -} - -static union node * -makename(void) -{ - union node *n; - - n = (union node *)stalloc(sizeof (struct narg)); - n->type = NARG; - n->narg.next = NULL; - n->narg.text = wordtext; - n->narg.backquote = backquotelist; - return n; -} - -void fixredir(union node *n, const char *text, int err) -{ - TRACE(("Fix redir %s %d\n", text, err)); - if (!err) - n->ndup.vname = NULL; - - if (is_digit(text[0]) && text[1] == '\0') - n->ndup.dupfd = digit_val(text[0]); - else if (text[0] == '-' && text[1] == '\0') - n->ndup.dupfd = -1; - else { - - if (err) - synerror("Bad fd number"); - else - n->ndup.vname = makename(); - } -} - - -static void -parsefname(void) -{ - union node *n = redirnode; - - if (readtoken() != TWORD) - synexpect(-1); - if (n->type == NHERE) { - struct heredoc *here = heredoc; - struct heredoc *p; - int i; - - if (quoteflag == 0) - n->type = NXHERE; - TRACE(("Here document %d\n", n->type)); - if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN) - synerror("Illegal eof marker for << redirection"); - rmescapes(wordtext); - here->eofmark = wordtext; - here->next = NULL; - if (heredoclist == NULL) - heredoclist = here; - else { - for (p = heredoclist ; p->next ; p = p->next); - p->next = here; - } - } else if (n->type == NTOFD || n->type == NFROMFD) { - fixredir(n, wordtext, 0); - } else { - n->nfile.fname = makename(); - } -} - - -/* - * Input any here documents. - */ - -static void -parseheredoc(void) -{ - struct heredoc *here; - union node *n; - - 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)); - 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(void) -{ - int t; - - t = readtoken(); - tokpushback++; - return tokname_array[t][0]; -} - -static int -readtoken(void) +#if ENABLE_ASH_BASH_COMPAT +static int decode_dollar_squote(void) { - int t; -#ifdef DEBUG - int alreadyseen = tokpushback; -#endif - -#ifdef CONFIG_ASH_ALIAS -top: -#endif - - t = xxreadtoken(); - - /* - * eat newlines - */ - if (checkkwd & CHKNL) { - while (t == TNL) { - parseheredoc(); - t = xxreadtoken(); - } - } - - if (t != TWORD || quoteflag) { - goto out; - } - - /* - * check for keywords - */ - if (checkkwd & CHKKWD) { - const char *const *pp; - - if ((pp = findkwd(wordtext))) { - lasttoken = t = pp - tokname_array; - TRACE(("keyword %s recognized\n", tokname(t))); - goto out; - } - } + static const char C_escapes[] ALIGN1 = "nrbtfav""x\\01234567"; + int c, cnt; + char *p; + char buf[4]; - if (checkkwd & CHKALIAS) { -#ifdef CONFIG_ASH_ALIAS - struct alias *ap; - if ((ap = lookupalias(wordtext, 1)) != NULL) { - if (*ap->val) { - pushstring(ap->val, ap); + c = pgetc(); + p = strchr(C_escapes, c); + if (p) { + buf[0] = c; + p = buf; + cnt = 3; + if ((unsigned char)(c - '0') <= 7) { /* \ooo */ + do { + c = pgetc(); + *++p = c; + } while ((unsigned char)(c - '0') <= 7 && --cnt); + pungetc(); + } else if (c == 'x') { /* \xHH */ + do { + c = pgetc(); + *++p = c; + } while (isxdigit(c) && --cnt); + pungetc(); + if (cnt == 3) { /* \x but next char is "bad" */ + c = 'x'; + goto unrecognized; } - goto top; + } else { /* simple seq like \\ or \t */ + p++; } -#endif - } -out: - checkkwd = 0; -#ifdef DEBUG - if (!alreadyseen) - TRACE(("token %s %s\n", tokname(t), t == TWORD ? wordtext : "")); - else - TRACE(("reread token %s %s\n", tokname(t), t == TWORD ? wordtext : "")); -#endif - return (t); -} - - -/* - * Read the next input token. - * If the token is a word, we set backquotelist to the list of cmds in - * backquotes. We set quoteflag to true if any part of the word was - * quoted. - * If the token is TREDIR, then we set redirnode to a structure containing - * the redirection. - * In all cases, the variable startlinno is set to the number of the line - * on which the token starts. - * - * [Change comment: here documents and internal procedures] - * [Readtoken shouldn't have any arguments. Perhaps we should make the - * word parsing code into a separate routine. In this case, readtoken - * doesn't need to have any internal procedures, but parseword does. - * We could also make parseoperator in essence the main routine, and - * have parseword (readtoken1?) handle both words and redirection.] - */ - -#define NEW_xxreadtoken -#ifdef NEW_xxreadtoken - -/* singles must be first! */ -static const char xxreadtoken_chars[7] = { '\n', '(', ')', '&', '|', ';', 0 }; - -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; - if (doprompt) - setprompt(2); - } 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]; - } + *p = '\0'; + p = buf; + c = bb_process_escape_sequence((void*)&p); + } else { /* unrecognized "\z": print both chars unless ' or " */ + if (c != '\'' && c != '"') { + unrecognized: + c |= 0x100; /* "please encode \, then me" */ } } + return c; } - - -#else -#define RETURN(token) return lasttoken = token - -static int -xxreadtoken(void) -{ - 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(); - switch (c) { - case ' ': case '\t': -#ifdef CONFIG_ASH_ALIAS - case PEOA: #endif - continue; - case '#': - while ((c = pgetc()) != '\n' && c != PEOF); - pungetc(); - continue; - case '\\': - if (pgetc() == '\n') { - startlinno = ++plinno; - if (doprompt) - setprompt(2); - continue; - } - pungetc(); - goto breakloop; - case '\n': - plinno++; - needprompt = doprompt; - RETURN(TNL); - case PEOF: - RETURN(TEOF); - case '&': - if (pgetc() == '&') - RETURN(TAND); - pungetc(); - RETURN(TBACKGND); - case '|': - if (pgetc() == '|') - RETURN(TOR); - pungetc(); - RETURN(TPIPE); - case ';': - if (pgetc() == ';') - RETURN(TENDCASE); - pungetc(); - RETURN(TSEMI); - case '(': - RETURN(TLP); - case ')': - RETURN(TRP); - default: - goto breakloop; - } - } -breakloop: - return readtoken1(c, BASESYNTAX, (char *)NULL, 0); -#undef RETURN -} -#endif /* NEW_xxreadtoken */ - /* * If eofmark is NULL, read a word or a redirection symbol. If eofmark @@ -10019,30 +10762,35 @@ breakloop: * using goto's to implement the subroutine linkage. The following macros * will run code that appears at the end of readtoken1. */ - #define CHECKEND() {goto checkend; checkend_return:;} #define PARSEREDIR() {goto parseredir; parseredir_return:;} #define PARSESUB() {goto parsesub; parsesub_return:;} #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;} #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;} #define PARSEARITH() {goto parsearith; parsearith_return:;} - static int readtoken1(int firstc, int syntax, char *eofmark, int striptabs) { + /* NB: syntax parameter fits into smallint */ int c = firstc; char *out; int len; char line[EOFMARKLEN + 1]; 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 oldstyle; - int prevsyntax; /* syntax before arithmetic */ + smallint quotef; + smallint dblquote; + smallint oldstyle; + smallint prevsyntax; /* syntax before arithmetic */ +#if ENABLE_ASH_EXPAND_PRMT + smallint pssyntax; /* we are expanding a prompt string */ +#endif + 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 */ + + USE_ASH_BASH_COMPAT(smallint bash_dollar_squote = 0;) + #if __GNUC__ /* Avoid longjmp clobbering */ (void) &out; @@ -10056,29 +10804,35 @@ readtoken1(int firstc, int syntax, char *eofmark, int striptabs) (void) &prevsyntax; (void) &syntax; #endif - - startlinno = plinno; - dblquote = 0; - if (syntax == DQSYNTAX) - dblquote = 1; - quotef = 0; + startlinno = g_parsefile->linno; bqlist = NULL; + quotef = 0; + oldstyle = 0; + prevsyntax = 0; +#if ENABLE_ASH_EXPAND_PRMT + pssyntax = (syntax == PSSYNTAX); + if (pssyntax) + syntax = DQSYNTAX; +#endif + dblquote = (syntax == DQSYNTAX); varnest = 0; arinest = 0; parenlevel = 0; dqvarnest = 0; STARTSTACKSTR(out); - loop: { /* for each line, until end of word */ + 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)) { + switch (SIT(c, syntax)) { case CNL: /* '\n' */ if (syntax == BASESYNTAX) goto endword; /* exit outer loop */ USTPUTC(c, out); - plinno++; + g_parsefile->linno++; if (doprompt) setprompt(2); c = pgetc(); @@ -10089,6 +10843,15 @@ readtoken1(int firstc, int syntax, char *eofmark, int striptabs) case CCTL: if (eofmark == NULL || dblquote) USTPUTC(CTLESC, out); +#if ENABLE_ASH_BASH_COMPAT + if (c == '\\' && bash_dollar_squote) { + c = decode_dollar_squote(); + if (c & 0x100) { + USTPUTC('\\', out); + c = (unsigned char)c; + } + } +#endif USTPUTC(c, out); break; case CBACK: /* backslash */ @@ -10101,13 +10864,15 @@ readtoken1(int firstc, int syntax, char *eofmark, int striptabs) if (doprompt) setprompt(2); } else { - if ( - dblquote && - c != '\\' && c != '`' && - c != '$' && ( - c != '"' || - eofmark != NULL - ) +#if ENABLE_ASH_EXPAND_PRMT + if (c == '$' && pssyntax) { + USTPUTC(CTLESC, out); + USTPUTC('\\', out); + } +#endif + if (dblquote && c != '\\' + && c != '`' && c != '$' + && (c != '"' || eofmark != NULL) ) { USTPUTC(CTLESC, out); USTPUTC('\\', out); @@ -10115,12 +10880,12 @@ readtoken1(int firstc, int syntax, char *eofmark, int striptabs) if (SIT(c, SQSYNTAX) == CCTL) USTPUTC(CTLESC, out); USTPUTC(c, out); - quotef++; + quotef = 1; } break; case CSQUOTE: syntax = SQSYNTAX; -quotemark: + quotemark: if (eofmark == NULL) { USTPUTC(CTLQUOTEMARK, out); } @@ -10130,15 +10895,17 @@ quotemark: dblquote = 1; goto quotemark; case CENDQUOTE: - if (eofmark != NULL && arinest == 0 && - varnest == 0) { + USE_ASH_BASH_COMPAT(bash_dollar_squote = 0;) + if (eofmark != NULL && arinest == 0 + && varnest == 0 + ) { USTPUTC(c, out); } else { if (dqvarnest == 0) { syntax = BASESYNTAX; dblquote = 0; } - quotef++; + quotef = 1; goto quotemark; } break; @@ -10156,7 +10923,7 @@ quotemark: USTPUTC(c, out); } break; -#ifdef CONFIG_ASH_MATH_SUPPORT +#if ENABLE_SH_MATH_SUPPORT case CLP: /* '(' in arithmetic */ parenlevel++; USTPUTC(c, out); @@ -10170,10 +10937,7 @@ quotemark: if (--arinest == 0) { USTPUTC(CTLENDARI, out); syntax = prevsyntax; - if (syntax == DQSYNTAX) - dblquote = 1; - else - dblquote = 0; + dblquote = (syntax == DQSYNTAX); } else USTPUTC(')', out); } else { @@ -10195,61 +10959,70 @@ quotemark: case CIGN: break; default: - if (varnest == 0) + if (varnest == 0) { +#if ENABLE_ASH_BASH_COMPAT + if (c == '&') { + if (pgetc() == '>') + c = 0x100 + '>'; /* flag &> */ + pungetc(); + } +#endif goto endword; /* exit outer loop */ -#ifdef CONFIG_ASH_ALIAS + } +#if ENABLE_ASH_ALIAS if (c != PEOA) #endif USTPUTC(c, out); } - c = pgetc_macro(); - } + c = pgetc_fast(); + } /* for (;;) */ } -endword: -#ifdef CONFIG_ASH_MATH_SUPPORT + endword: +#if ENABLE_SH_MATH_SUPPORT if (syntax == ARISYNTAX) - synerror("Missing '))'"); + raise_error_syntax("missing '))'"); #endif - if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL) - synerror("Unterminated quoted string"); + if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL) + raise_error_syntax("unterminated quoted string"); if (varnest != 0) { - startlinno = plinno; + startlinno = g_parsefile->linno; /* { */ - synerror("Missing '}'"); + raise_error_syntax("missing '}'"); } USTPUTC('\0', out); len = out - (char *)stackblock(); out = stackblock(); if (eofmark == NULL) { - if ((c == '>' || c == '<') + if ((c == '>' || c == '<' USE_ASH_BASH_COMPAT( || c == 0x100 + '>')) && quotef == 0 - && len <= 2 - && (*out == '\0' || is_digit(*out))) { - PARSEREDIR(); - return lasttoken = TREDIR; - } else { - pungetc(); + ) { + if (isdigit_str9(out)) { + PARSEREDIR(); /* passed as params: out, c */ + lasttoken = TREDIR; + return lasttoken; + } + /* else: non-number X seen, interpret it + * as "NNNX>file" = "NNNX >file" */ } + pungetc(); } quoteflag = quotef; backquotelist = bqlist; grabstackblock(len); wordtext = out; - return lasttoken = TWORD; + lasttoken = TWORD; + return lasttoken; /* end of readtoken routine */ - - /* * Check to see whether we are at the end of the here document. When this * is called, c is set to the first character of the next input line. If * we are at the end of the here document, this routine sets the c to PEOF. */ - checkend: { if (eofmark) { -#ifdef CONFIG_ASH_ALIAS +#if ENABLE_ASH_ALIAS if (c == PEOA) { c = pgetc2(); } @@ -10260,14 +11033,15 @@ checkend: { } } if (c == *eofmark) { - if (pfgets(line, sizeof line) != NULL) { + if (pfgets(line, sizeof(line)) != NULL) { char *p, *q; p = line; - for (q = eofmark + 1 ; *q && *p == *q ; p++, q++); + for (q = eofmark + 1; *q && *p == *q; p++, q++) + continue; if (*p == '\n' && *q == '\0') { c = PEOF; - plinno++; + g_parsefile->linno++; needprompt = doprompt; } else { pushstring(line, NULL); @@ -10278,18 +11052,17 @@ checkend: { goto checkend_return; } - /* * Parse a redirection operator. The variable "out" points to a string * specifying the fd to be redirected. The variable "c" contains the * first character of the redirection operator. */ - parseredir: { - char fd = *out; + /* out is already checked to be a valid number or "" */ + int fd = (*out == '\0' ? -1 : atoi(out)); union node *np; - np = (union node *)stalloc(sizeof (struct nfile)); + np = stzalloc(sizeof(struct nfile)); if (c == '>') { np->nfile.fd = 1; c = pgetc(); @@ -10299,25 +11072,36 @@ parseredir: { np->type = NCLOBBER; else if (c == '&') np->type = NTOFD; + /* it also can be NTO2 (>&file), but we can't figure it out yet */ else { np->type = NTO; pungetc(); } - } else { /* c == '<' */ - np->nfile.fd = 0; - switch (c = pgetc()) { + } +#if ENABLE_ASH_BASH_COMPAT + else if (c == 0x100 + '>') { /* this flags &> redirection */ + np->nfile.fd = 1; + pgetc(); /* this is '>', no need to check */ + np->type = NTO2; + } +#endif + else { /* c == '<' */ + /*np->nfile.fd = 0; - stzalloc did it */ + c = pgetc(); + switch (c) { case '<': - if (sizeof (struct nfile) != sizeof (struct nhere)) { - np = (union node *)stalloc(sizeof (struct nhere)); - np->nfile.fd = 0; + if (sizeof(struct nfile) != sizeof(struct nhere)) { + np = stzalloc(sizeof(struct nhere)); + /*np->nfile.fd = 0; - stzalloc did it */ } np->type = NHERE; - heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc)); + heredoc = stzalloc(sizeof(struct heredoc)); heredoc->here = np; - if ((c = pgetc()) == '-') { + c = pgetc(); + if (c == '-') { heredoc->striptabs = 1; } else { - heredoc->striptabs = 0; + /*heredoc->striptabs = 0; - stzalloc did it */ pungetc(); } break; @@ -10336,38 +11120,46 @@ parseredir: { break; } } - if (fd != '\0') - np->nfile.fd = digit_val(fd); + if (fd >= 0) + np->nfile.fd = fd; redirnode = np; goto parseredir_return; } - /* * Parse a substitution. At this point, we have read the dollar sign * and nothing else. */ +/* 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)(c) - 33 < 32) \ + && ((0xc1ff920dU >> ((unsigned)(c) - 33)) & 1)) parsesub: { int subtype; int typeloc; int flags; char *p; - static const char types[] = "}-+?="; + static const char types[] ALIGN1 = "}-+?="; c = pgetc(); - if ( - c <= PEOA_OR_PEOF || - (c != '(' && c != '{' && !is_name(c) && !is_special(c)) + if (c <= PEOA_OR_PEOF + || (c != '(' && c != '{' && !is_name(c) && !is_special(c)) ) { - USTPUTC('$', out); +#if ENABLE_ASH_BASH_COMPAT + if (c == '\'') + bash_dollar_squote = 1; + else +#endif + USTPUTC('$', out); pungetc(); } else if (c == '(') { /* $(command) or $((arith)) */ if (pgetc() == '(') { -#ifdef CONFIG_ASH_MATH_SUPPORT +#if ENABLE_SH_MATH_SUPPORT PARSEARITH(); #else - synerror("We unsupport $((arith))"); + raise_error_syntax("you disabled math support for $((arith)) syntax"); #endif } else { pungetc(); @@ -10381,12 +11173,12 @@ parsesub: { if (c == '{') { c = pgetc(); if (c == '#') { - if ((c = pgetc()) == '}') + c = pgetc(); + if (c == '}') c = '#'; else subtype = VSLENGTH; - } - else + } else subtype = 0; } if (c > PEOA_OR_PEOF && is_name(c)) { @@ -10394,26 +11186,33 @@ parsesub: { STPUTC(c, out); c = pgetc(); } while (c > PEOA_OR_PEOF && is_in_name(c)); - } else if (is_digit(c)) { + } else if (isdigit(c)) { do { STPUTC(c, out); c = pgetc(); - } while (is_digit(c)); - } - else if (is_special(c)) { + } while (isdigit(c)); + } else if (is_special(c)) { USTPUTC(c, out); c = pgetc(); + } else { + badsub: + raise_error_syntax("bad substitution"); } - else -badsub: synerror("Bad substitution"); STPUTC('=', out); flags = 0; if (subtype == 0) { switch (c) { case ':': - flags = VSNUL; c = pgetc(); +#if ENABLE_ASH_BASH_COMPAT + if (c == ':' || c == '$' || isdigit(c)) { + pungetc(); + subtype = VSSUBSTR; + break; + } +#endif + flags = VSNUL; /*FALLTHROUGH*/ default: p = strchr(types, c); @@ -10422,18 +11221,26 @@ badsub: synerror("Bad substitution"); subtype = p - types + VSNORMAL; break; case '%': - case '#': - { - int cc = c; - subtype = c == '#' ? VSTRIMLEFT : - VSTRIMRIGHT; - c = pgetc(); - if (c == cc) - subtype++; - else - pungetc(); - break; - } + case '#': { + int cc = c; + subtype = c == '#' ? VSTRIMLEFT : VSTRIMRIGHT; + c = pgetc(); + if (c == cc) + subtype++; + else + pungetc(); + break; + } +#if ENABLE_ASH_BASH_COMPAT + case '/': + subtype = VSREPLACE; + c = pgetc(); + if (c == '/') + subtype++; /* VSREPLACEALL */ + else + pungetc(); + break; +#endif } } else { pungetc(); @@ -10451,45 +11258,42 @@ badsub: synerror("Bad substitution"); goto parsesub_return; } - /* * Called to parse command substitutions. Newstyle is set if the command * is enclosed inside $(...); nlpp is a pointer to the head of the linked * list of commands (passed by reference), and savelen is the number of * characters on the top of the stack which must be preserved. */ - parsebackq: { struct nodelist **nlpp; - int savepbq; + smallint savepbq; union node *n; char *volatile str; struct jmploc jmploc; struct jmploc *volatile savehandler; size_t savelen; - int saveprompt; + smallint saveprompt = 0; + #ifdef __GNUC__ (void) &saveprompt; #endif - savepbq = parsebackquote; if (setjmp(jmploc.loc)) { - if (str) - ckfree(str); + free(str); parsebackquote = 0; - handler = savehandler; - longjmp(handler->loc, 1); + exception_handler = savehandler; + longjmp(exception_handler->loc, 1); } - INTOFF; + INT_OFF; str = NULL; savelen = out - (char *)stackblock(); if (savelen > 0) { str = ckmalloc(savelen); memcpy(str, stackblock(), savelen); } - savehandler = handler; - handler = &jmploc; - INTON; + savehandler = exception_handler; + exception_handler = &jmploc; + INT_ON; if (oldstyle) { /* We must read until the closing backquote, giving special treatment to some slashes, and then push the string and @@ -10504,15 +11308,16 @@ parsebackq: { for (;;) { if (needprompt) { setprompt(2); - needprompt = 0; } - switch (pc = pgetc()) { + pc = pgetc(); + switch (pc) { case '`': goto done; case '\\': - if ((pc = pgetc()) == '\n') { - plinno++; + pc = pgetc(); + if (pc == '\n') { + g_parsefile->linno++; if (doprompt) setprompt(2); /* @@ -10524,7 +11329,7 @@ parsebackq: { continue; } if (pc != '\\' && pc != '`' && pc != '$' - && (!dblquote || pc != '"')) + && (!dblquote || pc != '"')) STPUTC('\\', pout); if (pc > PEOA_OR_PEOF) { break; @@ -10532,14 +11337,14 @@ parsebackq: { /* fall through */ case PEOF: -#ifdef CONFIG_ASH_ALIAS +#if ENABLE_ASH_ALIAS case PEOA: #endif - startlinno = plinno; - synerror("EOF in backquote substitution"); + startlinno = g_parsefile->linno; + raise_error_syntax("EOF in backquote substitution"); case '\n': - plinno++; + g_parsefile->linno++; needprompt = doprompt; break; @@ -10548,7 +11353,7 @@ parsebackq: { } STPUTC(pc, pout); } -done: + done: STPUTC('\0', pout); psavelen = pout - (char *)stackblock(); if (psavelen > 0) { @@ -10559,8 +11364,8 @@ done: nlpp = &bqlist; while (*nlpp) nlpp = &(*nlpp)->next; - *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist)); - (*nlpp)->next = NULL; + *nlpp = stzalloc(sizeof(**nlpp)); + /* (*nlpp)->next = NULL; - stzalloc did it */ parsebackquote = oldstyle; if (oldstyle) { @@ -10572,10 +11377,8 @@ done: if (oldstyle) doprompt = saveprompt; - else { - if (readtoken() != TRP) - synexpect(TRP); - } + else if (readtoken() != TRP) + raise_error_unexpected_syntax(TRP); (*nlpp)->n = n; if (oldstyle) { @@ -10592,37 +11395,35 @@ done: if (str) { memcpy(out, str, savelen); STADJUST(savelen, out); - INTOFF; - ckfree(str); + INT_OFF; + free(str); str = NULL; - INTON; + INT_ON; } parsebackquote = savepbq; - handler = savehandler; + exception_handler = savehandler; if (arinest || dblquote) USTPUTC(CTLBACKQ | CTLQUOTE, out); else USTPUTC(CTLBACKQ, out); if (oldstyle) goto parsebackq_oldreturn; - else - goto parsebackq_newreturn; + goto parsebackq_newreturn; } -#ifdef CONFIG_ASH_MATH_SUPPORT +#if ENABLE_SH_MATH_SUPPORT /* * Parse an arithmetic expansion (indicate start of one and set state) */ parsearith: { - if (++arinest == 1) { prevsyntax = syntax; syntax = ARISYNTAX; USTPUTC(CTLARI, out); if (dblquote) - USTPUTC('"',out); + USTPUTC('"', out); else - USTPUTC(' ',out); + USTPUTC(' ', out); } else { /* * we collapse embedded arithmetic expansion to @@ -10636,826 +11437,748 @@ parsearith: { } /* end of readtoken */ - - /* - * Returns true if the text contains nothing to expand (no dollar signs - * or backquotes). + * Read the next input token. + * If the token is a word, we set backquotelist to the list of cmds in + * backquotes. We set quoteflag to true if any part of the word was + * quoted. + * If the token is TREDIR, then we set redirnode to a structure containing + * the redirection. + * In all cases, the variable startlinno is set to the number of the line + * on which the token starts. + * + * [Change comment: here documents and internal procedures] + * [Readtoken shouldn't have any arguments. Perhaps we should make the + * word parsing code into a separate routine. In this case, readtoken + * doesn't need to have any internal procedures, but parseword does. + * We could also make parseoperator in essence the main routine, and + * have parseword (readtoken1?) handle both words and redirection.] */ +#define NEW_xxreadtoken +#ifdef NEW_xxreadtoken +/* singles must be first! */ +static const char xxreadtoken_chars[7] ALIGN1 = { + '\n', '(', ')', /* singles */ + '&', '|', ';', /* doubles */ + 0 +}; + +#define xxreadtoken_singles 3 +#define xxreadtoken_doubles 3 + +static const char xxreadtoken_tokens[] ALIGN1 = { + TNL, TLP, TRP, /* only single occurrence allowed */ + TBACKGND, TPIPE, TSEMI, /* if single occurrence */ + TEOF, /* corresponds to trailing nul */ + TAND, TOR, TENDCASE /* if double occurrence */ +}; static int -noexpand(char *text) +xxreadtoken(void) { - char *p; - char c; + int c; - p = text; - while ((c = *p++) != '\0') { - if (c == CTLQUOTEMARK) - continue; - if (c == CTLESC) - p++; - else if (SIT(c, BASESYNTAX) == CCTL) - return 0; + if (tokpushback) { + tokpushback = 0; + return lasttoken; } - return 1; -} - - -/* - * Return of a legal variable name (a letter or underscore followed by zero or - * more letters, underscores, and digits). - */ - -char * -endofname(const char *name) - { - char *p; - - p = (char *) name; - if (! is_name(*p)) - return p; - while (*++p) { - if (! is_in_name(*p)) - break; + if (needprompt) { + setprompt(2); } - return p; -} + startlinno = g_parsefile->linno; + for (;;) { /* until token or start of word found */ + c = pgetc_fast(); + if (c == ' ' || c == '\t' USE_ASH_ALIAS( || c == PEOA)) + continue; + if (c == '#') { + while ((c = pgetc()) != '\n' && c != PEOF) + continue; + pungetc(); + } else if (c == '\\') { + if (pgetc() != '\n') { + pungetc(); + break; /* return readtoken1(...) */ + } + startlinno = ++g_parsefile->linno; + if (doprompt) + setprompt(2); + } else { + const char *p; -/* - * Called when an unexpected token is read during the parse. The argument - * is the token that is expected, or -1 if more than one type of token can - * occur at this point. - */ + p = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1; + if (c != PEOF) { + if (c == '\n') { + g_parsefile->linno++; + needprompt = doprompt; + } -static void synexpect(int token) -{ - char msg[64]; - int l; + p = strchr(xxreadtoken_chars, c); + if (p == NULL) + break; /* return readtoken1(...) */ - l = sprintf(msg, "%s unexpected", tokname(lasttoken)); - if (token >= 0) - sprintf(msg + l, " (expecting %s)", tokname(token)); - synerror(msg); - /* NOTREACHED */ -} + if ((int)(p - xxreadtoken_chars) >= xxreadtoken_singles) { + int cc = pgetc(); + if (cc == c) { /* double occurrence? */ + p += xxreadtoken_doubles + 1; + } else { + pungetc(); +#if ENABLE_ASH_BASH_COMPAT + if (c == '&' && cc == '>') /* &> */ + break; /* return readtoken1(...) */ +#endif + } + } + } + lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars]; + return lasttoken; + } + } /* for (;;) */ -static void -synerror(const char *msg) -{ - error("Syntax error: %s", msg); - /* NOTREACHED */ + return readtoken1(c, BASESYNTAX, (char *) NULL, 0); } - - -/* - * called by editline -- any expansions to the prompt - * should be added here. - */ - -static void setprompt(int whichprompt) +#else /* old xxreadtoken */ +#define RETURN(token) return lasttoken = token +static int +xxreadtoken(void) { - const char *prompt; + int c; - switch (whichprompt) { - case 1: - prompt = ps1val(); - break; - case 2: - prompt = ps2val(); - break; - default: /* 0 */ - prompt = nullstr; + if (tokpushback) { + tokpushback = 0; + return lasttoken; + } + if (needprompt) { + setprompt(2); } - putprompt(prompt); + startlinno = g_parsefile->linno; + for (;;) { /* until token or start of word found */ + c = pgetc_fast(); + switch (c) { + case ' ': case '\t': +#if ENABLE_ASH_ALIAS + case PEOA: +#endif + continue; + case '#': + while ((c = pgetc()) != '\n' && c != PEOF) + continue; + pungetc(); + continue; + case '\\': + if (pgetc() == '\n') { + startlinno = ++g_parsefile->linno; + if (doprompt) + setprompt(2); + continue; + } + pungetc(); + goto breakloop; + case '\n': + g_parsefile->linno++; + needprompt = doprompt; + RETURN(TNL); + case PEOF: + RETURN(TEOF); + case '&': + if (pgetc() == '&') + RETURN(TAND); + pungetc(); + RETURN(TBACKGND); + case '|': + if (pgetc() == '|') + RETURN(TOR); + pungetc(); + RETURN(TPIPE); + case ';': + if (pgetc() == ';') + RETURN(TENDCASE); + pungetc(); + RETURN(TSEMI); + case '(': + RETURN(TLP); + case ')': + RETURN(TRP); + default: + goto breakloop; + } + } + breakloop: + return readtoken1(c, BASESYNTAX, (char *)NULL, 0); +#undef RETURN } +#endif /* old xxreadtoken */ - -static const char *const *findkwd(const char *s) +static int +readtoken(void) { - 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. - */ + int t; +#if DEBUG + smallint alreadyseen = tokpushback; +#endif -#define EMPTY -2 /* marks an unused slot in redirtab */ -#ifndef PIPE_BUF -# define PIPESIZE 4096 /* amount of buffering in a pipe */ -#else -# define PIPESIZE PIPE_BUF +#if ENABLE_ASH_ALIAS + top: #endif -/* - * Open a file in noclobber mode. - * The code was copied from bash. - */ -static inline int -noclobberopen(const char *fname) -{ - int r, fd; - struct stat finfo, finfo2; + t = xxreadtoken(); /* - * If the file exists and is a regular file, return an error - * immediately. + * eat newlines */ - r = stat(fname, &finfo); - if (r == 0 && S_ISREG(finfo.st_mode)) { - errno = EEXIST; - return -1; + if (checkkwd & CHKNL) { + while (t == TNL) { + parseheredoc(); + t = xxreadtoken(); + } } - /* - * If the file was not present (r != 0), make sure we open it - * exclusively so that if it is created before we open it, our open - * will fail. Make sure that we do not truncate an existing file. - * Note that we don't turn on O_EXCL unless the stat failed -- if the - * file was not a regular file, we leave O_EXCL off. - */ - if (r != 0) - return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666); - fd = open(fname, O_WRONLY|O_CREAT, 0666); - - /* If the open failed, return the file descriptor right away. */ - if (fd < 0) - return fd; - - /* - * OK, the open succeeded, but the file may have been changed from a - * non-regular file to a regular file between the stat and the open. - * We are assuming that the O_EXCL open handles the case where FILENAME - * did not exist and is symlinked to an existing file between the stat - * and open. - */ + if (t != TWORD || quoteflag) { + goto out; + } /* - * If we can open it and fstat the file descriptor, and neither check - * revealed that it was a regular file, and the file has not been - * replaced, return the file descriptor. + * check for keywords */ - if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) && - finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino) - return fd; - - /* The file has been replaced. badness. */ - close(fd); - errno = EEXIST; - return -1; -} - -/* - * Handle here documents. Normally we fork off a process to write the - * data to a pipe. If the document is short, we can stuff the data in - * the pipe without forking. - */ - -static inline int -openhere(union node *redir) -{ - int pip[2]; - size_t len = 0; + if (checkkwd & CHKKWD) { + const char *const *pp; - if (pipe(pip) < 0) - error("Pipe call failed"); - if (redir->type == NHERE) { - len = strlen(redir->nhere.doc->narg.text); - if (len <= PIPESIZE) { - xwrite(pip[1], redir->nhere.doc->narg.text, len); + pp = findkwd(wordtext); + if (pp) { + lasttoken = t = pp - tokname_array; + TRACE(("keyword %s recognized\n", tokname(t))); goto out; } } - if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) { - close(pip[0]); - signal(SIGINT, SIG_IGN); - signal(SIGQUIT, SIG_IGN); - signal(SIGHUP, SIG_IGN); -#ifdef SIGTSTP - signal(SIGTSTP, SIG_IGN); + + if (checkkwd & CHKALIAS) { +#if ENABLE_ASH_ALIAS + struct alias *ap; + ap = lookupalias(wordtext, 1); + if (ap != NULL) { + if (*ap->val) { + pushstring(ap->val, ap); + } + goto top; + } #endif - signal(SIGPIPE, SIG_DFL); - if (redir->type == NHERE) - xwrite(pip[1], redir->nhere.doc->narg.text, len); - else - expandhere(redir->nhere.doc, pip[1]); - _exit(0); } -out: - close(pip[1]); - return pip[0]; + out: + checkkwd = 0; +#if DEBUG + if (!alreadyseen) + TRACE(("token %s %s\n", tokname(t), t == TWORD ? wordtext : "")); + else + TRACE(("reread token %s %s\n", tokname(t), t == TWORD ? wordtext : "")); +#endif + return t; } -static int -openredirect(union node *redir) +static char +peektoken(void) { - char *fname; - int f; - - switch (redir->nfile.type) { - case NFROM: - fname = redir->nfile.expfname; - if ((f = open(fname, O_RDONLY)) < 0) - goto eopen; - break; - case NFROMTO: - fname = redir->nfile.expfname; - if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) - goto ecreate; - break; - case NTO: - /* Take care of noclobber mode. */ - if (Cflag) { - fname = redir->nfile.expfname; - if ((f = noclobberopen(fname)) < 0) - goto ecreate; - break; - } - /* FALLTHROUGH */ - case NCLOBBER: - fname = redir->nfile.expfname; - if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0) - goto ecreate; - break; - case NAPPEND: - fname = redir->nfile.expfname; - if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0) - goto ecreate; - break; - default: -#ifdef DEBUG - abort(); -#endif - /* Fall through to eliminate warning. */ - case NTOFD: - case NFROMFD: - f = -1; - break; - case NHERE: - case NXHERE: - f = openhere(redir); - break; - } + int t; - return f; -ecreate: - error("cannot create %s: %s", fname, errmsg(errno, E_CREAT)); -eopen: - error("cannot open %s: %s", fname, errmsg(errno, E_OPEN)); + t = readtoken(); + tokpushback = 1; + return tokname_array[t][0]; } -static inline void -dupredirect(union node *redir, int f) +/* + * 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) { - 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; - } + int t; - if (f != fd) { - copyfd(f, fd); - close(f); - } - return; + tokpushback = 0; + doprompt = interact; + if (doprompt) + setprompt(doprompt); + needprompt = 0; + t = readtoken(); + if (t == TEOF) + return NEOF; + if (t == TNL) + return NULL; + tokpushback = 1; + return list(1); } /* - * 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, is saved in memory. + * Input any here documents. */ - static void -redirect(union node *redir, int flags) +parseheredoc(void) { + struct heredoc *here; union node *n; - struct redirtab *sv; - int i; - int fd; - int newfd; - int *p; - nullredirs++; - if (!redir) { - return; - } - 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; - if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) && - n->ndup.dupfd == fd) - continue; /* redirect from/to same file descriptor */ - newfd = openredirect(n); - if (fd == newfd) - continue; - if (sv && *(p = &sv->renamed[fd]) == EMPTY) { - i = fcntl(fd, F_DUPFD, 10); + here = heredoclist; + heredoclist = NULL; - if (i == -1) { - i = errno; - if (i != EBADF) { - close(newfd); - errno = i; - error("%d: %m", fd); - /* NOTREACHED */ - } - } else { - *p = i; - close(fd); - } - } else { - close(fd); + while (here) { + if (needprompt) { + setprompt(2); } - dupredirect(n, newfd); - } while ((n = n->nfile.next)); - INTON; + readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX, + here->eofmark, here->striptabs); + n = stzalloc(sizeof(struct narg)); + n->narg.type = NARG; + /*n->narg.next = NULL; - stzalloc did it */ + n->narg.text = wordtext; + n->narg.backquote = backquotelist; + here->here->nhere.doc = n; + here = here->next; + } } /* - * Undo the effects of the last redirection. + * called by editline -- any expansions to the prompt should be added here. */ - -void -popredir(int drop) +#if ENABLE_ASH_EXPAND_PRMT +static const char * +expandstr(const char *ps) { - struct redirtab *rp; - int i; - - if (--nullredirs >= 0) - return; - INTOFF; - rp = redirlist; - for (i = 0 ; i < 10 ; i++) { - if (rp->renamed[i] != EMPTY) { - if (!drop) { - close(i); - copyfd(rp->renamed[i], i); - } - close(rp->renamed[i]); - } - } - redirlist = rp->next; - nullredirs = rp->nullredirs; - ckfree(rp); - INTON; -} + union node n; -/* - * Undo all redirections. Called on error or interrupt. - */ + /* XXX Fix (char *) cast. It _is_ a bug. ps is variable's value, + * and token processing _can_ alter it (delete NULs etc). */ + setinputstring((char *)ps); + readtoken1(pgetc(), PSSYNTAX, nullstr, 0); + popfile(); -/* - * Discard all saved file descriptors. - */ + n.narg.type = NARG; + n.narg.next = NULL; + n.narg.text = wordtext; + n.narg.backquote = backquotelist; -void -clearredir(int drop) -{ - for (;;) { - nullredirs = 0; - if (!redirlist) - break; - popredir(drop); - } + expandarg(&n, NULL, 0); + return stackblock(); } - +#endif /* - * 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. + * Execute a command or commands contained in a string. */ - -int -copyfd(int from, int to) +static int +evalstring(char *s, int mask) { - int newfd; - - newfd = fcntl(from, F_DUPFD, to); - if (newfd < 0) { - if (errno == EMFILE) - return EMPTY; - else - error("%d: %m", from); - } - return newfd; -} - + union node *n; + struct stackmark smark; + int skip; -int -redirectsafe(union node *redir, int flags) -{ - int err; - volatile int saveint; - struct jmploc *volatile savehandler = handler; - struct jmploc jmploc; + setinputstring(s); + setstackmark(&smark); - SAVEINT(saveint); - if (!(err = setjmp(jmploc.loc) * 2)) { - handler = &jmploc; - redirect(redir, flags); + skip = 0; + while ((n = parsecmd(0)) != NEOF) { + evaltree(n, 0); + popstackmark(&smark); + skip = evalskip; + if (skip) + break; } - 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 *); - + popfile(); -void -showtree(union node *n) -{ - trputs("showtree called\n"); - shtree(n, 1, NULL, stdout); + skip &= mask; + evalskip = skip; + return skip; } - -static void -shtree(union node *n, int ind, char *pfx, FILE *fp) +/* + * The eval command. + */ +static int +evalcmd(int argc UNUSED_PARAM, char **argv) { - struct nodelist *lp; - const char *s; - - if (n == NULL) - return; + char *p; + char *concat; - indent(ind, pfx, fp); - switch(n->type) { - case NSEMI: - s = "; "; - goto binop; - case NAND: - s = " && "; - goto binop; - case NOR: - s = " || "; -binop: - shtree(n->nbinary.ch1, ind, NULL, fp); - /* if (ind < 0) */ - fputs(s, fp); - shtree(n->nbinary.ch2, ind, NULL, fp); - break; - case NCMD: - shcmd(n, fp); - if (ind >= 0) - putc('\n', fp); - break; - case NPIPE: - for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) { - shcmd(lp->n, fp); - if (lp->next) - fputs(" | ", fp); + if (argv[1]) { + p = argv[1]; + argv += 2; + if (argv[0]) { + STARTSTACKSTR(concat); + for (;;) { + concat = stack_putstr(p, concat); + p = *argv++; + if (p == NULL) + break; + STPUTC(' ', concat); + } + STPUTC('\0', concat); + p = grabstackstr(concat); } - if (n->npipe.backgnd) - fputs(" &", fp); - if (ind >= 0) - putc('\n', fp); - break; - default: - fprintf(fp, "<node type %d>", n->type); - if (ind >= 0) - putc('\n', fp); - break; - } -} - + evalstring(p, ~SKIPEVAL); -static void -shcmd(union node *cmd, FILE *fp) -{ - union node *np; - int first; - const char *s; - int dftfd; - - first = 1; - 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) - putchar(' '); - switch (np->nfile.type) { - 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; - } - if (np->nfile.fd != dftfd) - fprintf(fp, "%d", np->nfile.fd); - fputs(s, fp); - if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) { - fprintf(fp, "%d", np->ndup.dupfd); - } else { - sharg(np->nfile.fname, fp); - } - first = 0; } + return exitstatus; } - - -static void -sharg(union node *arg, FILE *fp) +/* + * Read and execute commands. "Top" is nonzero for the top level command + * loop; it turns on prompting if the shell is interactive. + */ +static int +cmdloop(int top) { - char *p; - struct nodelist *bqlist; - int subtype; - - if (arg->type != NARG) { - out1fmt("<node type %d>\n", arg->type); - abort(); - } - bqlist = arg->narg.backquote; - for (p = arg->narg.text ; *p ; p++) { - switch (*p) { - case CTLESC: - putc(*++p, fp); - break; - case CTLVAR: - putc('$', fp); - putc('{', fp); - subtype = *++p; - if (subtype == VSLENGTH) - putc('#', fp); - - while (*p != '=') - putc(*p++, fp); + union node *n; + struct stackmark smark; + int inter; + int numeof = 0; - if (subtype & VSNUL) - putc(':', fp); + TRACE(("cmdloop(%d) called\n", top)); + for (;;) { + int skip; - switch (subtype & VSTYPE) { - case VSNORMAL: - putc('}', fp); - break; - case VSMINUS: - putc('-', fp); - break; - case VSPLUS: - putc('+', fp); - break; - case VSQUESTION: - putc('?', fp); - break; - case VSASSIGN: - putc('=', fp); - break; - case VSTRIMLEFT: - putc('#', fp); - break; - case VSTRIMLEFTMAX: - putc('#', fp); - putc('#', fp); - break; - case VSTRIMRIGHT: - putc('%', fp); - break; - case VSTRIMRIGHTMAX: - putc('%', fp); - putc('%', fp); - break; - case VSLENGTH: + setstackmark(&smark); +#if JOBS + if (doing_jobctl) + showjobs(stderr, SHOW_CHANGED); +#endif + inter = 0; + if (iflag && top) { + inter++; +#if ENABLE_ASH_MAIL + chkmail(); +#endif + } + n = parsecmd(inter); +#if DEBUG + showtree(n); +#endif + if (n == NEOF) { + if (!top || numeof >= 50) break; - default: - out1fmt("<subtype %d>", subtype); + if (!stoppedjobs()) { + if (!Iflag) + break; + out2str("\nUse \"exit\" to leave shell.\n"); } - break; - case CTLENDVAR: - putc('}', fp); - break; - case CTLBACKQ: - case CTLBACKQ|CTLQUOTE: - putc('$', fp); - putc('(', fp); - shtree(bqlist->n, -1, NULL, fp); - putc(')', fp); - break; - default: - putc(*p, fp); - break; + numeof++; + } else if (nflag == 0) { + /* job_warning can only be 2,1,0. Here 2->1, 1/0->0 */ + job_warning >>= 1; + numeof = 0; + evaltree(n, 0); } - } -} - - -static void -indent(int amount, char *pfx, FILE *fp) -{ - int i; + popstackmark(&smark); + skip = evalskip; - for (i = 0 ; i < amount ; i++) { - if (pfx && i == amount - 1) - fputs(pfx, fp); - putc('\t', fp); + if (skip) { + evalskip = 0; + return skip & SKIPEVAL; + } } + return 0; } - - /* - * Debugging stuff. + * 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 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(name, '/')) + return name; -FILE *tracefile; + /* IIRC standards do not say whether . is to be searched. + * And it is even smaller this way, making it unconditional for now: + */ + if (1) { /* ENABLE_ASH_BASH_COMPAT */ + fullname = name; + goto try_cur_dir; + } + while ((fullname = padvance(&path, name)) != NULL) { + try_cur_dir: + if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) { + /* + * Don't bother freeing here, since it will + * be freed by the caller. + */ + return fullname; + } + if (fullname != name) + stunalloc(fullname); + } -void -trputc(int c) -{ - if (debug != 1) - return; - putc(c, tracefile); + /* not found in the PATH */ + ash_msg_and_raise_error("%s: not found", name); + /* NOTREACHED */ } -void -trace(const char *fmt, ...) +static int +dotcmd(int argc, char **argv) { - va_list va; + struct strlist *sp; + volatile struct shparam saveparam; + int status = 0; + + for (sp = cmdenviron; sp; sp = sp->next) + setvareq(ckstrdup(sp->text), VSTRFIXED | VTEXTFIXED); + + if (argv[1]) { /* That's what SVR2 does */ + char *fullname = find_dot_file(argv[1]); + argv += 2; + argc -= 2; + if (argc) { /* argc > 0, argv[0] != NULL */ + saveparam = shellparam; + shellparam.malloced = 0; + shellparam.nparam = argc; + shellparam.p = argv; + }; + + setinputfile(fullname, INPUT_PUSH_FILE); + commandname = fullname; + cmdloop(0); + popfile(); - if (debug != 1) - return; - va_start(va, fmt); - (void) vfprintf(tracefile, fmt, va); - va_end(va); + if (argc) { + freeparam(&shellparam); + shellparam = saveparam; + }; + status = exitstatus; + } + return status; } -void -tracev(const char *fmt, va_list va) +static int +exitcmd(int argc UNUSED_PARAM, char **argv) { - if (debug != 1) - return; - (void) vfprintf(tracefile, fmt, va); + if (stoppedjobs()) + return 0; + if (argv[1]) + exitstatus = number(argv[1]); + raise_exception(EXEXIT); + /* NOTREACHED */ } - -void -trputs(const char *s) +/* + * Read a file containing shell functions. + */ +static void +readcmdfile(char *name) { - if (debug != 1) - return; - fputs(s, tracefile); + setinputfile(name, INPUT_PUSH_FILE); + cmdloop(0); + popfile(); } +/* ============ find_command inplementation */ + +/* + * Resolve a command name. If you change this routine, you may have to + * change the shellexec routine as well. + */ static void -trstring(char *s) +find_command(char *name, struct cmdentry *entry, int act, const char *path) { - char *p; - char c; + struct tblentry *cmdp; + int idx; + int prev; + char *fullname; + struct stat statb; + int e; + int updatetbl; + struct builtincmd *bcmd; - if (debug != 1) - return; - putc('"', tracefile); - 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); - putc(c, tracefile); - break; - default: - if (*p >= ' ' && *p <= '~') - putc(*p, tracefile); - else { - putc('\\', tracefile); - putc(*p >> 6 & 03, tracefile); - putc(*p >> 3 & 07, tracefile); - putc(*p & 07, tracefile); + /* 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) { +#ifdef SYSV + if (errno == EINTR) + continue; +#endif + entry->cmdtype = CMDUNKNOWN; + return; } - break; } + entry->cmdtype = CMDNORMAL; + return; } - putc('"', tracefile); -} +/* #if ENABLE_FEATURE_SH_STANDALONE... moved after builtin check */ -void -trargs(char **ap) -{ - if (debug != 1) - return; - while (*ap) { - trstring(*ap++); - if (*ap) - putc(' ', tracefile); - else - putc('\n', tracefile); + updatetbl = (path == pathval()); + if (!updatetbl) { + act |= DO_ALTPATH; + if (strstr(path, "%builtin") != NULL) + act |= DO_ALTBLTIN; } -} + /* If name is in the table, check answer will be ok */ + cmdp = cmdlookup(name, 0); + if (cmdp != NULL) { + int bit; -void -opentrace(void) -{ - char s[100]; -#ifdef O_APPEND - int flags; + switch (cmdp->cmdtype) { + default: +#if DEBUG + abort(); #endif - - if (debug != 1) { - if (tracefile) - fflush(tracefile); - /* leave open because libedit might be using it */ - return; + case CMDNORMAL: + bit = DO_ALTPATH; + break; + case CMDFUNCTION: + bit = DO_NOFUNC; + break; + case CMDBUILTIN: + bit = DO_ALTBLTIN; + break; + } + if (act & bit) { + updatetbl = 0; + cmdp = NULL; + } else if (cmdp->rehash == 0) + /* if not invalidated by cd, we're done */ + goto success; } - scopy("./trace", s); - if (tracefile) { - if (!freopen(s, "a", tracefile)) { - fprintf(stderr, "Can't re-open %s\n", s); - debug = 0; - return; + + /* If %builtin not in path, check for builtin next */ + bcmd = find_builtin(name); + if (bcmd) { + if (IS_BUILTIN_REGULAR(bcmd)) + goto builtin_success; + if (act & DO_ALTPATH) { + if (!(act & DO_ALTBLTIN)) + goto builtin_success; + } else if (builtinloc <= 0) { + goto builtin_success; } - } else { - if ((tracefile = fopen(s, "a")) == NULL) { - fprintf(stderr, "Can't open %s\n", s); - debug = 0; + } + +#if ENABLE_FEATURE_SH_STANDALONE + { + int applet_no = find_applet_by_name(name); + if (applet_no >= 0) { + entry->cmdtype = CMDNORMAL; + entry->u.index = -2 - applet_no; 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); -} -#endif /* DEBUG */ + /* We have to search path. */ + prev = -1; /* where to start */ + if (cmdp && cmdp->rehash) { /* doing a rehash */ + if (cmdp->cmdtype == CMDBUILTIN) + prev = builtinloc; + else + prev = cmdp->param.index; + } -/* $NetBSD: trap.c,v 1.28 2002/11/24 22:35:43 christos Exp $ */ + e = ENOENT; + idx = -1; + loop: + while ((fullname = padvance(&path, name)) != NULL) { + stunalloc(fullname); + /* NB: code below will still use fullname + * despite it being "unallocated" */ + idx++; + if (pathopt) { + if (prefix(pathopt, "builtin")) { + if (bcmd) + goto builtin_success; + continue; + } + if ((act & DO_NOFUNC) + || !prefix(pathopt, "func") + ) { /* ignore unimplemented options */ + continue; + } + } + /* if rehash, don't redo absolute path names */ + 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 */ + if (!S_ISREG(statb.st_mode)) + continue; + if (pathopt) { /* this is a %func directory */ + stalloc(strlen(fullname) + 1); + /* NB: stalloc will return space pointed by fullname + * (because we don't have any intervening allocations + * between stunalloc above and this stalloc) */ + readcmdfile(fullname); + cmdp = cmdlookup(name, 0); + if (cmdp == NULL || cmdp->cmdtype != CMDFUNCTION) + ash_msg_and_raise_error("%s not defined in %s", name, fullname); + stunalloc(fullname); + goto success; + } + TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname)); + if (!updatetbl) { + entry->cmdtype = CMDNORMAL; + entry->u.index = idx; + return; + } + INT_OFF; + cmdp = cmdlookup(name, 1); + cmdp->cmdtype = CMDNORMAL; + cmdp->param.index = idx; + INT_ON; + goto success; + } -/* - * 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, - */ + /* We failed. If there was an entry for this command, delete it */ + if (cmdp && updatetbl) + delete_cmd_entry(); + if (act & DO_ERR) + ash_msg("%s: %s", name, errmsg(e, "not found")); + entry->cmdtype = CMDUNKNOWN; + return; -#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 */ + builtin_success: + if (!updatetbl) { + entry->cmdtype = CMDBUILTIN; + entry->u.cmd = bcmd; + return; + } + INT_OFF; + cmdp = cmdlookup(name, 1); + cmdp->cmdtype = CMDBUILTIN; + cmdp->param.cmd = bcmd; + INT_ON; + success: + cmdp->rehash = 0; + entry->cmdtype = cmdp->cmdtype; + entry->u = cmdp->param; +} +/* ============ trap.c */ /* * The trap builtin. */ - -int -trapcmd(int argc, char **argv) +static int +trapcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { char *action; char **ap; @@ -11464,707 +12187,137 @@ trapcmd(int argc, char **argv) nextopt(nullstr); ap = argptr; if (!*ap) { - for (signo = 0 ; signo < NSIG ; signo++) { + for (signo = 0; signo < NSIG; signo++) { if (trap[signo] != NULL) { - const char *sn; - - sn = u_signal_names(0, &signo, 0); - if (sn == NULL) - sn = "???"; out1fmt("trap -- %s %s\n", - single_quote(trap[signo]), sn); + single_quote(trap[signo]), + get_signame(signo)); } } return 0; } - if (!ap[1]) - action = NULL; - else + action = NULL; + if (ap[1]) action = *ap++; while (*ap) { - if ((signo = decode_signal(*ap, 0)) < 0) - error("%s: bad trap", *ap); - INTOFF; + signo = get_signum(*ap); + if (signo < 0) + ash_msg_and_raise_error("%s: bad trap", *ap); + INT_OFF; if (action) { - if (action[0] == '-' && action[1] == '\0') + if (LONE_DASH(action)) action = NULL; else - action = savestr(action); + action = ckstrdup(action); } - if (trap[signo]) - ckfree(trap[signo]); + free(trap[signo]); trap[signo] = action; if (signo != 0) setsignal(signo); - INTON; + INT_ON; ap++; } return 0; } -/* - * 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; - } - } -} - +/* ============ Builtins */ +#if !ENABLE_FEATURE_SH_EXTRA_QUIET /* - * Set the signal handler for the specified signal. The routine figures - * out what it should be set to. + * Lists available builtins */ - -void -setsignal(int signo) -{ - int action; - char *t, tsig; - struct sigaction act; - - if ((t = trap[signo]) == NULL) - action = S_DFL; - else if (*t != '\0') - action = S_CATCH; - else - action = S_IGN; - if (rootshell && action == S_DFL) { - switch (signo) { - case SIGINT: - if (iflag || minusc || sflag == 0) - action = S_CATCH; - break; - case SIGQUIT: -#ifdef DEBUG - if (debug) - break; -#endif - /* FALLTHROUGH */ - case SIGTERM: - if (iflag) - action = S_IGN; - break; -#if JOBS - case SIGTSTP: - case SIGTTOU: - if (mflag) - action = S_IGN; - break; -#endif - } - } - - t = &sigmode[signo - 1]; - tsig = *t; - if (tsig == 0) { - /* - * current setting unknown - */ - if (sigaction(signo, 0, &act) == -1) { - /* - * Pretend it worked; maybe we should give a warning - * here, but other shells don't. We don't alter - * sigmode, so that we retry every time. - */ - return; - } - if (act.sa_handler == SIG_IGN) { - if (mflag && (signo == SIGTSTP || - signo == SIGTTIN || signo == SIGTTOU)) { - tsig = S_IGN; /* don't hard ignore these */ - } else - tsig = S_HARD_IGN; - } else { - tsig = S_RESET; /* force to be set */ - } - } - if (tsig == S_HARD_IGN || tsig == action) - return; - 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; - sigfillset(&act.sa_mask); - sigaction(signo, &act, 0); -} - -/* - * Ignore a signal. - */ - -void -ignoresig(int signo) -{ - if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) { - signal(signo, SIG_IGN); - } - sigmode[signo - 1] = S_HARD_IGN; -} - - -/* - * Signal handler. - */ - -void -onsig(int signo) -{ - gotsig[signo - 1] = 1; - 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. - */ - -void -dotrap(void) -{ - char *p; - char *q; - int savestatus; - - 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; - } -} - - -/* - * 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) +static int +helpcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { - int col, i; + unsigned col; + unsigned i; - out1fmt("\nBuilt-in commands:\n-------------------\n"); - for (col = 0, i = 0; i < NUMBUILTINS; i++) { + out1fmt("\n" + "Built-in commands:\n" + "------------------\n"); + for (col = 0, i = 0; i < ARRAY_SIZE(builtintab); i++) { col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), - builtincmd[i].name + 1); + builtintab[i].name + 1); if (col > 60) { out1fmt("\n"); col = 0; } } -#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL +#if ENABLE_FEATURE_SH_STANDALONE { - 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); + const char *a = applet_names; + while (*a) { + col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), a); if (col > 60) { out1fmt("\n"); col = 0; } + a += strlen(a) + 1; } } #endif out1fmt("\n\n"); return EXIT_SUCCESS; } -#endif /* CONFIG_FEATURE_SH_EXTRA_QUIET */ - -/* - * Called to exit the shell. - */ - -void -exitshell(void) -{ - struct jmploc loc; - char *p; - int status; - - status = exitstatus; - TRACE(("pid %d, exitshell(%d)\n", getpid(), status)); - if (setjmp(loc.loc)) { - goto out; - } - handler = &loc; - if ((p = trap[0]) != NULL && *p != '\0') { - trap[0] = NULL; - evalstring(p, 0); - } - flushall(); -#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY - if (iflag && rootshell) { - const char *hp = lookupvar("HISTFILE"); - - if(hp != NULL ) - save_history ( hp ); - } -#endif -out: - _exit(status); - /* NOTREACHED */ -} - -static int decode_signal(const char *string, int minsig) -{ - int signo; - const char *name = u_signal_names(string, &signo, minsig); - - return name ? signo : -1; -} - -/* $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 -/* - * Safe version of setvar, returns 1 on success 0 on failure. - */ - -int -setvarsafe(const char *name, const char *val, int flags) -{ - int err; - volatile int saveint; - struct jmploc *volatile savehandler = handler; - struct jmploc jmploc; - - SAVEINT(saveint); - if (setjmp(jmploc.loc)) - err = 1; - else { - handler = &jmploc; - setvar(name, val, flags); - err = 0; - } - 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) -{ - char *p, *q; - size_t namelen; - char *nameeq; - size_t vallen; - - q = endofname(name); - p = strchrnul(q, '='); - namelen = p - name; - if (!namelen || p != q) - error("%.*s: bad variable name", namelen, name); - vallen = 0; - if (val == NULL) { - flags |= VUNSET; - } else { - vallen = strlen(val); - } - INTOFF; - p = mempcpy(nameeq = ckmalloc(namelen + vallen + 2), name, namelen); - *p++ = '\0'; - if (vallen) { - p[-1] = '='; - p = mempcpy(p, val, vallen); - } - *p = '\0'; - setvareq(nameeq, flags | VNOSAVE); - INTON; -} - - -/* - * Same as setvar except that the variable and value are passed in - * 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. - */ - -void -setvareq(char *s, int flags) -{ - struct var *vp, **vpp; - - vpp = hashvar(s); - flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1)); - vp = *findvar(vpp, s); - if (vp) { - if (vp->flags & VREADONLY) { - if (flags & VNOSAVE) - free(s); - error("%.*s: is read only", strchrnul(s, '=') - s, s); - } - - if (flags & VNOSET) - return; - - if (vp->func && (flags & VNOFUNC) == 0) - (*vp->func)(strchrnul(s, '=') + 1); - - if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0) - ckfree(vp->text); - - 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; - } - if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE))) - s = savestr(s); - vp->text = s; - vp->flags = flags; -} - - -/* - * Process a linked list of variable assignments. - */ - -static void -listsetvar(struct strlist *list_set_var, int flags) -{ - struct strlist *lp = list_set_var; - - if (!lp) - return; - INTOFF; - do { - setvareq(lp->text, flags); - } while ((lp = lp->next)); - INTON; -} - - -/* - * Find the value of a variable. Returns NULL if not set. - */ - -static char * -lookupvar(const char *name) -{ - struct var *v; - - if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) { - return strchrnul(v->text, '=') + 1; - } - return NULL; -} - - -/* - * Search the environment of a builtin command. - */ - -static char * -bltinlookup(const char *name) -{ - struct strlist *sp; - - for (sp = cmdenviron ; sp ; sp = sp->next) { - if (varequal(sp->text, name)) - return strchrnul(sp->text, '=') + 1; - } - return lookupvar(name); -} - - -/* - * Generate a list of variables satisfying the given conditions. - */ - -static char ** -listvars(int on, int off, char ***end) -{ - struct var **vpp; - struct var *vp; - char **ep; - int mask; - - 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); -} - - -/* - * 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 -showvars(const char *sep_prefix, int on, int off) -{ - 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; -} - - +#endif /* FEATURE_SH_EXTRA_QUIET */ /* * The export and readonly commands. */ - static int -exportcmd(int argc, char **argv) +exportcmd(int argc UNUSED_PARAM, char **argv) { struct var *vp; char *name; const char *p; char **aptr; - int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT; - int notp; + int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT; - 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; - continue; + if (nextopt("p") != 'p') { + aptr = argptr; + name = *aptr; + if (name) { + do { + p = strchr(name, '='); + if (p != NULL) { + p++; + } else { + vp = *findvar(hashvar(name), name); + if (vp) { + vp->flags |= flag; + continue; + } } - } - setvar(name, p, flag); - } while ((name = *++aptr) != NULL); - } else { - showvars(argv[0], flag, 0); - } - 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 inline void -mklocal(char *name) -{ - struct localvar *lvp; - struct var **vpp; - struct var *vp; - - INTOFF; - lvp = ckmalloc(sizeof (struct localvar)); - if (name[0] == '-' && name[1] == '\0') { - char *p; - 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 (eq) - setvareq(name, VSTRFIXED); - else - setvar(name, NULL, VSTRFIXED); - vp = *vpp; /* the new variable */ - lvp->flags = VUNSET; - } else { - lvp->text = vp->text; - lvp->flags = vp->flags; - vp->flags |= VSTRFIXED|VTEXTFIXED; - if (eq) - setvareq(name, 0); + setvar(name, p, flag); + } while ((name = *++aptr) != NULL); + return 0; } } - lvp->vp = vp; - lvp->next = localvars; - localvars = lvp; - INTON; -} - -/* - * The "local" command. - */ - -static int -localcmd(int argc, char **argv) -{ - char *name; - - argv = argptr; - while ((name = *argv++) != NULL) { - mklocal(name); - } + showvars(argv[0], flag, 0); return 0; } - - /* - * Called after a function returns. - * Interrupts must be off. + * Delete a function if it exists. */ - static void -poplocalvars(void) +unsetfunc(const char *name) { - struct localvar *lvp; - struct var *vp; + struct tblentry *cmdp; - while ((lvp = localvars) != NULL) { - localvars = lvp->next; - vp = lvp->vp; - 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->func) - (*vp->func)(strchrnul(lvp->text, '=') + 1); - if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0) - ckfree(vp->text); - vp->flags = lvp->flags; - vp->text = lvp->text; - } - ckfree(lvp); - } + cmdp = cmdlookup(name, 0); + if (cmdp!= NULL && cmdp->cmdtype == CMDFUNCTION) + delete_cmd_entry(); } - /* * 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. */ - -int -unsetcmd(int argc, char **argv) +static int +unsetcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { char **ap; int i; @@ -12175,7 +12328,7 @@ unsetcmd(int argc, char **argv) flag = i; } - for (ap = argptr; *ap ; ap++) { + for (ap = argptr; *ap; ap++) { if (flag != 'f') { i = unsetvar(*ap); ret |= i; @@ -12189,218 +12342,95 @@ unsetcmd(int argc, char **argv) } -/* - * Unset the specified variable. - */ +/* setmode.c */ -int -unsetvar(const char *s) -{ - struct var **vpp; - struct var *vp; - int retval; - - vpp = findvar(hashvar(s), s); - vp = *vpp; - retval = 2; - if (vp) { - 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; - ckfree(vp); - INTON; - } else { - setvar(s, 0, 0); - vp->flags &= ~VEXPORT; - } -ok: - retval = 0; - } - -out: - return retval; -} - - - -/* - * Find the appropriate entry in the hash table from the name. - */ - -static struct var ** -hashvar(const char *p) -{ - unsigned int hashval; - - hashval = ((unsigned char) *p) << 4; - while (*p && *p != '=') - hashval += (unsigned char) *p++; - return &vartab[hashval % VTABSIZE]; -} - - - -/* - * 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'. - */ - -int -varcmp(const char *p, const char *q) -{ - int c, d; +#include <sys/times.h> - while ((c = *p) == (d = *q)) { - if (!c || c == '=') - goto out; - p++; - q++; - } - if (c == '=') - c = 0; - if (d == '=') - d = 0; -out: - return c - d; -} +static const unsigned char timescmd_str[] ALIGN1 = { + ' ', offsetof(struct tms, tms_utime), + '\n', offsetof(struct tms, tms_stime), + ' ', offsetof(struct tms, tms_cutime), + '\n', offsetof(struct tms, tms_cstime), + 0 +}; static int -vpcmp(const void *a, const void *b) -{ - return varcmp(*(const char **)a, *(const char **)b); -} - -static struct var ** -findvar(struct var **vpp, const char *name) +timescmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { - for (; *vpp; vpp = &(*vpp)->next) { - if (varequal((*vpp)->text, name)) { - break; - } - } - 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 code for the times builtin. - */ - -#include <sys/times.h> - -int timescmd(int ac, char **av) { + long clk_tck, s, t; + const unsigned char *p; struct tms buf; - long int clk_tck = sysconf(_SC_CLK_TCK); + clk_tck = sysconf(_SC_CLK_TCK); times(&buf); - 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 -static int -dash_arith(const char *s) -{ - long result = 0; - int errcode = 0; - - INTOFF; - result = arith(s, &errcode); - if (errcode < 0) { - if (errcode == -2) - error("divide by zero"); - else - synerror(s); - } - INTON; + p = timescmd_str; + do { + t = *(clock_t *)(((char *) &buf) + p[1]); + s = t / clk_tck; + out1fmt("%ldm%ld.%.3lds%c", + s/60, s%60, + ((t - s * clk_tck) * 1000) / clk_tck, + p[0]); + } while (*(p += 2)); - return (result); + return 0; } - +#if ENABLE_SH_MATH_SUPPORT /* - * The exp(1) builtin. + * The let builtin. partial stolen from GNU Bash, the Bourne Again SHell. + * Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc. + * + * Copyright (C) 2003 Vladimir Oleynik <dzo@simtreas.ru> */ static int -expcmd(int argc, char **argv) +letcmd(int argc UNUSED_PARAM, 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); - } - } else - p = nullstr; + arith_t i; - i = dash_arith(p); + argv++; + if (!*argv) + ash_msg_and_raise_error("expression expected"); + do { + i = ash_arith(*argv); + } while (*++argv); - out1fmt("%ld\n", i); - return (! i); + return !i; } -#endif /* CONFIG_ASH_MATH_SUPPORT */ +#endif /* SH_MATH_SUPPORT */ -/* $NetBSD: miscbltin.c,v 1.31 2002/11/24 22:35:41 christos Exp $ */ -/* - * Miscelaneous builtins. +/* ============ miscbltin.c + * + * Miscellaneous builtins. */ #undef rflag -#ifdef __GLIBC__ -#if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1 +#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. - * + * The read builtin. Options: + * -r Do not interpret '\' specially + * -s Turn off echo (tty only) + * -n NCHARS Read NCHARS max + * -p PROMPT Display PROMPT on stderr (if input is from tty) + * -t SECONDS Timeout after SECONDS (tty or pipe only) + * -u FD Read from given FD instead of fd 0 * This uses unbuffered input, which may be avoidable in some cases. + * TODO: bash also has: + * -a ARRAY Read into array[0],[1],etc + * -d DELIM End on DELIM char, not newline + * -e Use line editing (tty only) */ - static int -readcmd(int argc, char **argv) +readcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { + static const char *const arg_REPLY[] = { "REPLY", NULL }; + char **ap; int backslash; char c; @@ -12411,29 +12441,137 @@ readcmd(int argc, char **argv) int startword; int status; int i; + int fd = 0; +#if ENABLE_ASH_READ_NCHARS + int nchars = 0; /* if != 0, -n is in effect */ + int silent = 0; + struct termios tty, old_tty; +#endif +#if ENABLE_ASH_READ_TIMEOUT + unsigned end_ms = 0; + unsigned timeout = 0; +#endif rflag = 0; prompt = NULL; - while ((i = nextopt("p:r")) != '\0') { - if (i == 'p') + while ((i = nextopt("p:u:r" + USE_ASH_READ_TIMEOUT("t:") + USE_ASH_READ_NCHARS("n:s") + )) != '\0') { + switch (i) { + case 'p': prompt = optionarg; - else + break; +#if ENABLE_ASH_READ_NCHARS + case 'n': + nchars = bb_strtou(optionarg, NULL, 10); + if (nchars < 0 || errno) + ash_msg_and_raise_error("invalid count"); + /* nchars == 0: off (bash 3.2 does this too) */ + break; + case 's': + silent = 1; + break; +#endif +#if ENABLE_ASH_READ_TIMEOUT + case 't': + timeout = bb_strtou(optionarg, NULL, 10); + if (errno || timeout > UINT_MAX / 2048) + ash_msg_and_raise_error("invalid timeout"); + timeout *= 1000; +#if 0 /* even bash have no -t N.NNN support */ + ts.tv_sec = bb_strtou(optionarg, &p, 10); + ts.tv_usec = 0; + /* EINVAL means number is ok, but not terminated by NUL */ + if (*p == '.' && errno == EINVAL) { + char *p2; + if (*++p) { + int scale; + ts.tv_usec = bb_strtou(p, &p2, 10); + if (errno) + ash_msg_and_raise_error("invalid timeout"); + scale = p2 - p; + /* normalize to usec */ + if (scale > 6) + ash_msg_and_raise_error("invalid timeout"); + while (scale++ < 6) + ts.tv_usec *= 10; + } + } else if (ts.tv_sec < 0 || errno) { + ash_msg_and_raise_error("invalid timeout"); + } + if (!(ts.tv_sec | ts.tv_usec)) { /* both are 0? */ + ash_msg_and_raise_error("invalid timeout"); + } +#endif /* if 0 */ + break; +#endif + case 'r': rflag = 1; + break; + case 'u': + fd = bb_strtou(optionarg, NULL, 10); + if (fd < 0 || errno) + ash_msg_and_raise_error("invalid file descriptor"); + break; + default: + break; + } } - if (prompt && isatty(0)) { + if (prompt && isatty(fd)) { out2str(prompt); - flushall(); } - if (*(ap = argptr) == NULL) - error("arg count"); - if ((ifs = bltinlookup("IFS")) == NULL) + ap = argptr; + if (*ap == NULL) + ap = (char**)arg_REPLY; + ifs = bltinlookup("IFS"); + if (ifs == NULL) ifs = defifs; +#if ENABLE_ASH_READ_NCHARS + tcgetattr(fd, &tty); + old_tty = tty; + if (nchars || silent) { + if (nchars) { + tty.c_lflag &= ~ICANON; + tty.c_cc[VMIN] = nchars < 256 ? nchars : 255; + } + if (silent) { + tty.c_lflag &= ~(ECHO | ECHOK | ECHONL); + } + /* if tcgetattr failed, tcsetattr will fail too. + * Ignoring, it's harmless. */ + tcsetattr(fd, TCSANOW, &tty); + } +#endif + status = 0; - startword = 1; + startword = 2; backslash = 0; +#if ENABLE_ASH_READ_TIMEOUT + if (timeout) /* NB: ensuring end_ms is nonzero */ + end_ms = ((unsigned)(monotonic_us() / 1000) + timeout) | 1; +#endif STARTSTACKSTR(p); - for (;;) { - if (read(0, &c, 1) != 1) { + do { + const char *is_ifs; + +#if ENABLE_ASH_READ_TIMEOUT + if (end_ms) { + struct pollfd pfd[1]; + pfd[0].fd = fd; + pfd[0].events = POLLIN; + timeout = end_ms - (unsigned)(monotonic_us() / 1000); + if ((int)timeout <= 0 /* already late? */ + || safe_poll(pfd, 1, timeout) != 1 /* no? wait... */ + ) { /* timed out! */ +#if ENABLE_ASH_READ_NCHARS + tcsetattr(fd, TCSANOW, &old_tty); +#endif + return 1; + } + } +#endif + if (nonblock_safe_read(fd, &c, 1) != 1) { status = 1; break; } @@ -12446,29 +12584,51 @@ readcmd(int argc, char **argv) continue; } if (!rflag && c == '\\') { - backslash++; + backslash = 1; continue; } if (c == '\n') break; - if (startword && *ifs == ' ' && strchr(ifs, c)) { - continue; + /* $IFS splitting */ +/* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05 */ + is_ifs = strchr(ifs, c); + if (startword && is_ifs) { + if (isspace(c)) + continue; + /* it is a non-space ifs char */ + startword--; + if (startword == 1) /* first one? */ + continue; /* yes, it is not next word yet */ } startword = 0; - if (ap[1] != NULL && strchr(ifs, c) != NULL) { + if (ap[1] != NULL && is_ifs) { + const char *beg; STACKSTRNUL(p); - setvar(*ap, stackblock(), 0); + beg = stackblock(); + setvar(*ap, beg, 0); ap++; - startword = 1; + /* can we skip one non-space ifs char? (2: yes) */ + startword = isspace(c) ? 2 : 1; STARTSTACKSTR(p); - } else { -put: - STPUTC(c, p); + continue; } + put: + STPUTC(c, p); } +/* end of do {} while: */ +#if ENABLE_ASH_READ_NCHARS + while (--nchars); +#else + while (1); +#endif + +#if ENABLE_ASH_READ_NCHARS + tcsetattr(fd, TCSANOW, &old_tty); +#endif + STACKSTRNUL(p); - /* Remove trailing blanks */ - while ((char *)stackblock() <= --p && strchr(ifs, *p) != NULL) + /* Remove trailing space ifs chars */ + while ((char *)stackblock() <= --p && isspace(*p) && strchr(ifs, *p) != NULL) *p = '\0'; setvar(*ap, stackblock(), 0); while (*++ap != NULL) @@ -12476,12 +12636,12 @@ put: return status; } - -static int umaskcmd(int argc, char **argv) +static int +umaskcmd(int argc UNUSED_PARAM, char **argv) { - static const char permuser[3] = "ugo"; - static const char permmode[3] = "rwx"; - static const short int permmask[] = { + static const char permuser[3] ALIGN1 = "ugo"; + static const char permmode[3] ALIGN1 = "rwx"; + static const short permmask[] ALIGN2 = { S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH @@ -12496,12 +12656,13 @@ static int umaskcmd(int argc, char **argv) symbolic_mode = 1; } - INTOFF; + INT_OFF; mask = umask(0); umask(mask); - INTON; + INT_ON; - if ((ap = *argptr) == NULL) { + ap = *argptr; + if (ap == NULL) { if (symbolic_mode) { char buf[18]; char *p = buf; @@ -12524,18 +12685,18 @@ static int umaskcmd(int argc, char **argv) out1fmt("%.4o\n", mask); } } else { - if (is_digit((unsigned char) *ap)) { + if (isdigit((unsigned char) *ap)) { mask = 0; do { if (*ap >= '8' || *ap < '0') - error(illnum, argv[1]); + ash_msg_and_raise_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); + ash_msg_and_raise_error("illegal mode: %s", ap); } umask(~mask & 0777); } @@ -12554,63 +12715,149 @@ static int umaskcmd(int argc, char **argv) */ struct limits { - const char *name; - int cmd; - int factor; /* multiply by to get rlim_{cur,max} values */ + uint8_t cmd; /* RLIMIT_xxx fit into it */ + uint8_t factor_shift; /* shift by to get rlim_{cur,max} values */ char option; }; -static const struct limits limits[] = { +static const struct limits limits_tbl[] = { #ifdef RLIMIT_CPU - { "time(seconds)", RLIMIT_CPU, 1, 't' }, + { RLIMIT_CPU, 0, 't' }, #endif #ifdef RLIMIT_FSIZE - { "file(blocks)", RLIMIT_FSIZE, 512, 'f' }, + { RLIMIT_FSIZE, 9, 'f' }, #endif #ifdef RLIMIT_DATA - { "data(kbytes)", RLIMIT_DATA, 1024, 'd' }, + { RLIMIT_DATA, 10, 'd' }, #endif #ifdef RLIMIT_STACK - { "stack(kbytes)", RLIMIT_STACK, 1024, 's' }, + { RLIMIT_STACK, 10, 's' }, #endif -#ifdef RLIMIT_CORE - { "coredump(blocks)", RLIMIT_CORE, 512, 'c' }, +#ifdef RLIMIT_CORE + { RLIMIT_CORE, 9, 'c' }, #endif #ifdef RLIMIT_RSS - { "memory(kbytes)", RLIMIT_RSS, 1024, 'm' }, + { RLIMIT_RSS, 10, 'm' }, #endif #ifdef RLIMIT_MEMLOCK - { "locked memory(kbytes)", RLIMIT_MEMLOCK, 1024, 'l' }, + { RLIMIT_MEMLOCK, 10, 'l' }, #endif #ifdef RLIMIT_NPROC - { "process(processes)", RLIMIT_NPROC, 1, 'p' }, + { RLIMIT_NPROC, 0, 'p' }, #endif #ifdef RLIMIT_NOFILE - { "nofiles(descriptors)", RLIMIT_NOFILE, 1, 'n' }, + { RLIMIT_NOFILE, 0, 'n' }, #endif -#ifdef RLIMIT_VMEM - { "vmemory(kbytes)", RLIMIT_VMEM, 1024, 'v' }, +#ifdef RLIMIT_AS + { RLIMIT_AS, 10, 'v' }, #endif -#ifdef RLIMIT_SWAP - { "swap(kbytes)", RLIMIT_SWAP, 1024, 'w' }, +#ifdef RLIMIT_LOCKS + { RLIMIT_LOCKS, 0, 'w' }, #endif - { (char *) 0, 0, 0, '\0' } }; +static const char limits_name[] = +#ifdef RLIMIT_CPU + "time(seconds)" "\0" +#endif +#ifdef RLIMIT_FSIZE + "file(blocks)" "\0" +#endif +#ifdef RLIMIT_DATA + "data(kb)" "\0" +#endif +#ifdef RLIMIT_STACK + "stack(kb)" "\0" +#endif +#ifdef RLIMIT_CORE + "coredump(blocks)" "\0" +#endif +#ifdef RLIMIT_RSS + "memory(kb)" "\0" +#endif +#ifdef RLIMIT_MEMLOCK + "locked memory(kb)" "\0" +#endif +#ifdef RLIMIT_NPROC + "process" "\0" +#endif +#ifdef RLIMIT_NOFILE + "nofiles" "\0" +#endif +#ifdef RLIMIT_AS + "vmemory(kb)" "\0" +#endif +#ifdef RLIMIT_LOCKS + "locks" "\0" +#endif +; + +enum limtype { SOFT = 0x1, HARD = 0x2 }; + +static void +printlim(enum limtype how, const struct rlimit *limit, + const struct limits *l) +{ + rlim_t val; + + val = limit->rlim_max; + if (how & SOFT) + val = limit->rlim_cur; + + if (val == RLIM_INFINITY) + out1fmt("unlimited\n"); + else { + val >>= l->factor_shift; + out1fmt("%lld\n", (long long) val); + } +} -int -ulimitcmd(int argc, char **argv) +static int +ulimitcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM) { - int c; + 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; + enum limtype how = SOFT | HARD; + const struct limits *l; + int set, all = 0; + int optc, what; + struct rlimit limit; what = 'f'; - while ((optc = nextopt("HSatfdsmcnpl")) != '\0') + 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_AS + "v" +#endif +#ifdef RLIMIT_LOCKS + "w" +#endif + )) != '\0') switch (optc) { case 'H': how = HARD; @@ -12625,49 +12872,38 @@ ulimitcmd(int argc, char **argv) what = optc; } - for (l = limits; l->name && l->option != what; l++) - ; - if (!l->name) - error("internal error (%c)", what); + for (l = limits_tbl; l->option != what; l++) + continue; set = *argptr ? 1 : 0; if (set) { char *p = *argptr; if (all || argptr[1]) - error("too many arguments"); + ash_msg_and_raise_error("too many arguments"); if (strncmp(p, "unlimited\n", 9) == 0) val = RLIM_INFINITY; else { val = (rlim_t) 0; - while ((c = *p++) >= '0' && c <= '9') - { + while ((c = *p++) >= '0' && c <= '9') { val = (val * 10) + (long)(c - '0'); + // val is actually 'unsigned long int' and can't get < 0 if (val < (rlim_t) 0) break; } if (c) - error("bad number"); - val *= l->factor; + ash_msg_and_raise_error("bad number"); + val <<= l->factor_shift; } } if (all) { - for (l = limits; l->name; l++) { + const char *lname = limits_name; + for (l = limits_tbl; l != &limits_tbl[ARRAY_SIZE(limits_tbl)]; 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); - } + out1fmt("%-20s ", lname); + lname += strlen(lname) + 1; + printlim(how, &limit, l); } return 0; } @@ -12679,31 +12915,336 @@ ulimitcmd(int argc, char **argv) if (how & SOFT) limit.rlim_cur = val; if (setrlimit(l->cmd, &limit) < 0) - error("error setting limit (%m)"); + ash_msg_and_raise_error("error setting limit (%m)"); } else { - if (how & SOFT) - val = limit.rlim_cur; - else if (how & HARD) - val = limit.rlim_max; + printlim(how, &limit, l); + } + return 0; +} - if (val == RLIM_INFINITY) - out1fmt("unlimited\n"); - else - { - val /= l->factor; - out1fmt("%lld\n", (long long) val); +/* ============ main() and helpers */ + +/* + * Called to exit the shell. + */ +static void exitshell(void) NORETURN; +static void +exitshell(void) +{ + struct jmploc loc; + char *p; + int status; + + status = exitstatus; + TRACE(("pid %d, exitshell(%d)\n", getpid(), status)); + if (setjmp(loc.loc)) { + if (exception_type == EXEXIT) +/* dash bug: it just does _exit(exitstatus) here + * but we have to do setjobctl(0) first! + * (bug is still not fixed in dash-0.5.3 - if you run dash + * under Midnight Commander, on exit from dash MC is backgrounded) */ + status = exitstatus; + goto out; + } + exception_handler = &loc; + p = trap[0]; + if (p) { + trap[0] = NULL; + evalstring(p, 0); + } + flush_stdout_stderr(); + out: + setjobctl(0); + _exit(status); + /* NOTREACHED */ +} + +static void +init(void) +{ + /* from input.c: */ + basepf.next_to_pgetc = basepf.buf = basebuf; + + /* from trap.c: */ + signal(SIGCHLD, SIG_DFL); + + /* from var.c: */ + { + char **envp; + char ppid[sizeof(int)*3 + 1]; + const char *p; + struct stat st1, st2; + + initvar(); + for (envp = environ; envp && *envp; envp++) { + if (strchr(*envp, '=')) { + setvareq(*envp, VEXPORT|VTEXTFIXED); + } } + + snprintf(ppid, sizeof(ppid), "%u", (unsigned) getppid()); + setvar("PPID", ppid, 0); + + p = lookupvar("PWD"); + if (p) + if (*p != '/' || stat(p, &st1) || stat(".", &st2) + || st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) + p = '\0'; + setpwd(p, 0); } - return 0; } -#ifdef DEBUG -const char *bb_applet_name = "debug stuff usage"; -int main(int argc, char **argv) +/* + * Process the shell command line arguments. + */ +static void +procargs(char **argv) +{ + int i; + const char *xminusc; + char **xargv; + + xargv = argv; + arg0 = xargv[0]; + /* if (xargv[0]) - mmm, this is always true! */ + xargv++; + for (i = 0; i < NOPTS; i++) + optlist[i] = 2; + argptr = xargv; + if (options(1)) { + /* it already printed err message */ + raise_exception(EXERROR); + } + xargv = argptr; + xminusc = minusc; + if (*xargv == NULL) { + if (xminusc) + ash_msg_and_raise_error(bb_msg_requires_arg, "-c"); + 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 (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; + } + + shellparam.p = xargv; +#if ENABLE_ASH_GETOPTS + shellparam.optind = 1; + shellparam.optoff = -1; +#endif + /* assert(shellparam.malloced == 0 && shellparam.nparam == 0); */ + while (*xargv) { + shellparam.nparam++; + xargv++; + } + optschanged(); +} + +/* + * Read /etc/profile or .profile. + */ +static void +read_profile(const char *name) { - return ash_main(argc, argv); + int skip; + + if (setinputfile(name, INPUT_PUSH_FILE | INPUT_NOFILE_OK) < 0) + return; + skip = cmdloop(0); + popfile(); + if (skip) + exitshell(); } + +/* + * 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; + /* from input.c: */ + g_parsefile->left_in_buffer = 0; + g_parsefile->left_in_line = 0; /* clear input buffer */ + popallfiles(); + /* from parser.c: */ + tokpushback = 0; + checkkwd = 0; + /* from redir.c: */ + clearredir(/*drop:*/ 0); +} + +#if PROFILE +static short profile_buf[16384]; +extern int etext(); +#endif + +/* + * Main routine. We initialize things, parse the arguments, execute + * profiles if we're a login shell, and then call cmdloop to execute + * commands. The setjmp call sets up the location to jump to when an + * exception occurs. When an exception occurs the variable "state" + * is used to figure out how far we had gotten. + */ +int ash_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int ash_main(int argc UNUSED_PARAM, char **argv) +{ + const char *shinit; + volatile smallint state; + struct jmploc jmploc; + struct stackmark smark; + + /* Initialize global data */ + INIT_G_misc(); + INIT_G_memstack(); + INIT_G_var(); +#if ENABLE_ASH_ALIAS + INIT_G_alias(); #endif + INIT_G_cmdtable(); + +#if PROFILE + monitor(4, etext, profile_buf, sizeof(profile_buf), 50); +#endif + +#if ENABLE_FEATURE_EDITING + line_input_state = new_line_input_t(FOR_SHELL | WITH_PATH_LOOKUP); +#endif + state = 0; + if (setjmp(jmploc.loc)) { + smallint e; + smallint s; + + reset(); + + e = exception_type; + if (e == EXERROR) + exitstatus = 2; + s = state; + if (e == EXEXIT || s == 0 || iflag == 0 || shlvl) + exitshell(); + if (e == EXINT) + outcslow('\n', stderr); + + popstackmark(&smark); + FORCE_INT_ON; /* enable interrupts */ + if (s == 1) + goto state1; + if (s == 2) + goto state2; + if (s == 3) + goto state3; + goto state4; + } + exception_handler = &jmploc; +#if DEBUG + opentrace(); + TRACE(("Shell args: ")); + trace_puts_args(argv); +#endif + rootpid = getpid(); + +#if ENABLE_ASH_RANDOM_SUPPORT + /* Can use monotonic_ns() for better randomness but for now it is + * not used anywhere else in busybox... so avoid bloat */ + random_galois_LFSR = random_LCG = rootpid + monotonic_us(); +#endif + init(); + setstackmark(&smark); + procargs(argv); + +#if ENABLE_FEATURE_EDITING_SAVEHISTORY + if (iflag) { + const char *hp = lookupvar("HISTFILE"); + + if (hp == NULL) { + hp = lookupvar("HOME"); + if (hp != NULL) { + char *defhp = concat_path_file(hp, ".ash_history"); + setvar("HISTFILE", defhp, 0); + free(defhp); + } + } + } +#endif + if (/* argv[0] && */ argv[0][0] == '-') + isloginsh = 1; + if (isloginsh) { + state = 1; + read_profile("/etc/profile"); + state1: + state = 2; + read_profile(".profile"); + } + state2: + state = 3; + if ( +#ifndef linux + getuid() == geteuid() && getgid() == getegid() && +#endif + iflag + ) { + shinit = lookupvar("ENV"); + if (shinit != NULL && *shinit != '\0') { + read_profile(shinit); + } + } + state3: + state = 4; + if (minusc) { + /* evalstring pushes parsefile stack. + * Ensure we don't falsely claim that 0 (stdin) + * is one of stacked source fds. + * Testcase: ash -c 'exec 1>&0' must not complain. */ + if (!sflag) + g_parsefile->fd = -1; + evalstring(minusc, 0); + } + + if (sflag || minusc == NULL) { +#if ENABLE_FEATURE_EDITING_SAVEHISTORY + if (iflag) { + const char *hp = lookupvar("HISTFILE"); + if (hp) + line_input_state->hist_file = hp; + } +#endif + state4: /* XXX ??? - why isn't this before the "if" statement */ + cmdloop(1); + } +#if PROFILE + monitor(0); +#endif +#ifdef GPROF + { + extern void _mcleanup(void); + _mcleanup(); + } +#endif + exitshell(); + /* NOTREACHED */ +} + /*- * Copyright (c) 1989, 1991, 1993, 1994 @@ -12720,11 +13261,7 @@ int main(int argc, char **argv) * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * - * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change - * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change> - * - * 4. Neither the name of the University nor the names of its contributors + * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * |